Update dtypes.py

pandas/core/dtypes/dtypes.py

@@ -1038,7 +1038,7 @@ class IntervalDtype(PandasExtensionDtype):
 
     Examples
     --------
-    >>> pd.IntervalDtype(subtype='int64', closed='both')
+    >>> pd.IntervalDtype(subtype='int64', inclusive='both')
     interval[int64, both]
     """
 
@@ -1049,35 +1049,42 @@ class IntervalDtype(PandasExtensionDtype):
     num = 103
     _metadata = (
         "subtype",
-        "closed",
+        "inclusive",
     )
     _match = re.compile(
-        r"(I|i)nterval\[(?P<subtype>[^,]+)(, (?P<closed>(right|left|both|neither)))?\]"
+        r"(I|i)nterval\[(?P<subtype>[^,]+)(, (?P<inclusive>(right|left|both|neither)))?\]"
     )
     _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
 
-    def __new__(cls, subtype=None, closed: str_type | None = None):
+    def __new__(cls, subtype=None, inclusive: str_type | None = 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 inclusive is not None and inclusive not in {
+            "right",
+            "left",
+            "both",
+            "neither",
+        }:
+            raise ValueError(
+                "inclusive must be one of 'right', 'left', 'both', 'neither'"
+            )
 
         if isinstance(subtype, IntervalDtype):
-            if closed is not None and closed != subtype.closed:
+            if inclusive is not None and inclusive != subtype.inclusive:
                 raise ValueError(
-                    "dtype.closed and 'closed' do not match. "
-                    "Try IntervalDtype(dtype.subtype, closed) instead."
+                    "dtype.inclusive and 'inclusive' do not match. "
+                    "Try IntervalDtype(dtype.subtype, inclusive) 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
+            u._closed = inclusive
             return u
         elif isinstance(subtype, str) and subtype.lower() == "interval":
             subtype = None
@@ -1087,14 +1094,14 @@ def __new__(cls, subtype=None, closed: str_type | None = None):
                 if m is not None:
                     gd = m.groupdict()
                     subtype = gd["subtype"]
-                    if gd.get("closed", None) is not None:
-                        if closed is not None:
-                            if closed != gd["closed"]:
+                    if gd.get("inclusive", None) is not None:
+                        if inclusive is not None:
+                            if inclusive != gd["inclusive"]:
                                 raise ValueError(
-                                    "'closed' keyword does not match value "
+                                    "'inclusive' keyword does not match value "
                                     "specified in dtype string"
                                 )
-                        closed = gd["closed"]
+                        inclusive = gd["inclusive"]
 
             try:
                 subtype = pandas_dtype(subtype)
@@ -1109,13 +1116,13 @@ def __new__(cls, subtype=None, closed: str_type | None = None):
             )
             raise TypeError(msg)
 
-        key = str(subtype) + str(closed)
+        key = str(subtype) + str(inclusive)
         try:
             return cls._cache_dtypes[key]
         except KeyError:
             u = object.__new__(cls)
             u._subtype = subtype
-            u._closed = closed
+            u._closed = inclusive
             cls._cache_dtypes[key] = u
             return u
 
@@ -1132,7 +1139,7 @@ def _can_hold_na(self) -> bool:
         return True
 
     @property
-    def closed(self):
+    def inclusive(self):
         return self._closed
 
     @property
@@ -1184,10 +1191,10 @@ def type(self):
     def __str__(self) -> str_type:
         if self.subtype is None:
             return "interval"
-        if self.closed is None:
+        if self.inclusive is None:
             # Only partially initialized GH#38394
             return f"interval[{self.subtype}]"
-        return f"interval[{self.subtype}, {self.closed}]"
+        return f"interval[{self.subtype}, {self.inclusive}]"
 
     def __hash__(self) -> int:
         # make myself hashable
@@ -1201,7 +1208,7 @@ 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:
+        elif self.inclusive != other.inclusive:
             return False
         else:
             from pandas.core.dtypes.common import is_dtype_equal
@@ -1214,8 +1221,8 @@ def __setstate__(self, state):
         # 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)
+        # backward-compat older pickles won't have "inclusive" key
+        self._closed = state.pop("inclusive", None)
 
     @classmethod
     def is_dtype(cls, dtype: object) -> bool:
@@ -1257,31 +1264,31 @@ def __from_arrow__(
                 arr = arr.storage
             left = np.asarray(arr.field("left"), dtype=self.subtype)
             right = np.asarray(arr.field("right"), dtype=self.subtype)
-            iarr = IntervalArray.from_arrays(left, right, closed=self.closed)
+            iarr = IntervalArray.from_arrays(left, right, inclusive=self.inclusive)
             results.append(iarr)
 
         if not results:
             return IntervalArray.from_arrays(
                 np.array([], dtype=self.subtype),
                 np.array([], dtype=self.subtype),
-                closed=self.closed,
+                inclusive=self.inclusive,
             )
         return IntervalArray._concat_same_type(results)
 
     def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
         if not all(isinstance(x, IntervalDtype) for x in dtypes):
             return None
 
-        closed = cast("IntervalDtype", dtypes[0]).closed
-        if not all(cast("IntervalDtype", x).closed == closed for x in dtypes):
+        inclusive = cast("IntervalDtype", dtypes[0]).inclusive
+        if not all(cast("IntervalDtype", x).inclusive == inclusive for x in dtypes):
             return np.dtype(object)
 
         from pandas.core.dtypes.cast import find_common_type
 
         common = find_common_type([cast("IntervalDtype", x).subtype for x in dtypes])
         if common == object:
             return np.dtype(object)
-        return IntervalDtype(common, closed=closed)
+        return IntervalDtype(common, inclusive=inclusive)
 
 
 class PandasDtype(ExtensionDtype):