implement Timedelta mod, divmod, rmod, rdivmod, fix and test scalar methods

doc/source/whatsnew/v0.23.0.txt

@@ -419,6 +419,7 @@ Datetimelike
 - Bug in ``.astype()`` to non-ns timedelta units would hold the incorrect dtype (:issue:`19176`, :issue:`19223`, :issue:`12425`)
 - Bug in subtracting :class:`Series` from ``NaT`` incorrectly returning ``NaT`` (:issue:`19158`)
 - Bug in :func:`Series.truncate` which raises ``TypeError`` with a monotonic ``PeriodIndex`` (:issue:`17717`)
+- Bug :func:`Timedelta.__mod__`, :func:`Timedelta.__divmod__` where operating with timedelta-like or numeric arguments would incorrectly raise ``TypeError`` (:issue:`19365`)
 
 Timezones
 ^^^^^^^^^

pandas/_libs/tslibs/timedeltas.pyx

@@ -492,7 +492,14 @@ def _binary_op_method_timedeltalike(op, name):
             if other.dtype.kind not in ['m', 'M']:
                 # raise rathering than letting numpy return wrong answer
                 return NotImplemented
-            return op(self.to_timedelta64(), other)
+            result = op(self.to_timedelta64(), other)
+            if other.ndim == 0:
+                if other.dtype.kind == 'm':
+                    return Timedelta(result)
+                if other.dtype.kind == 'M':
+                    from ..tslib import Timestamp
+                    return Timestamp(result)
+            return result
 
         elif not _validate_ops_compat(other):
             return NotImplemented
@@ -1046,7 +1053,10 @@ class Timedelta(_Timedelta):
     def __mul__(self, other):
         if hasattr(other, 'dtype'):
             # ndarray-like
-            return other * self.to_timedelta64()
+            result = other * self.to_timedelta64()
+            if other.ndim == 0:
+                return Timedelta(result)
+            return result
 
         elif other is NaT:
             return NaT
@@ -1061,7 +1071,10 @@ class Timedelta(_Timedelta):
 
     def __truediv__(self, other):
         if hasattr(other, 'dtype'):
-            return self.to_timedelta64() / other
+            result = self.to_timedelta64() / other
+            if other.ndim == 0 and result.dtype.kind == 'm':
+                return Timedelta(result)
+            return result
 
         elif is_integer_object(other) or is_float_object(other):
             # integers or floats
@@ -1077,7 +1090,10 @@ class Timedelta(_Timedelta):
 
     def __rtruediv__(self, other):
         if hasattr(other, 'dtype'):
-            return other / self.to_timedelta64()
+            result = other / self.to_timedelta64()
+            if other.ndim == 0 and result.dtype.kind == 'm':
+                return Timedelta(result)
+            return result
 
         elif not _validate_ops_compat(other):
             return NotImplemented
@@ -1096,6 +1112,9 @@ class Timedelta(_Timedelta):
         # just defer
         if hasattr(other, '_typ'):
             # Series, DataFrame, ...
+            if other._typ == 'dateoffset' and hasattr(other, 'delta'):
+                # Tick offset
+                return self // other.delta
             return NotImplemented
 
         if hasattr(other, 'dtype'):
@@ -1128,6 +1147,9 @@ class Timedelta(_Timedelta):
         # just defer
         if hasattr(other, '_typ'):
             # Series, DataFrame, ...
+            if other._typ == 'dateoffset' and hasattr(other, 'delta'):
+                # Tick offset
+                return other.delta // self
             return NotImplemented
 
         if hasattr(other, 'dtype'):
@@ -1149,6 +1171,23 @@ class Timedelta(_Timedelta):
             return np.nan
         return other.value // self.value
 
+    def __mod__(self, other):
+        # Naive implementation, room for optimization
+        return self.__divmod__(other)[1]
+
+    def __rmod__(self, other):
+        # Naive implementation, room for optimization
+        return self.__rdivmod__(other)[1]
+
+    def __divmod__(self, other):
+        # Naive implementation, room for optimization
+        div = self // other
+        return div, self - div * other
+
+    def __rdivmod__(self, other):
+        div = other // self
+        return div, other - div * self
+
 
 cdef _floordiv(int64_t value, right):
     return value // right

pandas/tests/scalar/test_timedelta.py

@@ -2,7 +2,7 @@
 import pytest
 
 import numpy as np
-from datetime import timedelta
+from datetime import datetime, timedelta
 
 import pandas as pd
 import pandas.util.testing as tm
@@ -128,6 +128,59 @@ def test_unary_ops(self):
         assert abs(-td) == td
         assert abs(-td) == Timedelta('10d')
 
