ENH: Updating eq and ne methods for extension arrays.

Adding __eq__ to ExtensionArray Abstract method doc string.

Adding ne implementation to EA base class.

Also removing other implementations.

Updating EA equals method and adding tests.

pandas-devGH-27081

Author: dwhu

pandas/core/arrays/base.py

@@ -105,6 +105,7 @@ class ExtensionArray:
     * _from_sequence
     * _from_factorized
     * __getitem__
+    * __eq__
     * __len__
     * dtype
     * nbytes
@@ -381,7 +382,7 @@ def __ne__(self, other: ABCExtensionArray) -> bool:
         bool
         """
 
-        raise AbstractMethodError(self)
+        return ~(self == other)
 
     # ------------------------------------------------------------------------
     # Required attributes
@@ -705,7 +706,9 @@ def equals(self, other: ABCExtensionArray) -> bool:
             Whether the arrays are equivalent.
 
         """
-        return ((self == other) | (self.isna() == other.isna())).all()
+        return isinstance(other, self.__class__) and (
+            ((self == other) | (self.isna() == other.isna())).all()
+        )
 
     def _values_for_factorize(self) -> Tuple[np.ndarray, Any]:
         """

pandas/core/arrays/boolean.py

@@ -327,20 +327,6 @@ def __getitem__(self, item):
 
         return type(self)(self._data[item], self._mask[item])
 
-    def __eq__(self, other):
-        if not isinstance(other, BooleanArray):
-            return NotImplemented
-        return (
-            hasattr(other, "_data")
-            and self._data == other._data
-            and hasattr(other, "_mask")
-            and self._mask == other._mask
-            and hasattr(other, "_dtype") & self._dtype == other._dtype
-        )
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
     def _coerce_to_ndarray(self, dtype=None, na_value: "Scalar" = libmissing.NA):
         """
         Coerce to an ndarray of object dtype or bool dtype (if force_bool=True).

pandas/core/arrays/categorical.py

@@ -2071,19 +2071,6 @@ def __setitem__(self, key, value):
         lindexer = self._maybe_coerce_indexer(lindexer)
         self._codes[key] = lindexer
 
-    def __eq__(self, other):
-        if not isinstance(other, Categorical):
-            return NotImplemented
-        return (
-            hasattr(other, "_codes")
-            and self._codes == other._codes
-            and hasattr(other, "_dtype")
-            and self._dtype == other._dtype
-        )
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
     def _reverse_indexer(self) -> Dict[Hashable, np.ndarray]:
         """
         Compute the inverse of a categorical, returning

pandas/core/arrays/integer.py

@@ -377,18 +377,14 @@ def __getitem__(self, item):
         return type(self)(self._data[item], self._mask[item])
 
     def __eq__(self, other):
-        if not isinstance(other, IntegerArray):
-            return NotImplemented
         return (
-            hasattr(other, "_data")
+            isinstance(other, IntegerArray)
+            and hasattr(other, "_data")
             and self._data == other._data
             and hasattr(other, "_mask")
             and self._mask == other._mask
         )
 
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
     def _coerce_to_ndarray(self, dtype=None, na_value=lib._no_default):
         """
         coerce to an ndarary of object dtype

pandas/core/arrays/interval.py

@@ -548,20 +548,16 @@ def __setitem__(self, key, value):
         self._right = right
 
     def __eq__(self, other):
-        if not isinstance(other, IntervalArray):
-            return NotImplementedError
         return (
-            hasattr(other, "_left")
-            and self._left == other._left
+            isinstance(other, IntervalArray)
+            and hasattr(other, "_left")
+            and np.array_equal(self._left, other._left)
             and hasattr(other, "_right")
-            and self._right == other._right
+            and np.array_equal(self._right, other._right)
             and hasattr(other, "_closed")
             and self._closed == other._closed
         )
 
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
     def fillna(self, value=None, method=None, limit=None):
         """
         Fill NA/NaN values using the specified method.

pandas/tests/extension/base/methods.py

@@ -358,3 +358,18 @@ def test_repeat_raises(self, data, repeats, kwargs, error, msg, use_numpy):
                 np.repeat(data, repeats, **kwargs)
             else:
                 data.repeat(repeats, **kwargs)
+
+    def test_equals(self, data, na_value):
+        cls = type(data)
+        ser = pd.Series(cls._from_sequence(data, dtype=data.dtype))
+        na_ser = pd.Series(cls._from_sequence([na_value], dtype=data.dtype))
+
+        assert data.equals(data)
+        assert ser.equals(ser)
+        assert na_ser.equals(na_ser)
+
+        assert not data.equals(na_value)
+        assert not na_ser.equals(ser)
+        assert not ser.equals(na_ser)
+        assert not ser.equals(0)
+        assert not na_ser.equals(0)

pandas/tests/extension/base/ops.py

@@ -132,10 +132,8 @@ class BaseComparisonOpsTests(BaseOpsUtil):
     def _compare_other(self, s, data, op_name, other):
         op = self.get_op_from_name(op_name)
         if op_name == "__eq__":
-            assert getattr(data, op_name)(other) is NotImplemented
             assert not op(s, other).all()
         elif op_name == "__ne__":
-            assert getattr(data, op_name)(other) is NotImplemented
             assert op(s, other).all()
 
         else:
@@ -158,13 +156,3 @@ def test_compare_array(self, data, all_compare_operators):
         s = pd.Series(data)
         other = pd.Series([data[0]] * len(data))
         self._compare_other(s, data, op_name, other)
-
-    def test_direct_arith_with_series_returns_not_implemented(self, data):
-        # EAs should return NotImplemented for ops with Series.
-        # Pandas takes care of unboxing the series and calling the EA's op.
-        other = pd.Series(data)
-        if hasattr(data, "__eq__"):
-            result = data.__eq__(other)
-            assert result is NotImplemented
-        else:
-            raise pytest.skip(f"{type(data).__name__} does not implement __eq__")

pandas/tests/extension/json/array.py

@@ -117,9 +117,6 @@ def __eq__(self, other):
             and self.data == other.data
         )
 
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
     def __len__(self) -> int:
         return len(self.data)
 

pandas/tests/extension/test_sparse.py

@@ -302,6 +302,10 @@ def test_searchsorted(self, data_for_sorting, as_series):
         with tm.assert_produces_warning(PerformanceWarning):
             super().test_searchsorted(data_for_sorting, as_series)
 
+    def test_equals(self, data, na_value):
+        self._check_unsupported(data)
+        super().test_equals(data, na_value)
+
 
 class TestCasting(BaseSparseTests, base.BaseCastingTests):
     pass