remove unused stuff

Author: patrickmckenna

pandas/_libs/ops.pxd

@@ -2,4 +2,3 @@ from numpy cimport int64_t
 
 
 cpdef int64_t calc_int_int(object op, int64_t a, int64_t b) except? -1
-cpdef int64_t calc_int_float(object op, int64_t a, double b) except? -1

pandas/_libs/ops.pyi

@@ -49,4 +49,3 @@ def maybe_convert_bool(
     convert_to_masked_nullable: Literal[True],
 ) -> tuple[np.ndarray, np.ndarray]: ...
 def calc_int_int(op, left: int, right: int) -> int: ...
-def calc_int_float(op, left: int, right: float) -> int: ...

pandas/_libs/ops.pyx

@@ -318,11 +318,3 @@ cpdef int64_t calc_int_int(object op, int64_t a, int64_t b) except? -1:
     operand or the result to an int64_t would overflow.
     """
     return op(a, b)
-
-@cython.overflowcheck(True)
-cpdef int64_t calc_int_float(object op, int64_t a, double b) except? -1:
-    """
-    Calculate op(a, b) and return the result. Raises OverflowError if converting either
-    operand or the result would overflow.
-    """
-    return op(a, b)

pandas/_libs/tslibs/timedeltas.pyx

@@ -250,9 +250,9 @@ cdef object ensure_td64ns(object ts):
 
     unitstr = npy_unit_to_abbrev(td64_unit)
     mult = precision_from_unit(unitstr)[0]
-    td64_value = calc_int_int(operator.mul, get_timedelta64_value(ts), mult)
+    ns = calc_int_int(operator.mul, get_timedelta64_value(ts), mult)
 
-    return np.timedelta64(td64_value, "ns")
+    return np.timedelta64(ns, "ns")
 
 
 cdef convert_to_timedelta64(object ts, str unit):
@@ -673,7 +673,7 @@ def _op_unary_method(func, name):
     return f
 
 
-cpdef int64_t calc_int_int(object op, object a, object b) except? -1:
+cdef int64_t calc_int_int(object op, object a, object b) except? -1:
     """
     Calculate op(a, b), raising if either operand or the result cannot be safely cast
     to an int64_t.

pandas/tests/libs/test_ops.py

@@ -1,11 +1,15 @@
 import operator
-from platform import architecture
 
 import numpy as np
 import pytest
 
 from pandas._libs import ops
 
+from pandas.core.ops import (
+    radd,
+    rsub,
+)
+
 
 @pytest.fixture(name="int_max", scope="module")
 def fixture_int_max() -> int:
@@ -17,16 +21,6 @@ def fixture_int_min() -> int:
     return np.iinfo(np.int64).min
 
 
-@pytest.fixture(name="float_max", scope="module")
-def fixture_float_max() -> np.float64:
-    return np.finfo(np.float64).max
-
-
-@pytest.fixture(name="float_min", scope="module")
-def fixture_float_min() -> np.float64:
-    return np.finfo(np.float64).min
-
-
 @pytest.fixture(name="overflow_msg", scope="module")
 def fixture_overflow_msg() -> str:
     return "|".join(
@@ -37,116 +31,37 @@ def fixture_overflow_msg() -> str:
     )
 
 
-class TestCalcIntInt:
-    def test_raises_for_too_large_arg(self, int_max: int, overflow_msg: str):
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.add, int_max + 1, 1)
-
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.add, 1, int_max + 1)
-
-    def test_raises_for_too_small_arg(self, int_min: int, overflow_msg: str):
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.add, int_min - 1, 1)
+@pytest.fixture(name="add_op", params=(operator.add, radd))
+def fixture_add_op(request):
+    return request.param
 
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.add, 1, int_min - 1)
 
-    def test_raises_for_too_large_result(self, int_max: int, overflow_msg: str):
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.add, int_max, 1)
+@pytest.fixture(name="sub_op", params=(operator.sub, rsub))
+def fixture_sub_op(request):
+    return request.param
 
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.add, 1, int_max)
 
-    def test_raises_for_too_small_result(self, int_min: int, overflow_msg: str):
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.sub, int_min, 1)
+class TestCalcIntInt:
+    def test_raises_for_too_large_arg(self, int_max: int, add_op, overflow_msg: str):
+        add_op(int_max + 1, 1)
 
         with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_int(operator.sub, 1, int_min)
+            ops.calc_int_int(add_op, int_max + 1, 1)
 
+    def test_raises_for_too_small_arg(self, int_min: int, sub_op, overflow_msg: str):
+        sub_op(int_min - 1, 1)
 