+    def test_mul(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+
+        result = td * 2
+        assert result == Timedelta(minutes=6)
+
+        result = td * np.int64(1)
+        assert isinstance(result, Timedelta)
+        assert result == td
+
+        result = td * 1.5
+        assert result == Timedelta(minutes=4, seconds=30)
+
+        result = td * np.array([3, 4], dtype='int64')
+        expected = np.array([9, 12], dtype='m8[m]').astype('m8[ns]')
+        tm.assert_numpy_array_equal(result, expected)
+
+        with pytest.raises(TypeError):
+            td * pd.Timestamp(2016, 1, 2)
+
+    def test_add_datetimelike(self):
+        # GH#19365
+        td = Timedelta(10, unit='d')
+
+        result = td + datetime(2016, 1, 1)
+        assert result == pd.Timestamp(2016, 1, 11)
+
+        result = td + pd.Timestamp('2018-01-12 18:09')
+        assert result == pd.Timestamp('2018-01-22 18:09')
+
+        result = td + np.datetime64('2018-01-12')
+        assert result == pd.Timestamp('2018-01-22')
+
+    def test_add_timedeltalike(self):
+        td = Timedelta(10, unit='d')
+
+        result = td + Timedelta(days=10)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=20)
+
+        result = td + timedelta(days=9)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=19)
+
+        result = td + pd.offsets.Hour(6)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=10, hours=6)
+
+        result = td + np.timedelta64(-4, 'D')
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=6)
+
     def test_binary_ops_nat(self):
         td = Timedelta(10, unit='d')
 
@@ -138,6 +191,10 @@ def test_binary_ops_nat(self):
         assert (td // pd.NaT) is np.nan
         assert (td // np.timedelta64('NaT')) is np.nan
 
+        # GH#19365
+        assert td - np.timedelta64('NaT') is pd.NaT
+        assert td + np.timedelta64('NaT') is pd.NaT
+
     def test_binary_ops_integers(self):
         td = Timedelta(10, unit='d')
 
@@ -173,6 +230,10 @@ def test_floordiv(self):
         assert -td // scalar.to_pytimedelta() == -2
         assert (2 * td) // scalar.to_timedelta64() == 2
 
+        # GH#19365
+        assert td // pd.offsets.Hour(1) == 3
+        assert td // pd.offsets.Minute(2) == 92
+
         assert td // np.nan is pd.NaT
         assert np.isnan(td // pd.NaT)
         assert np.isnan(td // np.timedelta64('NaT'))
@@ -218,6 +279,8 @@ def test_rfloordiv(self):
         assert (-td).__rfloordiv__(scalar.to_pytimedelta()) == -2
         assert (2 * td).__rfloordiv__(scalar.to_timedelta64()) == 0
 
+        assert pd.offsets.Hour(1) // Timedelta(minutes=25) == 2
+
         assert np.isnan(td.__rfloordiv__(pd.NaT))
         assert np.isnan(td.__rfloordiv__(np.timedelta64('NaT')))
 
@@ -255,6 +318,125 @@ def test_rfloordiv(self):
         with pytest.raises(TypeError):
             ser // td
 
+    def test_mod(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        # Timedelta-like others
+        result = td % Timedelta(hours=6)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=1)
+
+        result = td % timedelta(minutes=60)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(0)
+
+        result = td % pd.offsets.Hour(5)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=2)
+
+        result = td % np.timedelta64(2, 'h')
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=1)
+
+        result = td % NaT
+        assert result is NaT
+
+        result = td % np.timedelta64('NaT')
+        assert result is NaT
+
+        # Numeric Others
+        result = td % 2
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(0)
+
+        result = td % 1e12
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=3, seconds=20)
+
+        result = td % int(1e12)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=3, seconds=20)
+
+        # Invalid Others
+        with pytest.raises(TypeError):
+            td % pd.Timestamp('2018-01-22')
+
+        # Array-like others
+        result = td % np.array([6, 5], dtype='timedelta64[h]')
+        expected = np.array([1, 2], dtype='timedelta64[h]').astype('m8[ns]')
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = td % pd.TimedeltaIndex(['6H', '5H'])
+        expected = pd.TimedeltaIndex(['1H', '2H'])
+        tm.assert_index_equal(result, expected)
+
+        result = td % np.array([2, int(1e12)], dtype='i8')
+        expected = np.array([0, Timedelta(minutes=3, seconds=20).value],
+                            dtype='m8[ns]')
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_rmod(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+
+        result = timedelta(minutes=4) % td
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=1)
+
+        result = np.timedelta64(5, 'm') % td
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=2)
+
+        result = np.array([5, 6], dtype='m8[m]') % td
+        expected = np.array([2, 0], dtype='m8[m]').astype('m8[ns]')
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_divmod(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        result = divmod(td, timedelta(days=1))
+        assert result[0] == 2
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=6)
+
+        result = divmod(td, pd.offsets.Hour(-4))
+        assert result[0] == -14
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=-2)
+
+        result = divmod(td, 54)
+        assert result[0] == Timedelta(hours=1)
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(0)
+
+        result = divmod(td, 53 * 3600 * 1e9)
+        assert result[0] == Timedelta(1, unit='ns')
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=1)
+
+        assert result
+        result = divmod(td, np.nan)
+        assert result[0] is pd.NaT
+        assert result[1] is pd.NaT
+
+        result = divmod(td, pd.NaT)
+        assert np.isnan(result[0])
+        assert result[1] is pd.NaT
+
+    def test_rdivmod(self):
+        # GH#19365
+        result = divmod(timedelta(days=2, hours=6), Timedelta(days=1))
+        assert result[0] == 2
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=6)
+
+        result = divmod(pd.offsets.Hour(54), Timedelta(hours=-4))
+        assert result[0] == -14
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=-2)
+
 
 class TestTimedeltaComparison(object):
     def test_comparison_object_array(self):