test, linter fixes

Author: patrickmckenna

pandas/_libs/tslibs/timedeltas.pyx

@@ -29,8 +29,8 @@ from cpython.datetime cimport (
 import_datetime()
 
 
-from pandas._libs cimport ops
 cimport pandas._libs.tslibs.util as util
+from pandas._libs cimport ops
 from pandas._libs.tslibs.base cimport ABCTimestamp
 from pandas._libs.tslibs.conversion cimport (
     cast_from_unit,

pandas/_libs/tslibs/timestamps.pyx

@@ -86,7 +86,10 @@ from pandas._libs.tslibs.np_datetime cimport (
     pydatetime_to_dt64,
 )
 
-from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime, OutOfBoundsTimedelta
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+)
 
 from pandas._libs.tslibs.offsets cimport (
     BaseOffset,

pandas/tests/libs/test_ops.py

@@ -18,7 +18,12 @@ def fixture_int_min() -> int:
 
 @pytest.fixture(name="overflow_msg")
 def fixture_overflow_msg() -> str:
-    return "Python int too large to convert to C long"
+    return "|".join(
+        (
+            "Python int too large to convert to C long",
+            "int too big to convert",
+        )
+    )
 
 
 def test_raises_for_too_large_arg(int_max: int, overflow_msg: str):

pandas/tests/scalar/conftest.py

@@ -6,10 +6,13 @@
     timedelta,
 )
 import operator
+import re
 
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs import OutOfBoundsTimedelta
+
 import pandas as pd
 from pandas import (
     NaT,
@@ -96,11 +99,14 @@ def test_td_add_datetimelike_scalar(self, op):
         result = op(td, NaT)
         assert result is NaT
 
-    def test_td_add_timestamp_overflow(self, timedelta_overflow):
-        with pytest.raises(**timedelta_overflow):
+    def test_td_add_timestamp_overflow(self):
+        msg = msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timestamp("1700-01-01") + Timedelta(13 * 19999, unit="D")
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timestamp("1700-01-01") + timedelta(days=13 * 19999)
 
     @pytest.mark.parametrize("op", [operator.add, ops.radd])

pandas/tests/scalar/timedelta/test_arithmetic.py

@@ -8,6 +8,8 @@
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs import OutOfBoundsTimedelta
+
 from pandas import (
     NA,
     NaT,
@@ -163,16 +165,19 @@ def test_construction():
 
 
 @pytest.mark.parametrize("unit", ("ps", "ns"))
-def test_from_np_td64_ignores_unit(unit: str, timedelta_overflow):
+def test_from_np_td64_ignores_unit(unit: str):
     """
     Ignore the unit, as it may cause silently overflows leading to incorrect results,
     and in non-overflow cases is irrelevant GH#46827.
     """
     td64 = np.timedelta64(NP_TD64_MAX_PER_UNIT["h"], "h")
+    msg = re.escape(
+        "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+    )
 
     assert Timedelta(td64, unit=unit) == Timedelta(td64)
 
-    with pytest.raises(**timedelta_overflow):
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
         Timedelta(td64 * 2, unit=unit)
 
 
@@ -448,13 +453,7 @@ def test_raises_if_ambiguous_units_passed(self, unit: str):
 
 class TestOverflow:
     @pytest.mark.parametrize(("unit", "max_val"), TD_MAX_PER_UNIT.items())
-    def test_int_plus_units_too_big(
-        self,
-        unit: str,
-        max_val: int,
-        request,
-        timedelta_overflow,
-    ):
+    def test_int_plus_units_too_big(self, unit: str, max_val: int, request):
         if unit == "w":
             mark = pytest.mark.xfail(
                 reason="does not raise",
@@ -464,18 +463,15 @@ def test_int_plus_units_too_big(
             request.node.add_marker(mark)
 
         too_big = max_val + 1
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(too_big, unit=unit)
 
     @pytest.mark.parametrize(("unit", "min_val"), skip_ns(TD_MIN_PER_UNIT).items())
-    def test_int_plus_units_too_small(
-        self,
-        unit: str,
-        min_val: int,
-        request,
-        timedelta_overflow,
-    ):
+    def test_int_plus_units_too_small(self, unit: str, min_val: int, request):
         if unit == "w":
             mark = pytest.mark.xfail(
                 reason="does not raise",
@@ -485,55 +481,71 @@ def test_int_plus_units_too_small(
             request.node.add_marker(mark)
 
         too_small = min_val - 1
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(too_small, unit=unit)
 
     @pytest.mark.parametrize(("kwarg", "max_val"), TD_MAX_PER_KWARG.items())
-    def test_kwarg_too_big(self, kwarg: str, max_val: int, timedelta_overflow):
+    def test_kwarg_too_big(self, kwarg: str, max_val: int):
         too_big = max_val + 1
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             assert Timedelta(**{kwarg: too_big})  # type: ignore[arg-type]
 
     @pytest.mark.parametrize(("kwarg", "min_val"), skip_ns(TD_MIN_PER_KWARG).items())
-    def test_kwarg_too_small(self, kwarg: str, min_val: int, timedelta_overflow):
+    def test_kwarg_too_small(self, kwarg: str, min_val: int):
         too_small = min_val - 1
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(**{kwarg: too_small})  # type: ignore[arg-type]
 
     @pytest.mark.parametrize(("kwarg", "max_val"), skip_ns(TD_MAX_PER_KWARG).items())
-    def test_from_timedelta_too_big(self, kwarg: str, max_val: int, timedelta_overflow):
+    def test_from_timedelta_too_big(self, kwarg: str, max_val: int):
         too_big = timedelta(**{kwarg: max_val + 1})
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(too_big)
 
     @pytest.mark.parametrize(("kwarg", "min_val"), skip_ns(TD_MIN_PER_KWARG).items())
-    def test_from_timedelta_too_small(
-        self,
-        kwarg: str,
-        min_val: int,
-        timedelta_overflow,
-    ):
+    def test_from_timedelta_too_small(self, kwarg: str, min_val: int):
         too_small = timedelta(**{kwarg: min_val - 1})
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(too_small)
 
     @pytest.mark.parametrize(("unit", "max_val"), skip_ns(NP_TD64_MAX_PER_UNIT).items())
-    def test_from_np_td64_too_big(self, unit: str, max_val: int, timedelta_overflow):
+    def test_from_np_td64_too_big(self, unit: str, max_val: int):
         too_big = np.timedelta64(max_val + 1, unit)
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(too_big)
 
     @pytest.mark.parametrize(("unit", "min_val"), skip_ns(NP_TD64_MIN_PER_UNIT).items())
-    def test_from_np_td64_too_small(self, unit: str, min_val: int, timedelta_overflow):
+    def test_from_np_td64_too_small(self, unit: str, min_val: int):
         too_small = np.timedelta64(min_val - 1, unit)
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(too_small)
 
     def test_too_small_by_1ns_returns_nat(self):

pandas/tests/scalar/timedelta/test_constructors.py

@@ -1,5 +1,6 @@
 """ test the scalar Timedelta """
 from datetime import timedelta
+import re
 
 from hypothesis import (
     given,
@@ -11,6 +12,7 @@
 from pandas._libs import lib
 from pandas._libs.tslibs import (
     NaT,
+    OutOfBoundsTimedelta,
     iNaT,
 )
 
@@ -646,7 +648,7 @@ def test_timedelta_hash_equality(self):
         ns_td = Timedelta(1, "ns")
         assert hash(ns_td) != hash(ns_td.to_pytimedelta())
 
-    def test_implementation_limits(self, timedelta_overflow):
+    def test_implementation_limits(self):
         min_td = Timedelta(Timedelta.min)
         max_td = Timedelta(Timedelta.max)
 
@@ -658,20 +660,23 @@ def test_implementation_limits(self, timedelta_overflow):
         # Beyond lower limit, a NAT before the Overflow
         assert (min_td - Timedelta(1, "ns")) is NaT
 
-        with pytest.raises(**timedelta_overflow):
+        msg = re.escape(
+            "outside allowed range [-9223372036854775807ns, 9223372036854775807ns]"
+        )
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             min_td - Timedelta(2, "ns")
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             max_td + Timedelta(1, "ns")
 
         # Same tests using the internal nanosecond values
         td = Timedelta(min_td.value - 1, "ns")
         assert td is NaT
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(min_td.value - 2, "ns")
 
-        with pytest.raises(**timedelta_overflow):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             Timedelta(max_td.value + 1, "ns")
 
     def test_total_seconds_precision(self):

pandas/tests/scalar/timedelta/test_timedelta.py

@@ -8,7 +8,7 @@
 import pytest
 
 from pandas._libs.tslibs import (
-    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
     Timedelta,
     Timestamp,
     offsets,
@@ -72,13 +72,13 @@ def test_overflow_offset_raises(self):
         with pytest.raises(OverflowError, match=lmsg):
             stamp - offset_overflow
 
-    def test_sub_returns_stdlib_timedelta_to_avoid_overflow(self, timedelta_overflow):
+    def test_sub_returns_stdlib_timedelta_to_avoid_overflow(self):
         # https://github.com/pandas-dev/pandas/issues/31774
         msg = "Result is too large for pandas.Timedelta"
         a = Timestamp("2101-01-01 00:00:00")
         b = Timestamp("1688-01-01 00:00:00")
 
-        with pytest.raises(timedelta_overflow["expected_exception"], match=msg):
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
             a - b
 
         # but we're OK for Timestamp and datetime.datetime

pandas/tests/scalar/timestamp/test_arithmetic.py

@@ -109,9 +109,7 @@ def test_to_timedelta_invalid_unit(self, arg):
 
     def test_to_timedelta_time(self):
         # time not supported ATM
-        msg = (
-            "Value must be Timedelta, string, integer, float, timedelta or convertible"
-        )
+        msg = "Invalid type for timedelta scalar: <class 'datetime.time'>"
         with pytest.raises(ValueError, match=msg):
             to_timedelta(time(second=1))
         assert to_timedelta(time(second=1), errors="coerce") is pd.NaT
@@ -264,10 +262,7 @@ def test_to_timedelta_zerodim(self, fixed_now_ts):
         dt64 = fixed_now_ts.to_datetime64()
         arg = np.array(dt64)
 
-        msg = (
-            "Value must be Timedelta, string, integer, float, timedelta "
-            "or convertible, not datetime64"
-        )
+        msg = "Invalid type for timedelta scalar: <class 'numpy.datetime64'>"
         with pytest.raises(ValueError, match=msg):
             to_timedelta(arg)
 

pandas/tests/tools/test_to_timedelta.py

@@ -61,21 +61,6 @@ def test_huge_nanoseconds_overflow():
     assert delta_to_nanoseconds(Timedelta(nanoseconds=1e10)) == 1e10
 
 
-@pytest.mark.parametrize(
-    "kwargs", [{"Seconds": 1}, {"seconds": 1, "Nanoseconds": 1}, {"Foo": 2}]
-)
-def test_kwarg_assertion(kwargs):
-    err_message = (
-        "cannot construct a Timedelta from the passed arguments, "
-        "allowed keywords are "
-        "[weeks, days, hours, minutes, seconds, "
-        "milliseconds, microseconds, nanoseconds]"
-    )
-
-    with pytest.raises(ValueError, match=re.escape(err_message)):
-        Timedelta(**kwargs)
-
-
 class TestArrayToTimedelta64:
     def test_array_to_timedelta64_string_with_unit_2d_raises(self):
         # check the 'unit is not None and errors != "coerce"' path