ExtensionArray.Round method and tests

pandas/core/arrays/base.py

@@ -2337,6 +2337,9 @@ def _add_logical_ops(cls) -> None:
         setattr(cls, "__xor__", cls._create_logical_method(operator.xor))
         setattr(cls, "__rxor__", cls._create_logical_method(roperator.rxor))
 
+    def round(self, decimals: int = 0, *args, **kwargs) -> Self:
+        raise AbstractMethodError(self)
+
 
 class ExtensionScalarOpsMixin(ExtensionOpsMixin):
     """

pandas/tests/extension/base/methods.py

@@ -704,3 +704,13 @@ def test_equals(self, data, as_series, box):
     def test_equals_same_data_different_object(self, data):
         # https://github.com/pandas-dev/pandas/issues/34660
         assert pd.Series(data).equals(pd.Series(data))
+
+    def test_round(self, data):
+        if not data.dtype._is_numeric:
+            pytest.skip("Round is only valid for numeric dtypes")
+        result = pd.Series(data).round()
+        expected = pd.Series(
+            [np.round(element) if pd.notna(element) else element for element in data],
+            dtype=data.dtype,
+        )
+        tm.assert_series_equal(result, expected)

pandas/tests/extension/decimal/test_decimal.py

@@ -259,6 +259,10 @@ def test_series_repr(self, data):
     def test_unary_ufunc_dunder_equivalence(self, data, ufunc):
         super().test_unary_ufunc_dunder_equivalence(data, ufunc)
 
+    @pytest.mark.xfail(reason="DecimalArray.round is not implemented.")
+    def test_round(self, data):
+        super().test_round(data)
+
 
 def test_take_na_value_other_decimal():
     arr = DecimalArray([decimal.Decimal("1.0"), decimal.Decimal("2.0")])

pandas/tests/extension/test_arrow.py

@@ -1026,6 +1026,19 @@ def _get_arith_xfail_marker(self, opname, pa_dtype):
 
         return mark
 
+    def test_round(self, data, request):
+        mark = pytest.mark.xfail(
+            # raises=pa.ArrowInvalid,
+            reason="ArrowArray.round converts dtype to double",
+        )
+        if pa.types.is_float32(data.dtype.pyarrow_dtype) or pa.types.is_float64(
+            data.dtype.pyarrow_dtype
+        ):
+            mark = None
+        if mark is not None:
+            request.node.add_marker(mark)
+        super().test_round(data)
+
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request):
         pa_dtype = data.dtype.pyarrow_dtype
 

pandas/tests/extension/test_interval.py

@@ -96,6 +96,10 @@ def test_EA_types(self, engine, data):
         with pytest.raises(NotImplementedError, match=expected_msg):
             super().test_EA_types(engine, data)
 
+    @pytest.mark.xfail(reason="Round is not valid for IntervalArray.")
+    def test_round(self, data):
+        super().test_round(data)
+
 
 # TODO: either belongs in tests.arrays.interval or move into base tests.
 def test_fillna_non_scalar_raises(data_missing):

pandas/tests/extension/test_masked.py

@@ -361,6 +361,12 @@ def check_accumulate(self, ser: pd.Series, op_name: str, skipna: bool):
         else:
             raise NotImplementedError(f"{op_name} not supported")
 
+    def test_round(self, data, request):
+        if data.dtype == "boolean":
+            mark = pytest.mark.xfail(reason="Cannot round boolean dtype")
+            request.node.add_marker(mark)
+        super().test_round(data)
+
 
 class Test2DCompat(base.Dim2CompatTests):
     pass

pandas/tests/extension/test_numpy.py

@@ -270,6 +270,10 @@ def test_insert_invalid(self, data, invalid_scalar):
         # NumpyExtensionArray[object] can hold anything, so skip
         super().test_insert_invalid(data, invalid_scalar)
 
+    @pytest.mark.xfail(reason="NumpyExtensionArray.round is not implemented.")
+    def test_round(self, data):
+        super().test_round(data)
+
 
 class TestArithmetics(BaseNumPyTests, base.BaseArithmeticOpsTests):
     divmod_exc = None

pandas/tests/extension/test_sparse.py

@@ -349,6 +349,10 @@ def test_map_raises(self, data, na_action):
         with pytest.raises(ValueError, match=msg):
             data.map(lambda x: np.nan, na_action=na_action)
 
+    @pytest.mark.xfail(reason="SpareArray.round not implemented.")
+    def test_round(self, data):
+        super().test_round(data)
+
 
 class TestCasting(BaseSparseTests, base.BaseCastingTests):
     @pytest.mark.xfail(raises=TypeError, reason="no sparse StringDtype")