Use LSP parameter style for request

Replace `request` parameter with `*args, **kwargs` in many places.  This allows us to avoid needlessly passing request parameters just to satisfy method signatures.

Also remove whatsnew entry as this enhancement to test cases is not really user-visible.

Signed-off-by: Michael Tiemann <72577720+MichaelTiemannOSC@users.noreply.github.com>

Author: MichaelTiemannOSC

doc/source/whatsnew/v2.2.0.rst

@@ -351,7 +351,6 @@ Styler
 
 Other
 ^^^^^
-- Add complex128 to the types of numerical data we test across the test suite (:issue:`54761`)
 - Bug in :func:`cut` incorrectly allowing cutting of timezone-aware datetimes with timezone-naive bins (:issue:`54964`)
 
 .. ***DO NOT USE THIS SECTION***

pandas/tests/extension/base/ops.py

@@ -19,7 +19,7 @@ class BaseOpsUtil:
     divmod_exc: type[Exception] | None = TypeError
 
     def _get_expected_exception(
-        self, op_name: str, obj, other, request
+        self, op_name: str, obj, other, *args, **kwargs
     ) -> type[Exception] | None:
         # Find the Exception, if any we expect to raise calling
         #  obj.__op_name__(other)
@@ -54,8 +54,8 @@ def get_op_from_name(self, op_name: str):
     #  case that still requires overriding _check_op or _combine, please let
     #  us know at github.com/pandas-dev/pandas/issues
     @final
-    def check_opname(self, ser: pd.Series, op_name: str, other, request):
-        exc = self._get_expected_exception(op_name, ser, other, request)
+    def check_opname(self, ser: pd.Series, op_name: str, other, *args, **kwargs):
+        exc = self._get_expected_exception(op_name, ser, other, *args, **kwargs)
         op = self.get_op_from_name(op_name)
 
         self._check_op(ser, op, other, op_name, exc)
@@ -91,12 +91,16 @@ def _check_op(
 
     # see comment on check_opname
     @final
-    def _check_divmod_op(self, ser: pd.Series, op, other, request):
+    def _check_divmod_op(self, ser: pd.Series, op, other, *args, **kwargs):
         # check that divmod behavior matches behavior of floordiv+mod
         if op is divmod:
-            exc = self._get_expected_exception("__divmod__", ser, other, request)
+            exc = self._get_expected_exception(
+                "__divmod__", ser, other, *args, **kwargs
+            )
         else:
-            exc = self._get_expected_exception("__rdivmod__", ser, other, request)
+            exc = self._get_expected_exception(
+                "__rdivmod__", ser, other, *args, **kwargs
+            )
         if exc is None:
             result_div, result_mod = op(ser, other)
             if op is divmod:
@@ -128,53 +132,61 @@ class BaseArithmeticOpsTests(BaseOpsUtil):
     series_array_exc: type[Exception] | None = TypeError
     divmod_exc: type[Exception] | None = TypeError
 
-    def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request):
+    def test_arith_series_with_scalar(
+        self, data, all_arithmetic_operators, *args, **kwargs
+    ):
         # series & scalar
         if all_arithmetic_operators == "__rmod__" and is_string_dtype(data.dtype):
             pytest.skip("Skip testing Python string formatting")
 
         op_name = all_arithmetic_operators
         ser = pd.Series(data)
-        self.check_opname(ser, op_name, ser.iloc[0], request)
+        self.check_opname(ser, op_name, ser.iloc[0], *args, **kwargs)
 
-    def test_arith_frame_with_scalar(self, data, all_arithmetic_operators, request):
+    def test_arith_frame_with_scalar(
+        self, data, all_arithmetic_operators, *args, **kwargs
+    ):
         # frame & scalar
         if all_arithmetic_operators == "__rmod__" and is_string_dtype(data.dtype):
             pytest.skip("Skip testing Python string formatting")
 
         op_name = all_arithmetic_operators
         df = pd.DataFrame({"A": data})
-        self.check_opname(df, op_name, data[0], request)
+        self.check_opname(df, op_name, data[0], *args, **kwargs)
 
