REF: Back IntervalArray by array instead of Index

pandas/_testing.py

@@ -976,8 +976,16 @@ def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray")
     """
     _check_isinstance(left, right, IntervalArray)
 
-    assert_index_equal(left.left, right.left, exact=exact, obj=f"{obj}.left")
-    assert_index_equal(left.right, right.right, exact=exact, obj=f"{obj}.left")
+    if left.left.dtype.kind in ["m", "M"]:
+        # We have a DatetimeArray or Timed
+        # TODO: `exact` keyword?
+        assert_equal(left.left, right.left, obj=f"{obj}.left", check_freq=False)
+        assert_equal(left.right, right.right, obj=f"{obj}.left", check_freq=False)
+    else:
+        # doesnt take check_freq
+        assert_equal(left.left, right.left, obj=f"{obj}.left")  # TODO: exact?
+        assert_equal(left.right, right.right, obj=f"{obj}.left")
+
     assert_attr_equal("closed", left, right, obj=obj)
 
 
@@ -988,20 +996,22 @@ def assert_period_array_equal(left, right, obj="PeriodArray"):
     assert_attr_equal("freq", left, right, obj=obj)
 
 
-def assert_datetime_array_equal(left, right, obj="DatetimeArray"):
+def assert_datetime_array_equal(left, right, obj="DatetimeArray", check_freq=True):
     __tracebackhide__ = True
     _check_isinstance(left, right, DatetimeArray)
 
     assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
-    assert_attr_equal("freq", left, right, obj=obj)
+    if check_freq:
+        assert_attr_equal("freq", left, right, obj=obj)
     assert_attr_equal("tz", left, right, obj=obj)
 
 
-def assert_timedelta_array_equal(left, right, obj="TimedeltaArray"):
+def assert_timedelta_array_equal(left, right, obj="TimedeltaArray", check_freq=True):
     __tracebackhide__ = True
     _check_isinstance(left, right, TimedeltaArray)
     assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
-    assert_attr_equal("freq", left, right, obj=obj)
+    if check_freq:
+        assert_attr_equal("freq", left, right, obj=obj)
 
 
 def raise_assert_detail(obj, message, left, right, diff=None, index_values=None):

pandas/core/arrays/interval.py

@@ -32,7 +32,6 @@
 from pandas.core.dtypes.dtypes import IntervalDtype
 from pandas.core.dtypes.generic import (
     ABCDatetimeIndex,
-    ABCIndexClass,
     ABCIntervalIndex,
     ABCPeriodIndex,
     ABCSeries,
@@ -43,7 +42,7 @@
 from pandas.core.arrays.base import ExtensionArray, _extension_array_shared_docs
 from pandas.core.arrays.categorical import Categorical
 import pandas.core.common as com
-from pandas.core.construction import array
+from pandas.core.construction import array, extract_array
 from pandas.core.indexers import check_array_indexer
 from pandas.core.indexes.base import ensure_index
 
@@ -161,10 +160,12 @@ def __new__(
         verify_integrity: bool = True,
     ):
 
-        if isinstance(data, ABCSeries) and is_interval_dtype(data.dtype):
-            data = data._values
+        if isinstance(data, (ABCSeries, ABCIntervalIndex)) and is_interval_dtype(
+            data.dtype
+        ):
+            data = data._values  # TODO: extract_array?
 
-        if isinstance(data, (cls, ABCIntervalIndex)):
+        if isinstance(data, cls):
             left = data.left
             right = data.right
             closed = closed or data.closed
@@ -243,8 +244,12 @@ def _simple_new(
             )
             raise ValueError(msg)
 
-        result._left = left
-        result._right = right
+        from pandas.core.ops.array_ops import maybe_upcast_datetimelike_array
+
+        left = maybe_upcast_datetimelike_array(left)
+        right = maybe_upcast_datetimelike_array(right)
+        result._left = extract_array(left, extract_numpy=True)
+        result._right = extract_array(right, extract_numpy=True)
         result._closed = closed
         if verify_integrity:
             result._validate()
@@ -511,15 +516,14 @@ def __getitem__(self, value):
         left = self.left[value]
         right = self.right[value]
 
-        # scalar
-        if not isinstance(left, ABCIndexClass):
+        if not isinstance(left, (np.ndarray, ExtensionArray)):
+            # scalar
             if is_scalar(left) and isna(left):
                 return self._fill_value
-            if np.ndim(left) > 1:
-                # GH#30588 multi-dimensional indexer disallowed
-                raise ValueError("multi-dimensional indexing not allowed")
             return Interval(left, right, self.closed)
-
+        if np.ndim(left) > 1:
+            # GH#30588 multi-dimensional indexer disallowed
+            raise ValueError("multi-dimensional indexing not allowed")
         return self._shallow_copy(left, right)
 
     def __setitem__(self, key, value):
@@ -557,15 +561,8 @@ def __setitem__(self, key, value):
 
         key = check_array_indexer(self, key)
 
-        # Need to ensure that left and right are updated atomically, so we're
-        # forced to copy, update the copy, and swap in the new values.
-        left = self.left.copy(deep=True)
-        left._values[key] = value_left
-        self._left = left
-
-        right = self.right.copy(deep=True)
-        right._values[key] = value_right
-        self._right = right
+        self._left[key] = value_left
+        self._right[key] = value_right  # TODO: needs tests for not breaking views
 
     def __eq__(self, other):
         # ensure pandas array for list-like and eliminate non-interval scalars
@@ -657,8 +654,10 @@ def fillna(self, value=None, method=None, limit=None):
 
         self._check_closed_matches(value, name="value")
 
-        left = self.left.fillna(value=value.left)
-        right = self.right.fillna(value=value.right)
+        from pandas import Index
+
+        left = Index(self.left).fillna(value=value.left)
+        right = Index(self.right).fillna(value=value.right)
         return self._shallow_copy(left, right)
 
     @property
@@ -684,6 +683,7 @@ def astype(self, dtype, copy=True):
         array : ExtensionArray or ndarray
             ExtensionArray or NumPy ndarray with 'dtype' for its dtype.
         """