-class TestCalcIntFloat:
-    @pytest.mark.parametrize(
-        "op,lval,rval,expected",
-        (
-            (operator.add, 1, 1.0, 2),
-            (operator.sub, 2, 1.0, 1),
-            (operator.mul, 1, 2.0, 2),
-            (operator.truediv, 1, 0.5, 2),
-        ),
-        ids=("+", "-", "*", "/"),
-    )
-    def test_arithmetic_ops(self, op, lval: int, rval: float, expected: int):
-        result = ops.calc_int_float(op, lval, rval)
-
-        assert result == expected
-        assert isinstance(result, int)
-
-    def test_raises_for_too_large_arg(
-        self,
-        int_max: int,
-        float_max: float,
-        overflow_msg: str,
-    ):
         with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_float(operator.add, int_max + 1, 1)
+            ops.calc_int_int(sub_op, int_min - 1, 1)
 
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_float(operator.add, 1, float_max + 1)
-
-    def test_raises_for_too_small_arg(
-        self,
-        int_min: int,
-        float_min: float,
-        overflow_msg: str,
-    ):
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_float(operator.add, int_min - 1, 1)
+    def test_raises_for_too_large_result(self, int_max: int, add_op, overflow_msg: str):
+        assert add_op(int_max, 1) == int_max + 1
 
         with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_float(operator.add, 1, float_min - 1)
-
-    def test_raises_for_too_large_result(
-        self,
-        int_max: int,
-        float_max: float,
-        overflow_msg: str,
-    ):
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_float(operator.add, int_max, 1)
+            ops.calc_int_int(add_op, int_max, 1)
 
-        with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_float(operator.add, 1, float_max)
+    def test_raises_for_too_small_result(self, int_min: int, sub_op, overflow_msg: str):
+        assert abs(sub_op(int_min, 1)) == abs(int_min - 1)
 
-    @pytest.mark.parametrize(
-        "value",
-        (
-            pytest.param(
-                1024,
-                marks=pytest.mark.xfail(
-                    reason="TBD",
-                    raises=pytest.fail.Exception,
-                    strict=True,
-                ),
-            ),
-            pytest.param(
-                1024.1,
-                marks=pytest.mark.xfail(
-                    condition=architecture()[0] == "32bit",
-                    reason="overflows earlier",
-                    raises=pytest.fail.Exception,
-                    strict=True,
-                ),
-            ),
-        ),
-    )
-    def test_raises_for_most_too_small_results(
-        self,
-        value: float,
-        int_min: int,
-        overflow_msg: str,
-    ):
         with pytest.raises(OverflowError, match=overflow_msg):
-            ops.calc_int_float(operator.sub, int_min, value)
+            ops.calc_int_int(sub_op, int_min, 1)

pandas/tests/tslibs/test_timedeltas.py

@@ -53,27 +53,27 @@ def test_delta_to_nanoseconds_error():
         delta_to_nanoseconds(np.int32(3))
 
 
-def test_huge_nanoseconds_overflow():
+def test_delta_to_nanoseconds_overflow():
     # GH 32402
     assert delta_to_nanoseconds(Timedelta(1e10)) == 1e10
     assert delta_to_nanoseconds(Timedelta(nanoseconds=1e10)) == 1e10
 
 
-class TestArrayToTimedelta64:
-    def test_array_to_timedelta64_string_with_unit_2d_raises(self):
-        # check the 'unit is not None and errors != "coerce"' path
-        #  in array_to_timedelta64 raises correctly with 2D values
-        values = np.array([["1", 2], [3, "4"]], dtype=object)
-        with pytest.raises(ValueError, match="unit must not be specified"):
-            array_to_timedelta64(values, unit="s")
+def test_array_to_timedelta64_string_with_unit_2d_raises():
+    # check the 'unit is not None and errors != "coerce"' path
+    #  in array_to_timedelta64 raises correctly with 2D values
+    values = np.array([["1", 2], [3, "4"]], dtype=object)
+    with pytest.raises(ValueError, match="unit must not be specified"):
+        array_to_timedelta64(values, unit="s")
 
-    def test_array_to_timedelta64_non_object_raises(self):
-        # check we raise, not segfault
-        values = np.arange(5)
 
-        msg = "'values' must have object dtype"
-        with pytest.raises(TypeError, match=msg):
-            array_to_timedelta64(values)
+def test_array_to_timedelta64_non_object_raises():
+    # check we raise, not segfault
+    values = np.arange(5)
+
+    msg = "'values' must have object dtype"
+    with pytest.raises(TypeError, match=msg):
+        array_to_timedelta64(values)
 
 
 @pytest.mark.parametrize("unit", ["s", "ms", "us"])