Fix incorrect exception raised by Series[datetime64] + int

pandas/core/indexes/datetimelike.py

@@ -32,6 +32,7 @@
 from pandas.core import common as com, algorithms
 from pandas.core.algorithms import checked_add_with_arr
 from pandas.core.common import AbstractMethodError
+from pandas.errors import NullFrequencyError
 
 import pandas.io.formats.printing as printing
 from pandas._libs import lib, iNaT, NaT
@@ -692,6 +693,9 @@ def __add__(self, other):
                 return self._add_datelike(other)
             elif isinstance(other, Index):
                 return self._add_datelike(other)
+            elif is_integer_dtype(other) and self.freq is None:
+                # GH#19123
+                raise NullFrequencyError("Cannot shift with no freq")
             else:  # pragma: no cover
                 return NotImplemented
 
@@ -731,7 +735,9 @@ def __sub__(self, other):
                 raise TypeError("cannot subtract {typ1} and {typ2}"
                                 .format(typ1=type(self).__name__,
                                         typ2=type(other).__name__))
-
+            elif is_integer_dtype(other) and self.freq is None:
+                # GH#19123
+                raise NullFrequencyError("Cannot shift with no freq")
             else:  # pragma: no cover
                 return NotImplemented
 
@@ -831,7 +837,7 @@ def shift(self, n, freq=None):
             return self
 
         if self.freq is None:
-            raise ValueError("Cannot shift with no freq")
+            raise NullFrequencyError("Cannot shift with no freq")
 
         start = self[0] + n * self.freq
         end = self[-1] + n * self.freq

pandas/core/ops.py

@@ -20,7 +20,7 @@
 from pandas.compat import bind_method
 import pandas.core.missing as missing
 