-    def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
+    def test_arith_series_with_array(
+        self, data, all_arithmetic_operators, *args, **kwargs
+    ):
         # ndarray & other series
         op_name = all_arithmetic_operators
         ser = pd.Series(data)
-        self.check_opname(ser, op_name, pd.Series([ser.iloc[0]] * len(ser)), request)
+        self.check_opname(
+            ser, op_name, pd.Series([ser.iloc[0]] * len(ser)), *args, **kwargs
+        )
 
-    def test_divmod(self, data, request):
+    def test_divmod(self, data, *args, **kwargs):
         ser = pd.Series(data)
-        self._check_divmod_op(ser, divmod, 1, request)
-        self._check_divmod_op(1, ops.rdivmod, ser, request)
+        self._check_divmod_op(ser, divmod, 1, *args, **kwargs)
+        self._check_divmod_op(1, ops.rdivmod, ser, *args, **kwargs)
 
-    def test_divmod_series_array(self, data, data_for_twos, request):
+    def test_divmod_series_array(self, data, data_for_twos, *args, **kwargs):
         ser = pd.Series(data)
-        self._check_divmod_op(ser, divmod, data, request)
+        self._check_divmod_op(ser, divmod, data, *args, **kwargs)
 
         other = data_for_twos
-        self._check_divmod_op(other, ops.rdivmod, ser, request)
+        self._check_divmod_op(other, ops.rdivmod, ser, *args, **kwargs)
 
         other = pd.Series(other)
-        self._check_divmod_op(other, ops.rdivmod, ser, request)
+        self._check_divmod_op(other, ops.rdivmod, ser, *args, **kwargs)
 
-    def test_add_series_with_extension_array(self, data, request):
+    def test_add_series_with_extension_array(self, data, *args, **kwargs):
         # Check adding an ExtensionArray to a Series of the same dtype matches
         # the behavior of adding the arrays directly and then wrapping in a
         # Series.
 
         ser = pd.Series(data)
 
-        exc = self._get_expected_exception("__add__", ser, data, request)
+        exc = self._get_expected_exception("__add__", ser, data, *args, **kwargs)
         if exc is not None:
             with pytest.raises(exc):
                 ser + data

pandas/tests/extension/decimal/test_decimal.py

@@ -67,7 +67,7 @@ def data_for_grouping():
 
 class TestDecimalArray(base.ExtensionTests):
     def _get_expected_exception(
-        self, op_name: str, obj, other, request
+        self, op_name: str, obj, other, *args, **kwargs
     ) -> type[Exception] | None:
         return None
 
@@ -108,7 +108,7 @@ def test_compare_array(self, data, comparison_op):
         other = pd.Series(data) * [decimal.Decimal(pow(2.0, i)) for i in alter]
         self._compare_other(ser, data, comparison_op, other)
 
-    def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
+    def test_arith_series_with_array(self, data, all_arithmetic_operators):
         op_name = all_arithmetic_operators
         ser = pd.Series(data)
 
@@ -120,13 +120,13 @@ def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
 
         # Decimal supports ops with int, but not float
         other = pd.Series([int(d * 100) for d in data])
-        self.check_opname(ser, op_name, other, request)
+        self.check_opname(ser, op_name, other)
 
         if "mod" not in op_name:
-            self.check_opname(ser, op_name, ser * 2, request)
+            self.check_opname(ser, op_name, ser * 2)
 
-        self.check_opname(ser, op_name, 0, request)
-        self.check_opname(ser, op_name, 5, request)
+        self.check_opname(ser, op_name, 0)
+        self.check_opname(ser, op_name, 5)
         context.traps[decimal.DivisionByZero] = divbyzerotrap
         context.traps[decimal.InvalidOperation] = invalidoptrap
 
@@ -330,11 +330,11 @@ class TestArithmeticOps(base.BaseArithmeticOpsTests):
     series_array_exc = None
 
     def _get_expected_exception(
-        self, op_name: str, obj, other, request
+        self, op_name: str, obj, other
     ) -> type[Exception] | None:
         return None
 
-    def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
+    def test_arith_series_with_array(self, data, all_arithmetic_operators):
         op_name = all_arithmetic_operators
         s = pd.Series(data)
 
