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

doc/source/timedeltas.rst

@@ -283,6 +283,18 @@ Rounded division (floor-division) of a ``timedelta64[ns]`` Series by a scalar
    td // pd.Timedelta(days=3, hours=4)
    pd.Timedelta(days=3, hours=4) // td
 
+The mod (%) and divmod operations are defined for ``Timedelta`` when operating with another timedelta-like or with a numeric argument.
+
+.. ipython:: python
+
+   pd.Timedelta(hours=37) % datetime.timedelta(hours=2)
+
+   # divmod against a timedelta-like returns a pair (int, Timedelta)
+   divmod(datetime.timedelta(hours=2), pd.Timedelta(minutes=11))
+
+   # divmod against a numeric returns a pair (Timedelta, Timedelta)
+   pd.Timedelta(hours=25) % 86400000000000
+
 Attributes
 ----------
 

doc/source/whatsnew/v0.23.0.txt

@@ -117,6 +117,25 @@ resetting indexes. See the :ref:`Sorting by Indexes and Values
    # Sort by 'second' (index) and 'A' (column)
    df_multi.sort_values(by=['second', 'A'])
 
+.. _whatsnew_0230.enhancements.timedelta_mod
+
+Timedelta mod method
+^^^^^^^^^^^^^^^^^^^^
+
+``mod`` (%) and ``divmod`` operations are now defined on ``Timedelta`` objects when operating with either timedelta-like or with numeric arguments. (:issue:`19365`)
+
+.. ipython:: python
+
+    td = pd.Timedelta(hours=37)
+    td
+
+Current Behavior
+
+.. ipython:: python
+
+    td % pd.Timedelta(hours=2)
+    divmod(td, np.array([2, 3], dtype='timedelta64[h]'))
+
 .. _whatsnew_0230.enhancements.ran_inf:
 
 ``.rank()`` handles ``inf`` values when ``NaN`` are present
@@ -438,6 +457,7 @@ Other API Changes
 - Set operations (union, difference...) on :class:`IntervalIndex` with incompatible index types will now raise a ``TypeError`` rather than a ``ValueError`` (:issue:`19329`)
 - :class:`DateOffset` objects render more simply, e.g. "<DateOffset: days=1>" instead of "<DateOffset: kwds={'days': 1}>" (:issue:`19403`)
 - :func:`pandas.merge` provides a more informative error message when trying to merge on timezone-aware and timezone-naive columns (:issue:`15800`)
+- :func:`Timedelta.__mod__`, :func:`Timedelta.__divmod__` now accept timedelta-like and numeric arguments instead of raising ``TypeError`` (:issue:`19365`)
 
 .. _whatsnew_0230.deprecations:
 
@@ -552,6 +572,7 @@ Datetimelike
 - Bug in comparison of :class:`DatetimeIndex` against ``None`` or ``datetime.date`` objects raising ``TypeError`` for ``==`` and ``!=`` comparisons instead of all-``False`` and all-``True``, respectively (:issue:`19301`)
 -
 
+
 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