+        from pandas import Index
         from pandas.core.arrays.string_ import StringDtype
 
         if dtype is not None:
@@ -695,8 +695,10 @@ def astype(self, dtype, copy=True):
 
             # need to cast to different subtype
             try:
-                new_left = self.left.astype(dtype.subtype)
-                new_right = self.right.astype(dtype.subtype)
+                # We need to use Index rules for astype to prevent casting
+                #  np.nan entries to int subtypes
+                new_left = Index(self.left).astype(dtype.subtype)
+                new_right = Index(self.right).astype(dtype.subtype)
             except TypeError as err:
                 msg = (
                     f"Cannot convert {self.dtype} to {dtype}; subtypes are incompatible"
@@ -758,13 +760,13 @@ def copy(self):
         -------
         IntervalArray
         """
-        left = self.left.copy(deep=True)
-        right = self.right.copy(deep=True)
+        left = self.left.copy()
+        right = self.right.copy()
         closed = self.closed
         # TODO: Could skip verify_integrity here.
         return type(self).from_arrays(left, right, closed=closed)
 
-    def isna(self):
+    def isna(self) -> np.ndarray:
         return isna(self.left)
 
     @property
@@ -790,7 +792,9 @@ def shift(self, periods: int = 1, fill_value: object = None) -> "IntervalArray":
 
         empty_len = min(abs(periods), len(self))
         if isna(fill_value):
-            fill_value = self.left._na_value
+            from pandas import Index
+
+            fill_value = Index(self.left)._na_value
             empty = IntervalArray.from_breaks([fill_value] * (empty_len + 1))
         else:
             empty = self._from_sequence([fill_value] * empty_len)
@@ -854,7 +858,9 @@ def take(self, indices, allow_fill=False, fill_value=None, axis=None, **kwargs):
         fill_left = fill_right = fill_value
         if allow_fill:
             if fill_value is None:
-                fill_left = fill_right = self.left._na_value
+                from pandas import Index
+
+                fill_left = fill_right = Index(self.left)._na_value
             elif is_interval(fill_value):
                 self._check_closed_matches(fill_value, name="fill_value")
                 fill_left, fill_right = fill_value.left, fill_value.right

pandas/core/indexes/interval.py

@@ -183,12 +183,8 @@ def func(intvidx_self, other, sort=False):
     )
 )
 @inherit_names(["set_closed", "to_tuples"], IntervalArray, wrap=True)
-@inherit_names(
-    ["__array__", "overlaps", "contains", "left", "right", "length"], IntervalArray
-)
-@inherit_names(
-    ["is_non_overlapping_monotonic", "mid", "closed"], IntervalArray, cache=True
-)
+@inherit_names(["__array__", "overlaps", "contains"], IntervalArray)
+@inherit_names(["is_non_overlapping_monotonic", "closed"], IntervalArray, cache=True)
 class IntervalIndex(IntervalMixin, ExtensionIndex):
     _typ = "intervalindex"
     _comparables = ["name"]
@@ -201,6 +197,8 @@ class IntervalIndex(IntervalMixin, ExtensionIndex):
     _mask = None
 
     _data: IntervalArray
+    _values: IntervalArray
+
     # --------------------------------------------------------------------
     # Constructors
 
@@ -407,7 +405,7 @@ def __reduce__(self):
         return _new_IntervalIndex, (type(self), d), None
 
     @Appender(Index.astype.__doc__)
-    def astype(self, dtype, copy=True):
+    def astype(self, dtype, copy: bool = True):
         with rewrite_exception("IntervalArray", type(self).__name__):
             new_values = self._values.astype(dtype, copy=copy)
         if is_interval_dtype(new_values.dtype):
@@ -436,7 +434,7 @@ def is_monotonic_decreasing(self) -> bool:
         return self[::-1].is_monotonic_increasing
 
     @cache_readonly
-    def is_unique(self):
+    def is_unique(self) -> bool:
         """
         Return True if the IntervalIndex contains unique elements, else False.
         """
@@ -891,6 +889,22 @@ def _convert_list_indexer(self, keyarr):
 
     # --------------------------------------------------------------------
 
+    @cache_readonly
+    def left(self) -> Index:
+        return Index(self._values.left)
+
+    @cache_readonly
+    def right(self) -> Index:
+        return Index(self._values.right)
+
+    @cache_readonly
+    def mid(self):
+        return Index(self._data.mid)
+
+    @property
+    def length(self):
+        return Index(self._data.length)
+
     @Appender(Index.where.__doc__)
     def where(self, cond, other=None):
         if other is None:

pandas/tests/extension/test_interval.py

@@ -147,9 +147,7 @@ class TestReshaping(BaseInterval, base.BaseReshapingTests):
 
 
 class TestSetitem(BaseInterval, base.BaseSetitemTests):
-    @pytest.mark.xfail(reason="GH#27147 setitem changes underlying index")
-    def test_setitem_preserves_views(self, data):
-        super().test_setitem_preserves_views(data)
+    pass
 
 
 class TestPrinting(BaseInterval, base.BasePrintingTests):

pandas/tests/series/indexing/test_getitem.py

@@ -101,7 +101,7 @@ def test_getitem_intlist_intindex_periodvalues(self):
     @pytest.mark.parametrize("box", [list, np.array, pd.Index])
     def test_getitem_intlist_intervalindex_non_int(self, box):
         # GH#33404 fall back to positional since ints are unambiguous
-        dti = date_range("2000-01-03", periods=3)
+        dti = date_range("2000-01-03", periods=3)._with_freq(None)
         ii = pd.IntervalIndex.from_breaks(dti)
         ser = Series(range(len(ii)), index=ii)
 

pandas/tests/util/test_assert_interval_array_equal.py

@@ -41,9 +41,9 @@ def test_interval_array_equal_periods_mismatch():
     msg = """\
 IntervalArray.left are different
 
-IntervalArray.left length are different
-\\[left\\]:  5, Int64Index\\(\\[0, 1, 2, 3, 4\\], dtype='int64'\\)
-\\[right\\]: 6, Int64Index\\(\\[0, 1, 2, 3, 4, 5\\], dtype='int64'\\)"""
+IntervalArray.left shapes are different
+\\[left\\]:  \\(5,\\)
+\\[right\\]: \\(6,\\)"""
 
     with pytest.raises(AssertionError, match=msg):
         tm.assert_interval_array_equal(arr1, arr2)
@@ -58,8 +58,8 @@ def test_interval_array_equal_end_mismatch():
 IntervalArray.left are different
 
 IntervalArray.left values are different \\(80.0 %\\)
-\\[left\\]:  Int64Index\\(\\[0, 2, 4, 6, 8\\], dtype='int64'\\)
-\\[right\\]: Int64Index\\(\\[0, 4, 8, 12, 16\\], dtype='int64'\\)"""
+\\[left\\]:  \\[0, 2, 4, 6, 8\\]
+\\[right\\]: \\[0, 4, 8, 12, 16\\]"""
 
     with pytest.raises(AssertionError, match=msg):
         tm.assert_interval_array_equal(arr1, arr2)
@@ -74,8 +74,8 @@ def test_interval_array_equal_start_mismatch():
 IntervalArray.left are different
 
 IntervalArray.left values are different \\(100.0 %\\)
-\\[left\\]:  Int64Index\\(\\[0, 1, 2, 3\\], dtype='int64'\\)
-\\[right\\]: Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+\\[left\\]:  \\[0, 1, 2, 3\\]
+\\[right\\]: \\[1, 2, 3, 4\\]"""
 
     with pytest.raises(AssertionError, match=msg):
         tm.assert_interval_array_equal(arr1, arr2)