-from pandas.errors import PerformanceWarning
+from pandas.errors import PerformanceWarning, NullFrequencyError
 from pandas.core.common import _values_from_object, _maybe_match_name
 from pandas.core.dtypes.missing import notna, isna
 from pandas.core.dtypes.common import (
@@ -672,9 +672,8 @@ def wrapper(left, right, name=name, na_op=na_op):
 
         left, right = _align_method_SERIES(left, right)
         if is_datetime64_dtype(left) or is_datetime64tz_dtype(left):
-            result = op(pd.DatetimeIndex(left), right)
+            result = dispatch_to_index_op(op, left, right, pd.DatetimeIndex)
             res_name = _get_series_op_result_name(left, right)
-            result.name = res_name  # needs to be overriden if None
             return construct_result(left, result,
                                     index=left.index, name=res_name,
                                     dtype=result.dtype)
@@ -703,6 +702,39 @@ def wrapper(left, right, name=name, na_op=na_op):
     return wrapper
 
 
+def dispatch_to_index_op(op, left, right, index_class):
+    """
+    Wrap Series left in the given index_class to delegate the operation op
+    to the index implementation.  DatetimeIndex and TimedeltaIndex perform
+    type checking, timezone handling, overflow checks, etc.
+
+    Parameters
+    ----------
+    op : binary operator (operator.add, operator.sub, ...)
+    left : Series
+    right : object
+    index_class : DatetimeIndex or TimedeltaIndex
+
+    Returns
+    -------
+    result : object, usually DatetimeIndex, TimedeltaIndex, or Series
+    """
+    left_idx = index_class(left)
+
+    # avoid accidentally allowing integer add/sub.  For datetime64[tz] dtypes,
+    # left_idx may inherit a freq from a cached DatetimeIndex.
+    # See discussion in GH#19147.
+    left_idx.freq = None
+    try:
+        result = op(left_idx, right)
+    except NullFrequencyError:
+        # DatetimeIndex and TimedeltaIndex with freq == None raise ValueError
+        # on add/sub of integers (or int-like).  We re-raise as a TypeError.
+        raise TypeError('incompatible type for a datetime/timedelta '
+                        'operation [{name}]'.format(name=op.__name__))
+    return result
+
+
 def _get_series_op_result_name(left, right):
     # `left` is always a pd.Series
     if isinstance(right, (ABCSeries, pd.Index)):

pandas/errors/__init__.py

@@ -65,3 +65,11 @@ class MergeError(ValueError):
     Error raised when problems arise during merging due to problems
     with input data. Subclass of `ValueError`.
     """
+
+
+class NullFrequencyError(ValueError):
+    """
+    Error raised when a null `freq` attribute is used in an operation
+    that needs a non-null frequency, particularly `DatetimeIndex.shift`,
+    `TimedeltaIndex.shift`, `PeriodIndex.shift`.
+    """

pandas/tests/series/test_operators.py

@@ -680,6 +680,25 @@ def test_timedelta_series_ops(self):
         assert_series_equal(ts - s, expected2)
         assert_series_equal(ts + (-s), expected2)
 
+    def test_td64series_add_intlike(self):
+        # GH#19123
+        tdi = pd.TimedeltaIndex(['59 days', '59 days', 'NaT'])
+        ser = Series(tdi)
+
+        other = Series([20, 30, 40], dtype='uint8')
+
+        pytest.raises(TypeError, ser.__add__, 1)
+        pytest.raises(TypeError, ser.__sub__, 1)
+
+        pytest.raises(TypeError, ser.__add__, other)
+        pytest.raises(TypeError, ser.__sub__, other)
+
+        pytest.raises(TypeError, ser.__add__, other.values)
+        pytest.raises(TypeError, ser.__sub__, other.values)
+
+        pytest.raises(TypeError, ser.__add__, pd.Index(other))
+        pytest.raises(TypeError, ser.__sub__, pd.Index(other))
+
     def test_timedelta64_operations_with_integers(self):
         # GH 4521
         # divide/multiply by integers
@@ -739,12 +758,6 @@ def test_timedelta64_operations_with_integers(self):
                             Series([Timedelta('29 days 12:00:00'), Timedelta(
                                 '29 days 12:00:00'), Timedelta('NaT')]))
 
-        for op in ['__add__', '__sub__']:
-            sop = getattr(s1, op, None)
-            if sop is not None:
-                pytest.raises(TypeError, sop, 1)
-                pytest.raises(TypeError, sop, s2.values)
-
     def test_timedelta64_operations_with_DateOffset(self):
         # GH 10699
         td = Series([timedelta(minutes=5, seconds=3)] * 3)
@@ -1428,6 +1441,25 @@ def test_dt64series_arith_overflow(self):
         res = dt - ser
         tm.assert_series_equal(res, -expected)
 
+    def test_dt64series_add_intlike(self):
+        # GH#19123
+        dti = pd.DatetimeIndex(['2016-01-02', '2016-02-03', 'NaT'])
+        ser = Series(dti)
+
+        other = Series([20, 30, 40], dtype='uint8')
+
+        pytest.raises(TypeError, ser.__add__, 1)
+        pytest.raises(TypeError, ser.__sub__, 1)
+
+        pytest.raises(TypeError, ser.__add__, other)
+        pytest.raises(TypeError, ser.__sub__, other)
+
+        pytest.raises(TypeError, ser.__add__, other.values)
+        pytest.raises(TypeError, ser.__sub__, other.values)
+
+        pytest.raises(TypeError, ser.__add__, pd.Index(other))
+        pytest.raises(TypeError, ser.__sub__, pd.Index(other))
+
 
 class TestSeriesOperators(TestData):
     def test_op_method(self):

pandas/tseries/offsets.py

@@ -1233,7 +1233,8 @@ def _get_roll(self, i, before_day_of_month, after_day_of_month):
         return roll
 
     def _apply_index_days(self, i, roll):
-        i += (roll % 2) * Timedelta(days=self.day_of_month).value
+        nanos = (roll % 2) * Timedelta(days=self.day_of_month).value
+        i += nanos.astype('timedelta64[ns]')
         return i + Timedelta(days=-1)
 
 
@@ -1278,7 +1279,8 @@ def _get_roll(self, i, before_day_of_month, after_day_of_month):
         return roll
 
     def _apply_index_days(self, i, roll):
-        return i + (roll % 2) * Timedelta(days=self.day_of_month - 1).value
+        nanos = (roll % 2) * Timedelta(days=self.day_of_month - 1).value
+        return i + nanos.astype('timedelta64[ns]')
 
 
 # ---------------------------------------------------------------------