@@ -346,13 +346,13 @@ def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
 
         # Decimal supports ops with int, but not float
         other = pd.Series([int(d * 100) for d in data])
-        self.check_opname(s, op_name, other, request)
+        self.check_opname(s, op_name, other)
 
         if "mod" not in op_name:
-            self.check_opname(s, op_name, s * 2, request)
+            self.check_opname(s, op_name, s * 2)
 
-        self.check_opname(s, op_name, 0, request)
-        self.check_opname(s, op_name, 5, request)
+        self.check_opname(s, op_name, 0)
+        self.check_opname(s, op_name, 5)
         context.traps[decimal.DivisionByZero] = divbyzerotrap
         context.traps[decimal.InvalidOperation] = invalidoptrap
 

pandas/tests/extension/test_arrow.py

@@ -938,7 +938,7 @@ def _is_temporal_supported(self, opname, pa_dtype):
         )
 
     def _get_expected_exception(
-        self, op_name: str, obj, other, request
+        self, op_name: str, obj, other, *args, **kwargs
     ) -> type[Exception] | None:
         if op_name in ("__divmod__", "__rdivmod__"):
             return self.divmod_exc
@@ -1048,7 +1048,9 @@ def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request)
         if mark is not None:
             request.node.add_marker(mark)
 
-        super().test_arith_series_with_scalar(data, all_arithmetic_operators, request)
+        super().test_arith_series_with_scalar(
+            data, all_arithmetic_operators, request=request
+        )
 
     def test_arith_frame_with_scalar(self, data, all_arithmetic_operators, request):
         pa_dtype = data.dtype.pyarrow_dtype
@@ -1063,7 +1065,7 @@ def test_arith_frame_with_scalar(self, data, all_arithmetic_operators, request):
             request.node.add_marker(mark)
 
             super().test_arith_frame_with_scalar(
-                data, all_arithmetic_operators, request
+                data, all_arithmetic_operators, request=request
             )
 
     def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
@@ -1098,7 +1100,7 @@ def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
         # since ser.iloc[0] is a python scalar
         other = pd.Series(pd.array([ser.iloc[0]] * len(ser), dtype=data.dtype))
 
-        self.check_opname(ser, op_name, other, request)
+        self.check_opname(ser, op_name, other, request=request)
 
     def test_add_series_with_extension_array(self, data, request):
         pa_dtype = data.dtype.pyarrow_dtype
@@ -1110,7 +1112,7 @@ def test_add_series_with_extension_array(self, data, request):
                     reason=f"raises on overflow for {pa_dtype}",
                 )
             )
-        super().test_add_series_with_extension_array(data, request)
+        super().test_add_series_with_extension_array(data, request=request)
 
     def test_invalid_other_comp(self, data, comparison_op):
         # GH 48833

pandas/tests/extension/test_categorical.py

@@ -153,7 +153,7 @@ def test_arith_frame_with_scalar(self, data, all_arithmetic_operators, request):
                     reason="rmod never called when string is first argument"
                 )
             )
-        super().test_arith_frame_with_scalar(data, op_name, request)
+        super().test_arith_frame_with_scalar(data, op_name)
 
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request):
         op_name = all_arithmetic_operators
@@ -163,7 +163,7 @@ def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request)
                     reason="rmod never called when string is first argument"
                 )
             )
-        super().test_arith_series_with_scalar(data, op_name, request)
+        super().test_arith_series_with_scalar(data, op_name)
 
     def _compare_other(self, ser: pd.Series, data, op, other):
         op_name = f"__{op.__name__}__"

pandas/tests/extension/test_datetime.py

@@ -83,10 +83,10 @@ def cmp(a, b):
 
 # ----------------------------------------------------------------------------
 class TestDatetimeArray(base.ExtensionTests):
-    def _get_expected_exception(self, op_name, obj, other, request):
+    def _get_expected_exception(self, op_name, obj, other, *args, **kwargs):
         if op_name in ["__sub__", "__rsub__"]:
             return None
