pre-commit edit (#40617)

Author: jbrockmendel

pandas/core/indexes/extension.py

@@ -231,6 +231,38 @@ class ExtensionIndex(Index):
 
     _data: Union[IntervalArray, NDArrayBackedExtensionArray]
 
+    _data_cls: Union[
+        Type[Categorical],
+        Type[DatetimeArray],
+        Type[TimedeltaArray],
+        Type[PeriodArray],
+        Type[IntervalArray],
+    ]
+
+    @classmethod
+    def _simple_new(
+        cls,
+        array: Union[IntervalArray, NDArrayBackedExtensionArray],
+        name: Hashable = None,
+    ):
+        """
+        Construct from an ExtensionArray of the appropriate type.
+
+        Parameters
+        ----------
+        array : ExtensionArray
+        name : Label, default None
+            Attached as result.name
+        """
+        assert isinstance(array, cls._data_cls), type(array)
+
+        result = object.__new__(cls)
+        result._data = array
+        result._name = name
+        result._cache = {}
+        result._reset_identity()
+        return result
+
     __eq__ = _make_wrapped_comparison_op("__eq__")
     __ne__ = _make_wrapped_comparison_op("__ne__")
     __lt__ = _make_wrapped_comparison_op("__lt__")
@@ -362,30 +394,17 @@ class NDArrayBackedExtensionIndex(ExtensionIndex):
 
     _data: NDArrayBackedExtensionArray
 
-    _data_cls: Union[
-        Type[Categorical],
-        Type[DatetimeArray],
-        Type[TimedeltaArray],
-        Type[PeriodArray],
-    ]
-
     @classmethod
     def _simple_new(
         cls,
         values: NDArrayBackedExtensionArray,
         name: Hashable = None,
     ):
-        assert isinstance(values, cls._data_cls), type(values)
-
-        result = object.__new__(cls)
-        result._data = values
-        result._name = name
-        result._cache = {}
+        result = super()._simple_new(values, name)
 
         # For groupby perf. See note in indexes/base about _index_data
         result._index_data = values._ndarray
 
-        result._reset_identity()
         return result
 
     def _get_engine_target(self) -> np.ndarray:

pandas/core/indexes/interval.py

@@ -187,6 +187,31 @@ def wrapped(self, other, sort=False):
     return wrapped
 
 
+def _setop(op_name: str):
+    """
+    Implement set operation.
+    """
+
+    def func(self, other, sort=None):
+        # At this point we are assured
+        #  isinstance(other, IntervalIndex)
+        #  other.closed == self.closed
+
+        result = getattr(self._multiindex, op_name)(other._multiindex, sort=sort)
+        result_name = get_op_result_name(self, other)
+
+        # GH 19101: ensure empty results have correct dtype
+        if result.empty:
+            result = result._values.astype(self.dtype.subtype)
+        else:
+            result = result._values
+
+        return type(self).from_tuples(result, closed=self.closed, name=result_name)
+
+    func.__name__ = op_name
+    return setop_check(func)
+
+
 @Appender(
     _interval_shared_docs["class"]
     % {
@@ -218,19 +243,38 @@ def wrapped(self, other, sort=False):
     }
 )
 @inherit_names(["set_closed", "to_tuples"], IntervalArray, wrap=True)
-@inherit_names(["__array__", "overlaps", "contains"], IntervalArray)
+@inherit_names(
+    [
+        "__array__",
+        "overlaps",
+        "contains",
+        "closed_left",
+        "closed_right",
+        "open_left",
+        "open_right",
+        "is_empty",
+    ],
+    IntervalArray,
+)
 @inherit_names(["is_non_overlapping_monotonic", "closed"], IntervalArray, cache=True)
-class IntervalIndex(IntervalMixin, ExtensionIndex):
+class IntervalIndex(ExtensionIndex):
     _typ = "intervalindex"
     _comparables = ["name"]
     _attributes = ["name", "closed"]
 
+    # annotate properties pinned via inherit_names
+    closed: str
+    is_non_overlapping_monotonic: bool
+    closed_left: bool
+    closed_right: bool
+
     # we would like our indexing holder to defer to us
     _defer_to_indexing = True
 
     _data: IntervalArray
     _values: IntervalArray
     _can_hold_strings = False
+    _data_cls = IntervalArray
 
     # --------------------------------------------------------------------
     # Constructors
@@ -241,7 +285,7 @@ def __new__(
         closed=None,
         dtype: Optional[Dtype] = None,
         copy: bool = False,
-        name=None,
+        name: Hashable = None,
         verify_integrity: bool = True,
     ):
 
@@ -258,26 +302,6 @@ def __new__(
 
         return cls._simple_new(array, name)
 
-    @classmethod
-    def _simple_new(cls, array: IntervalArray, name: Hashable = None):
-        """
-        Construct from an IntervalArray
-
-        Parameters
-        ----------
-        array : IntervalArray
-        name : Label, default None
-            Attached as result.name
-        """
-        assert isinstance(array, IntervalArray), type(array)
-
-        result = IntervalMixin.__new__(cls)
-        result._data = array
-        result.name = name
-        result._cache = {}
-        result._reset_identity()
-        return result
-
     @classmethod
     @Appender(
         _interval_shared_docs["from_breaks"]
@@ -605,7 +629,7 @@ def _searchsorted_monotonic(self, label, side: str = "left"):
                 "non-overlapping and all monotonic increasing or decreasing"
             )
 
-        if isinstance(label, IntervalMixin):
+        if isinstance(label, (IntervalMixin, IntervalIndex)):
             raise NotImplementedError("Interval objects are not currently supported")
 
         # GH 20921: "not is_monotonic_increasing" for the second condition
@@ -1012,26 +1036,6 @@ def _intersection_non_unique(self, other: IntervalIndex) -> IntervalIndex:
 
         return self[mask]
 
-    def _setop(op_name: str, sort=None):
-        def func(self, other, sort=sort):
-            # At this point we are assured
-            #  isinstance(other, IntervalIndex)
-            #  other.closed == self.closed
-
-            result = getattr(self._multiindex, op_name)(other._multiindex, sort=sort)
-            result_name = get_op_result_name(self, other)
-
-            # GH 19101: ensure empty results have correct dtype
-            if result.empty:
-                result = result._values.astype(self.dtype.subtype)
-            else:
-                result = result._values
-
-            return type(self).from_tuples(result, closed=self.closed, name=result_name)
-
-        func.__name__ = op_name
-        return setop_check(func)
-
     _union = _setop("union")
     _difference = _setop("difference")