ENH: make "closed" part of IntervalDtype

pandas/conftest.py

@@ -703,8 +703,8 @@ def float_frame():
 # ----------------------------------------------------------------
 @pytest.fixture(
     params=[
-        (Interval(left=0, right=5), IntervalDtype("int64")),
-        (Interval(left=0.1, right=0.5), IntervalDtype("float64")),
+        (Interval(left=0, right=5), IntervalDtype("int64", "right")),
+        (Interval(left=0.1, right=0.5), IntervalDtype("float64", "right")),
         (Period("2012-01", freq="M"), "period[M]"),
         (Period("2012-02-01", freq="D"), "period[D]"),
         (

pandas/core/arrays/_arrow_utils.py

@@ -127,7 +127,7 @@ def __hash__(self):
         def to_pandas_dtype(self):
             import pandas as pd
 
-            return pd.IntervalDtype(self.subtype.to_pandas_dtype())
+            return pd.IntervalDtype(self.subtype.to_pandas_dtype(), self.closed)
 
     # register the type with a dummy instance
     _interval_type = ArrowIntervalType(pyarrow.int64(), "left")

pandas/core/arrays/interval.py

@@ -213,6 +213,9 @@ def _simple_new(
     ):
         result = IntervalMixin.__new__(cls)
 
+        if closed is None and isinstance(dtype, IntervalDtype):
+            closed = dtype.closed
+
         closed = closed or "right"
         left = ensure_index(left, copy=copy)
         right = ensure_index(right, copy=copy)
@@ -227,6 +230,10 @@ def _simple_new(
                 left = left.astype(dtype.subtype)
                 right = right.astype(dtype.subtype)
 
+            if dtype._closed is None:
+                # possibly loading an old pickle
+                dtype = IntervalDtype(dtype.subtype, closed)
+
         # coerce dtypes to match if needed
         if is_float_dtype(left) and is_integer_dtype(right):
             right = right.astype(left.dtype)
@@ -268,6 +275,9 @@ def _simple_new(
             # If these share data, then setitem could corrupt our IA
             right = right.copy()
 
+        dtype = IntervalDtype(left.dtype, closed=closed)
+        result._dtype = dtype
+
         result._left = left
         result._right = right
         result._closed = closed
@@ -534,7 +544,7 @@ def _shallow_copy(self, left, right):
 
     @property
     def dtype(self):
-        return IntervalDtype(self.left.dtype)
+        return self._dtype
 
     @property
     def nbytes(self) -> int:
@@ -1184,7 +1194,7 @@ def closed(self):
         Whether the intervals are closed on the left-side, right-side, both or
         neither.
         """
-        return self._closed
+        return self.dtype.closed
 
     _interval_shared_docs["set_closed"] = textwrap.dedent(
         """
@@ -1282,7 +1292,7 @@ def __array__(self, dtype=None) -> np.ndarray:
         left = self._left
         right = self._right
         mask = self.isna()
-        closed = self._closed
+        closed = self.closed
 
         result = np.empty(len(left), dtype=object)
         for i in range(len(left)):

pandas/core/dtypes/cast.py

@@ -812,7 +812,7 @@ def infer_dtype_from_scalar(val, pandas_dtype: bool = False) -> Tuple[DtypeObj,
             dtype = PeriodDtype(freq=val.freq)
         elif lib.is_interval(val):
             subtype = infer_dtype_from_scalar(val.left, pandas_dtype=True)[0]
-            dtype = IntervalDtype(subtype=subtype)
+            dtype = IntervalDtype(subtype=subtype, closed=val.closed)
 
     return dtype, val
 

pandas/core/dtypes/dtypes.py

@@ -15,6 +15,7 @@
     Union,
     cast,
 )
+import warnings
 
 import numpy as np
 import pytz
@@ -1011,28 +1012,60 @@ class IntervalDtype(PandasExtensionDtype):
     str = "|O08"
     base = np.dtype("O")
     num = 103
-    _metadata = ("subtype",)
-    _match = re.compile(r"(I|i)nterval\[(?P<subtype>.+)\]")
+    _metadata = (
+        "subtype",
+        "closed",
+    )
+    _match = re.compile(
+        r"(I|i)nterval\[(?P<subtype>[^,]+)(, (?P<closed>(right|left|both|neither)))?\]"
+    )
     _cache: Dict[str_type, PandasExtensionDtype] = {}
 
-    def __new__(cls, subtype=None):
+    def __new__(cls, subtype=None, closed: Optional[str_type] = None):
         from pandas.core.dtypes.common import is_string_dtype, pandas_dtype
 
+        if closed is not None and closed not in {"right", "left", "both", "neither"}:
+            raise ValueError("closed must be one of 'right', 'left', 'both', 'neither'")
+
         if isinstance(subtype, IntervalDtype):
+            if closed is not None and closed != subtype.closed:
+                raise ValueError(
+                    "dtype.closed and 'closed' do not match. "
+                    "Try IntervalDtype(dtype.subtype, closed) instead."
+                )
             return subtype
         elif subtype is None:
             # we are called as an empty constructor
             # generally for pickle compat
             u = object.__new__(cls)
             u._subtype = None
+            u._closed = closed
             return u
         elif isinstance(subtype, str) and subtype.lower() == "interval":
             subtype = None
         else:
             if isinstance(subtype, str):
                 m = cls._match.search(subtype)
                 if m is not None:
-                    subtype = m.group("subtype")
+                    gd = m.groupdict()
+                    subtype = gd["subtype"]
+                    if gd.get("closed", None) is not None:
+                        closed = gd["closed"]
+                    elif closed is not None:
+                        # user passed eg. IntervalDtype("interval[int64]", "left")
+                        pass
+                    else:
+                        warnings.warn(
+                            "Constructing an IntervalDtype from a string without "
+                            "specifying 'closed' is deprecated and will raise in "
+                            "a future version. "
+                            f"Use e.g. 'interval[{subtype}, left]'. "
+                            "Defaulting to closed='right'.",
+                            FutureWarning,
+                            stacklevel=2,
+                        )
+                        # default to "right"
+                        closed = "right"
 
             try:
                 subtype = pandas_dtype(subtype)
@@ -1047,14 +1080,32 @@ def __new__(cls, subtype=None):
             )
             raise TypeError(msg)
 
+        if closed is None and subtype is not None:
+            warnings.warn(
+                "Constructing an IntervalDtype without "
+                "specifying 'closed' is deprecated and will raise in "
+                "a future version. "
+                "Use e.g. IntervalDtype(np.int64, 'left'). "
+                "Defaulting to closed='right'.",
+                FutureWarning,
+                stacklevel=2,
+            )
+            closed = "right"
+
+        key = str(subtype) + str(closed)
         try:
-            return cls._cache[str(subtype)]
+            return cls._cache[key]
         except KeyError:
             u = object.__new__(cls)
             u._subtype = subtype
-            cls._cache[str(subtype)] = u
+            u._closed = closed
+            cls._cache[key] = u
             return u
 
+    @property
+    def closed(self):
+        return self._closed
+
     @property
     def subtype(self):
         """
@@ -1104,7 +1155,7 @@ def type(self):
     def __str__(self) -> str_type:
         if self.subtype is None:
             return "interval"
-        return f"interval[{self.subtype}]"
+        return f"interval[{self.subtype}, {self.closed}]"
 
     def __hash__(self) -> int:
         # make myself hashable
@@ -1118,6 +1169,8 @@ def __eq__(self, other: Any) -> bool:
         elif self.subtype is None or other.subtype is None:
             # None should match any subtype
             return True
+        elif self.closed != other.closed:
+            return False
         else:
             from pandas.core.dtypes.common import is_dtype_equal
 
@@ -1128,6 +1181,15 @@ def __setstate__(self, state):
         # PandasExtensionDtype superclass and uses the public properties to
         # pickle -> need to set the settable private ones here (see GH26067)
         self._subtype = state["subtype"]
+        # backward-compat older pickles won't have "closed" key
+        self._closed = state.pop("closed", None)
+        if self._closed is None:
+            warnings.warn(
+                "Unpickled legacy IntervalDtype does not specify 'closed' "
+                "attribute.  Set dtype._closed to one of 'left', 'right', 'both', "
+                "'neither' before using this IntervalDtype object.",
+                UserWarning,
+            )
 
     @classmethod
     def is_dtype(cls, dtype: object) -> bool:

pandas/core/reshape/tile.py

@@ -135,7 +135,7 @@ def cut(
     >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)
     ... # doctest: +ELLIPSIS
     [(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
-    Categories (3, interval[float64]): [(0.994, 3.0] < (3.0, 5.0] ...
+    Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...
 
     >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True)
     ... # doctest: +ELLIPSIS
@@ -176,7 +176,7 @@ def cut(
     d     (7.333, 10.0]
     e     (7.333, 10.0]
     dtype: category
-    Categories (3, interval[float64]): [(1.992, 4.667] < (4.667, ...
+    Categories (3, interval[float64, right]): [(1.992, 4.667] < (4.667, ...
 
     Passing a Series as an input returns a Series with mapping value.
     It is used to map numerically to intervals based on bins.
@@ -214,7 +214,7 @@ def cut(
     >>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)])
     >>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins)
     [NaN, (0.0, 1.0], NaN, (2.0, 3.0], (4.0, 5.0]]
-    Categories (3, interval[int64]): [(0, 1] < (2, 3] < (4, 5]]
+    Categories (3, interval[int64, right]): [(0, 1] < (2, 3] < (4, 5]]
     """
     # NOTE: this binning code is changed a bit from histogram for var(x) == 0
 

pandas/tests/arithmetic/test_interval.py

@@ -133,7 +133,7 @@ def test_compare_scalar_na(self, op, array, nulls_fixture, request):
         result = op(array, nulls_fixture)
         expected = self.elementwise_comparison(op, array, nulls_fixture)
 
-        if nulls_fixture is pd.NA and array.dtype != pd.IntervalDtype("int64"):
+        if nulls_fixture is pd.NA and array.dtype.subtype != "int64":
             mark = pytest.mark.xfail(
                 reason="broken for non-integer IntervalArray; see GH 31882"
             )

pandas/tests/arrays/interval/test_interval.py

@@ -131,7 +131,7 @@ def test_repr():
     expected = (
         "<IntervalArray>\n"
         "[(0, 1], (1, 2]]\n"
-        "Length: 2, closed: right, dtype: interval[int64]"
+        "Length: 2, closed: right, dtype: interval[int64, right]"
     )
     assert result == expected
 

pandas/tests/dtypes/cast/test_infer_dtype.py

@@ -124,7 +124,7 @@ def test_infer_from_interval(left, right, subtype, closed, pandas_dtype):
     # GH 30337
     interval = Interval(left, right, closed)
     result_dtype, result_value = infer_dtype_from_scalar(interval, pandas_dtype)
-    expected_dtype = f"interval[{subtype}]" if pandas_dtype else np.object_
+    expected_dtype = f"interval[{subtype}, {closed}]" if pandas_dtype else np.object_
     assert result_dtype == expected_dtype
     assert result_value == interval