ExtensionArray.Round method and tests

pandas/core/arrays/base.py

@@ -2337,6 +2337,19 @@ 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:
+        # Implementer note: This is a non-optimized default implementation.
+        # Implementers are encouraged to override this method to avoid
+        # elementwise rounding.
+        if not self.dtype._is_numeric or self.dtype._is_boolean:
+            raise TypeError(
+                f"Cannot round {self.dtype} dtype as it is non-numeric or boolean"
+            )
+        return self._from_sequence(
+            [round(element) if not isna(element) else element for element in self.data],
+            dtype=self.dtype,
+        )
+
 
 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 or data.dtype._is_boolean:
+            pytest.skip("Round is only valid for numeric non-boolean dtypes")
+        result = pd.Series(data).round()
+        expected = pd.Series(
+            [round(element) if pd.notna(element) else element for element in data],
+            dtype=data.dtype,
+        )
+        tm.assert_series_equal(result, expected)

pandas/tests/extension/test_arrow.py

@@ -1026,6 +1026,21 @@ 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)
+            or pa.types.is_decimal(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_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="SparseArray.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")