-        return super()._get_expected_exception(op_name, obj, other, request)
+        return super()._get_expected_exception(op_name, obj, other, *args, **kwargs)
 
     def _supports_accumulation(self, ser, op_name: str) -> bool:
         return op_name in ["cummin", "cummax"]

pandas/tests/extension/test_masked.py

@@ -162,7 +162,7 @@ def data_for_grouping(dtype):
 
 
 class TestMaskedArrays(base.ExtensionTests):
-    def _get_expected_exception(self, op_name, obj, other, request):
+    def _get_expected_exception(self, op_name, obj, other, *args, **kwargs):
         try:
             dtype = tm.get_dtype(obj)
         except AttributeError:
@@ -235,7 +235,7 @@ def test_divmod_series_array(self, data, data_for_twos, request):
                 "non-masked bool dtype."
             )
             request.node.add_marker(mark)
-        super().test_divmod_series_array(data, data_for_twos, request)
+        super().test_divmod_series_array(data, data_for_twos)
 
     def test_combine_le(self, data_repeated):
         # TODO: patching self is a bad pattern here

pandas/tests/extension/test_numpy.py

@@ -283,7 +283,7 @@ class TestArithmetics(BaseNumPyTests, base.BaseArithmeticOpsTests):
     series_array_exc = None
 
     def _get_expected_exception(
-        self, op_name: str, obj, other, request
+        self, op_name: str, obj, other, *args, **kwargs
     ) -> type[Exception] | None:
         # Find the Exception, if any we expect to raise calling
         #  obj.__op_name__(other)
@@ -311,34 +311,43 @@ def _get_expected_exception(
                             marked_reason = f"{dtype.name} dtype"
                             break
                 if marked_reason:
-                    request.node.add_marker(
+                    kwargs["request"].node.add_marker(
                         pytest.mark.xfail(
                             raises=TypeError,
                             reason=f"{marked_reason} does not support {op_name}",
                             strict=False,
                         )
                     )
                     return TypeError
-        return super()._get_expected_exception(op_name, obj, other, request)
+        return super()._get_expected_exception(op_name, obj, other)
 
     @skip_nested
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request):
-        super().test_arith_series_with_scalar(data, all_arithmetic_operators, request)
+        super().test_arith_series_with_scalar(
+            data, all_arithmetic_operators, request=request
+        )
 
     def test_arith_series_with_array(self, data, all_arithmetic_operators, request):
         opname = all_arithmetic_operators
         if data.dtype.numpy_dtype == object and opname not in ["__add__", "__radd__"]:
             mark = pytest.mark.xfail(reason="Fails for object dtype")
             request.node.add_marker(mark)
-        super().test_arith_series_with_array(data, all_arithmetic_operators, request)
+        super().test_arith_series_with_array(
+            data, all_arithmetic_operators, request=request
+        )
 
     @skip_nested
     def test_arith_frame_with_scalar(self, data, all_arithmetic_operators, request):
-        super().test_arith_frame_with_scalar(data, all_arithmetic_operators, request)
+        super().test_arith_frame_with_scalar(
+            data, all_arithmetic_operators, request=request
+        )
 
     @skip_nested
     def test_divmod(self, data, request):
-        super().test_divmod(data, request)
+        super().test_divmod(data, request=request)
+
+    def test_divmod_series_array(self, data, data_for_twos, request):
+        super().test_divmod_series_array(data, data_for_twos, request=request)
 
 
 class TestPrinting(BaseNumPyTests, base.BasePrintingTests):

pandas/tests/extension/test_period.py

@@ -72,10 +72,10 @@ def data_for_grouping(dtype):
 
 
 class TestPeriodArray(base.ExtensionTests):
-    def _get_expected_exception(self, op_name, obj, other, request):
+    def _get_expected_exception(self, op_name, obj, other, *args, **kwargs):
         if op_name in ("__sub__", "__rsub__"):
             return None
-        return super()._get_expected_exception(op_name, obj, other, request)
+        return super()._get_expected_exception(op_name, obj, other, *args, **kwargs)
 
     def _supports_accumulation(self, ser, op_name: str) -> bool:
         return op_name in ["cummin", "cummax"]