REF: re-use convert_reso (#47807)

* REF: re-use convert_reso

* typo fixup

Author: jbrockmendel

pandas/_libs/tslibs/np_datetime.pxd

@@ -109,3 +109,10 @@ cdef bint cmp_dtstructs(npy_datetimestruct* left, npy_datetimestruct* right, int
 cdef get_implementation_bounds(
     NPY_DATETIMEUNIT reso, npy_datetimestruct *lower, npy_datetimestruct *upper
 )
+
+cdef int64_t convert_reso(
+    int64_t value,
+    NPY_DATETIMEUNIT from_reso,
+    NPY_DATETIMEUNIT to_reso,
+    bint round_ok,
+) except? -1

pandas/_libs/tslibs/np_datetime.pyx

@@ -541,5 +541,59 @@ cdef int64_t get_conversion_factor(NPY_DATETIMEUNIT from_unit, NPY_DATETIMEUNIT
         return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_fs, to_unit)
     elif from_unit == NPY_DATETIMEUNIT.NPY_FR_fs:
         return 1000 * get_conversion_factor(NPY_DATETIMEUNIT.NPY_FR_as, to_unit)
+
+
+cdef int64_t convert_reso(
+    int64_t value,
+    NPY_DATETIMEUNIT from_reso,
+    NPY_DATETIMEUNIT to_reso,
+    bint round_ok,
+) except? -1:
+    cdef:
+        int64_t res_value, mult, div, mod
+
+    if from_reso == to_reso:
+        return value
+
+    elif to_reso < from_reso:
+        # e.g. ns -> us, no risk of overflow, but can be lossy rounding
+        mult = get_conversion_factor(to_reso, from_reso)
+        div, mod = divmod(value, mult)
+        if mod > 0 and not round_ok:
+            raise ValueError("Cannot losslessly convert units")
+
+        # Note that when mod > 0, we follow np.timedelta64 in always
+        #  rounding down.
+        res_value = div
+
+    elif (
+        from_reso == NPY_FR_Y
+        or from_reso == NPY_FR_M
+        or to_reso == NPY_FR_Y
+        or to_reso == NPY_FR_M
+    ):
+        # Converting by multiplying isn't _quite_ right bc the number of
+        #  seconds in a month/year isn't fixed.
+        res_value = _convert_reso_with_dtstruct(value, from_reso, to_reso)
+
     else:
-        raise ValueError(from_unit, to_unit)
+        # e.g. ns -> us, risk of overflow, but no risk of lossy rounding
+        mult = get_conversion_factor(from_reso, to_reso)
+        with cython.overflowcheck(True):
+            # Note: caller is responsible for re-raising as OutOfBoundsTimedelta
+            res_value = value * mult
+
+    return res_value
+
+
+cdef int64_t _convert_reso_with_dtstruct(
+    int64_t value,
+    NPY_DATETIMEUNIT from_unit,
+    NPY_DATETIMEUNIT to_unit,
+) except? -1:
+    cdef:
+        npy_datetimestruct dts
+
+    pandas_datetime_to_datetimestruct(value, from_unit, &dts)
+    check_dts_bounds(&dts, to_unit)
+    return npy_datetimestruct_to_datetime(to_unit, &dts)

pandas/_libs/tslibs/timedeltas.pyx

@@ -47,6 +47,7 @@ from pandas._libs.tslibs.np_datetime cimport (
     NPY_FR_ns,
     cmp_dtstructs,
     cmp_scalar,
+    convert_reso,
     get_conversion_factor,
     get_datetime64_unit,
     get_timedelta64_value,
@@ -57,7 +58,10 @@ from pandas._libs.tslibs.np_datetime cimport (
     pandas_timedeltastruct,
 )
 
-from pandas._libs.tslibs.np_datetime import OutOfBoundsTimedelta
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+)
 
 from pandas._libs.tslibs.offsets cimport is_tick_object
 from pandas._libs.tslibs.util cimport (
@@ -240,6 +244,11 @@ cpdef int64_t delta_to_nanoseconds(
 
     elif is_timedelta64_object(delta):
         in_reso = get_datetime64_unit(delta)
+        if in_reso == NPY_DATETIMEUNIT.NPY_FR_Y or in_reso == NPY_DATETIMEUNIT.NPY_FR_M:
+            raise ValueError(
+                "delta_to_nanoseconds does not support Y or M units, "
+                "as their duration in nanoseconds is ambiguous."
+            )
         n = get_timedelta64_value(delta)
 
     elif PyDelta_Check(delta):
@@ -256,26 +265,15 @@ cpdef int64_t delta_to_nanoseconds(
     else:
         raise TypeError(type(delta))
 
-    if reso < in_reso:
-        # e.g. ns -> us
-        factor = get_conversion_factor(reso, in_reso)
-        div, mod = divmod(n, factor)
-        if mod > 0 and not round_ok:
-            raise ValueError("Cannot losslessly convert units")
-
-        # Note that when mod > 0, we follow np.timedelta64 in always
-        #  rounding down.
-        value = div
-    else:
-        factor = get_conversion_factor(in_reso, reso)
-        try:
-            with cython.overflowcheck(True):
-                value = n * factor
-        except OverflowError as err:
-            unit_str = npy_unit_to_abbrev(reso)
-            raise OutOfBoundsTimedelta(
-                f"Cannot cast {str(delta)} to unit={unit_str} without overflow."
-            ) from err
+    try:
+        return convert_reso(n, in_reso, reso, round_ok=round_ok)
+    except (OutOfBoundsDatetime, OverflowError) as err:
+        # Catch OutOfBoundsDatetime bc convert_reso can call check_dts_bounds
+        #  for Y/M-resolution cases
+        unit_str = npy_unit_to_abbrev(reso)
+        raise OutOfBoundsTimedelta(
+            f"Cannot cast {str(delta)} to unit={unit_str} without overflow."
+        ) from err
 
     return value
 
@@ -1538,21 +1536,7 @@ cdef class _Timedelta(timedelta):
         if reso == self._reso:
             return self
 
-        if reso < self._reso:
-            # e.g. ns -> us
-            mult = get_conversion_factor(reso, self._reso)
-            div, mod = divmod(self.value, mult)
-            if mod > 0 and not round_ok:
-                raise ValueError("Cannot losslessly convert units")
-
-            # Note that when mod > 0, we follow np.timedelta64 in always
-            #  rounding down.
-            value = div
-        else:
-            mult = get_conversion_factor(self._reso, reso)
-            with cython.overflowcheck(True):
-                # Note: caller is responsible for re-raising as OutOfBoundsTimedelta
-                value = self.value * mult
+        value = convert_reso(self.value, self._reso, reso, round_ok=round_ok)
         return type(self)._from_value_and_reso(value, reso=reso)
 
 

pandas/_libs/tslibs/timestamps.pyx

@@ -82,6 +82,7 @@ from pandas._libs.tslibs.np_datetime cimport (
     NPY_FR_ns,
     cmp_dtstructs,
     cmp_scalar,
+    convert_reso,
     get_conversion_factor,
     get_datetime64_unit,
     get_datetime64_value,
@@ -1043,7 +1044,6 @@ cdef class _Timestamp(ABCTimestamp):
     # -----------------------------------------------------------------
     # Conversion Methods
 
-    # TODO: share with _Timedelta?
     @cython.cdivision(False)
     cdef _Timestamp _as_reso(self, NPY_DATETIMEUNIT reso, bint round_ok=True):
         cdef:
@@ -1052,21 +1052,7 @@ cdef class _Timestamp(ABCTimestamp):
         if reso == self._reso:
             return self
 
-        if reso < self._reso:
-            # e.g. ns -> us
-            mult = get_conversion_factor(reso, self._reso)
-            div, mod = divmod(self.value, mult)
-            if mod > 0 and not round_ok:
-                raise ValueError("Cannot losslessly convert units")
-
-            # Note that when mod > 0, we follow np.datetime64 in always
-            #  rounding down.
-            value = div
-        else:
-            mult = get_conversion_factor(self._reso, reso)
-            with cython.overflowcheck(True):
-                # Note: caller is responsible for re-raising as OutOfBoundsDatetime
-                value = self.value * mult
+        value = convert_reso(self.value, self._reso, reso, round_ok=round_ok)
         return type(self)._from_value_and_reso(value, reso=reso, tz=self.tzinfo)
 
     def _as_unit(self, str unit, bint round_ok=True):

pandas/tests/tslibs/test_timedeltas.py

@@ -56,14 +56,19 @@ def test_delta_to_nanoseconds_error():
 
 
 def test_delta_to_nanoseconds_td64_MY_raises():
+    msg = (
+        "delta_to_nanoseconds does not support Y or M units, "
+        "as their duration in nanoseconds is ambiguous"
+    )
+
     td = np.timedelta64(1234, "Y")
 
-    with pytest.raises(ValueError, match="0, 10"):
+    with pytest.raises(ValueError, match=msg):
         delta_to_nanoseconds(td)
 
     td = np.timedelta64(1234, "M")
 
-    with pytest.raises(ValueError, match="1, 10"):
+    with pytest.raises(ValueError, match=msg):
         delta_to_nanoseconds(td)