Revert "CLN: Rename private variables to inclusive (pandas-dev#47655)"

This reverts commit 102b3ca.

Author: mroeschke

pandas/_libs/interval.pyi

@@ -15,7 +15,7 @@ from pandas._typing import (
     Timestamp,
 )
 
-VALID_INCLUSIVE: frozenset[str]
+VALID_CLOSED: frozenset[str]
 
 _OrderableScalarT = TypeVar("_OrderableScalarT", int, float)
 _OrderableTimesT = TypeVar("_OrderableTimesT", Timestamp, Timedelta)
@@ -50,9 +50,7 @@ class IntervalMixin:
     def open_right(self) -> bool: ...
     @property
     def is_empty(self) -> bool: ...
-    def _check_inclusive_matches(
-        self, other: IntervalMixin, name: str = ...
-    ) -> None: ...
+    def _check_closed_matches(self, other: IntervalMixin, name: str = ...) -> None: ...
 
 def _warning_interval(
     inclusive, closed
@@ -157,7 +155,7 @@ class Interval(IntervalMixin, Generic[_OrderableT]):
     def overlaps(self: Interval[_OrderableT], other: Interval[_OrderableT]) -> bool: ...
 
 def intervals_to_interval_bounds(
-    intervals: np.ndarray, validate_inclusive: bool = ...
+    intervals: np.ndarray, validate_closed: bool = ...
 ) -> tuple[np.ndarray, np.ndarray, IntervalInclusiveType]: ...
 
 class IntervalTree(IntervalMixin):

pandas/_libs/interval.pyx

@@ -58,7 +58,7 @@ from pandas._libs.tslibs.util cimport (
     is_timedelta64_object,
 )
 
-VALID_INCLUSIVE = frozenset(['both', 'neither', 'left', 'right'])
+VALID_CLOSED = frozenset(['both', 'neither', 'left', 'right'])
 
 
 cdef class IntervalMixin:
@@ -87,7 +87,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            True if the Interval is closed on the right-side.
+            True if the Interval is closed on the left-side.
         """
         return self.inclusive in ('right', 'both')
 
@@ -101,7 +101,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            True if the Interval is not closed on the left-side.
+            True if the Interval is closed on the left-side.
         """
         return not self.closed_left
 
@@ -115,7 +115,7 @@ cdef class IntervalMixin:
         Returns
         -------
         bool
-            True if the Interval is not closed on the right-side.
+            True if the Interval is closed on the left-side.
         """
         return not self.closed_right
 
@@ -190,7 +190,7 @@ cdef class IntervalMixin:
         """
         return (self.right == self.left) & (self.inclusive != 'both')
 
-    def _check_inclusive_matches(self, other, name='other'):
+    def _check_closed_matches(self, other, name='other'):
         """
         Check if the inclusive attribute of `other` matches.
 
@@ -205,7 +205,7 @@ cdef class IntervalMixin:
         Raises
         ------
         ValueError
-            When `other` is not inclusive exactly the same as self.
+            When `other` is not closed exactly the same as self.
         """
         if self.inclusive != other.inclusive:
             raise ValueError(f"'{name}.inclusive' is {repr(other.inclusive)}, "
@@ -261,14 +261,14 @@ cdef class Interval(IntervalMixin):
         .. deprecated:: 1.5.0
 
     inclusive : {'both', 'neither', 'left', 'right'}, default 'both'
-        Whether the interval is inclusive on the left-side, right-side, both or
+        Whether the interval is closed on the left-side, right-side, both or
         neither. See the Notes for more detailed explanation.
 
         .. versionadded:: 1.5.0
 
     See Also
     --------
-    IntervalIndex : An Index of Interval objects that are all inclusive on the
+    IntervalIndex : An Index of Interval objects that are all closed on the
         same side.
     cut : Convert continuous data into discrete bins (Categorical
         of Interval objects).
@@ -281,13 +281,13 @@ cdef class Interval(IntervalMixin):
     The parameters `left` and `right` must be from the same type, you must be
     able to compare them and they must satisfy ``left <= right``.
 
-    A inclusive interval (in mathematics denoted by square brackets) contains
-    its endpoints, i.e. the inclusive interval ``[0, 5]`` is characterized by the
+    A closed interval (in mathematics denoted by square brackets) contains
+    its endpoints, i.e. the closed interval ``[0, 5]`` is characterized by the
     conditions ``0 <= x <= 5``. This is what ``inclusive='both'`` stands for.
     An open interval (in mathematics denoted by parentheses) does not contain
     its endpoints, i.e. the open interval ``(0, 5)`` is characterized by the
     conditions ``0 < x < 5``. This is what ``inclusive='neither'`` stands for.
-    Intervals can also be half-open or half-inclusive, i.e. ``[0, 5)`` is
+    Intervals can also be half-open or half-closed, i.e. ``[0, 5)`` is
     described by ``0 <= x < 5`` (``inclusive='left'``) and ``(0, 5]`` is
     described by ``0 < x <= 5`` (``inclusive='right'``).
 
@@ -356,9 +356,8 @@ cdef class Interval(IntervalMixin):
 
     cdef readonly str inclusive
     """
-    String describing the inclusive side the intervals.
-
-    Either ``left``, ``right``, ``both`` or ``neither``.
+    Whether the interval is closed on the left-side, right-side, both or
+    neither.
     """
 
     def __init__(self, left, right, inclusive: str | None = None, closed: None | lib.NoDefault = lib.no_default):
@@ -373,7 +372,7 @@ cdef class Interval(IntervalMixin):
         if inclusive is None:
             inclusive = "right"
 
-        if inclusive not in VALID_INCLUSIVE:
+        if inclusive not in VALID_CLOSED:
             raise ValueError(f"invalid option for 'inclusive': {inclusive}")
         if not left <= right:
             raise ValueError("left side of interval must be <= right side")
@@ -538,7 +537,7 @@ cdef class Interval(IntervalMixin):
         """
         Check whether two Interval objects overlap.
 
-        Two intervals overlap if they share a common point, including inclusive
+        Two intervals overlap if they share a common point, including closed
         endpoints. Intervals that only have an open endpoint in common do not
         overlap.
 
@@ -567,7 +566,7 @@ cdef class Interval(IntervalMixin):
         >>> i1.overlaps(i3)
         False
 
-        Intervals that share inclusive endpoints overlap:
+        Intervals that share closed endpoints overlap:
 
         >>> i4 = pd.Interval(0, 1, inclusive='both')
         >>> i5 = pd.Interval(1, 2, inclusive='both')
@@ -584,7 +583,7 @@ cdef class Interval(IntervalMixin):
             raise TypeError("`other` must be an Interval, "
                             f"got {type(other).__name__}")
 
-        # equality is okay if both endpoints are inclusive (overlap at a point)
+        # equality is okay if both endpoints are closed (overlap at a point)
         op1 = le if (self.closed_left and other.closed_right) else lt
         op2 = le if (other.closed_left and self.closed_right) else lt
 
@@ -596,16 +595,16 @@ cdef class Interval(IntervalMixin):
 
 @cython.wraparound(False)
 @cython.boundscheck(False)
-def intervals_to_interval_bounds(ndarray intervals, bint validate_inclusive=True):
+def intervals_to_interval_bounds(ndarray intervals, bint validate_closed=True):
     """
     Parameters
     ----------
     intervals : ndarray
         Object array of Intervals / nulls.
 
-    validate_inclusive: bool, default True
-        Boolean indicating if all intervals must be inclusive on the same side.
-        Mismatching inclusive will raise if True, else return None for inclusive.
+    validate_closed: bool, default True
+        Boolean indicating if all intervals must be closed on the same side.
+        Mismatching closed will raise if True, else return None for closed.
 
     Returns
     -------
@@ -618,7 +617,7 @@ def intervals_to_interval_bounds(ndarray intervals, bint validate_inclusive=True
         object inclusive = None, interval
         Py_ssize_t i, n = len(intervals)
         ndarray left, right
-        bint seen_inclusive = False
+        bint seen_closed = False
 
     left = np.empty(n, dtype=intervals.dtype)
     right = np.empty(n, dtype=intervals.dtype)
@@ -636,13 +635,13 @@ def intervals_to_interval_bounds(ndarray intervals, bint validate_inclusive=True
 
         left[i] = interval.left
         right[i] = interval.right
-        if not seen_inclusive:
-            seen_inclusive = True
+        if not seen_closed:
+            seen_closed = True
             inclusive = interval.inclusive
         elif inclusive != interval.inclusive:
             inclusive = None
-            if validate_inclusive:
-                raise ValueError("intervals must all be inclusive on the same side")
+            if validate_closed:
+                raise ValueError("intervals must all be closed on the same side")
 
     return left, right, inclusive
 

pandas/core/arrays/arrow/extension_types.py

@@ -9,7 +9,7 @@
 from pandas.util._decorators import deprecate_kwarg
 from pandas.util._exceptions import find_stack_level
 
-from pandas.core.arrays.interval import VALID_INCLUSIVE
+from pandas.core.arrays.interval import VALID_CLOSED
 
 
 class ArrowPeriodType(pyarrow.ExtensionType):
@@ -57,7 +57,7 @@ class ArrowIntervalType(pyarrow.ExtensionType):
     def __init__(self, subtype, inclusive: IntervalInclusiveType) -> None:
         # attributes need to be set first before calling
         # super init (as that calls serialize)
-        assert inclusive in VALID_INCLUSIVE
+        assert inclusive in VALID_CLOSED
         self._inclusive: IntervalInclusiveType = inclusive
         if not isinstance(subtype, pyarrow.DataType):
             subtype = pyarrow.type_for_alias(str(subtype))

pandas/core/arrays/interval.py

@@ -24,7 +24,7 @@
 
 from pandas._libs import lib
 from pandas._libs.interval import (
-    VALID_INCLUSIVE,
+    VALID_CLOSED,
     Interval,
     IntervalMixin,
     intervals_to_interval_bounds,
@@ -131,7 +131,7 @@
     Array-like containing Interval objects from which to build the
     %(klass)s.
 inclusive : {'left', 'right', 'both', 'neither'}, default 'right'
-    Whether the intervals are inclusive on the left-side, right-side, both or
+    Whether the intervals are closed on the left-side, right-side, both or
     neither.
 dtype : dtype or None, default None
     If None, dtype will be inferred.
@@ -186,8 +186,7 @@
     _interval_shared_docs["class"]
     % {
         "klass": "IntervalArray",
-        "summary": "Pandas array for interval data that are inclusive on the same "
-        "side.",
+        "summary": "Pandas array for interval data that are closed on the same side.",
         "versionadded": "0.24.0",
         "name": "",
         "extra_attributes": "",
@@ -256,13 +255,13 @@ def __new__(
 
             # might need to convert empty or purely na data
             data = _maybe_convert_platform_interval(data)
-            left, right, infer_inclusive = intervals_to_interval_bounds(
-                data, validate_inclusive=inclusive is None
+            left, right, infer_closed = intervals_to_interval_bounds(
+                data, validate_closed=inclusive is None
             )
             if left.dtype == object:
                 left = lib.maybe_convert_objects(left)
                 right = lib.maybe_convert_objects(right)
-            inclusive = inclusive or infer_inclusive
+            inclusive = inclusive or infer_closed
 
         return cls._simple_new(
             left,
@@ -391,7 +390,7 @@ def _from_factorized(
         breaks : array-like (1-dimensional)
             Left and right bounds for each interval.
         inclusive : {'left', 'right', 'both', 'neither'}, default 'right'
-            Whether the intervals are inclusive on the left-side, right-side, both
+            Whether the intervals are closed on the left-side, right-side, both
             or neither.
         copy : bool, default False
             Copy the data.
@@ -457,7 +456,7 @@ def from_breaks(
         right : array-like (1-dimensional)
             Right bounds for each interval.
         inclusive : {'left', 'right', 'both', 'neither'}, default 'right'
-            Whether the intervals are inclusive on the left-side, right-side, both
+            Whether the intervals are closed on the left-side, right-side, both
             or neither.
         copy : bool, default False
             Copy the data.
@@ -544,7 +543,7 @@ def from_arrays(
         data : array-like (1-dimensional)
             Array of tuples.
         inclusive : {'left', 'right', 'both', 'neither'}, default 'right'
-            Whether the intervals are inclusive on the left-side, right-side, both
+            Whether the intervals are closed on the left-side, right-side, both
             or neither.
         copy : bool, default False
             By-default copy the data, this is compat only and ignored.
@@ -631,7 +630,7 @@ def _validate(self):
         * left and right have the same missing values
         * left is always below right
         """
-        if self.inclusive not in VALID_INCLUSIVE:
+        if self.inclusive not in VALID_CLOSED:
             msg = f"invalid option for 'inclusive': {self.inclusive}"
             raise ValueError(msg)
         if len(self._left) != len(self._right):
@@ -747,7 +746,7 @@ def _cmp_method(self, other, op):
             # for categorical defer to categories for dtype
             other_dtype = other.categories.dtype
 
-            # extract intervals if we have interval categories with matching inclusive
+            # extract intervals if we have interval categories with matching closed
             if is_interval_dtype(other_dtype):
                 if self.inclusive != other.categories.inclusive:
                     return invalid_comparison(self, other, op)
@@ -756,7 +755,7 @@ def _cmp_method(self, other, op):
                     other.codes, allow_fill=True, fill_value=other.categories._na_value
                 )
 
-        # interval-like -> need same inclusive and matching endpoints
+        # interval-like -> need same closed and matching endpoints
         if is_interval_dtype(other_dtype):
             if self.inclusive != other.inclusive:
                 return invalid_comparison(self, other, op)
@@ -996,7 +995,7 @@ def _concat_same_type(
         """
         inclusive_set = {interval.inclusive for interval in to_concat}
         if len(inclusive_set) != 1:
-            raise ValueError("Intervals must all be inclusive on the same side.")
+            raise ValueError("Intervals must all be closed on the same side.")
         inclusive = inclusive_set.pop()
 
         left = np.concatenate([interval.left for interval in to_concat])
@@ -1122,7 +1121,7 @@ def _validate_listlike(self, value):
         # list-like of intervals
         try:
             array = IntervalArray(value)
-            self._check_inclusive_matches(array, name="value")
+            self._check_closed_matches(array, name="value")
             value_left, value_right = array.left, array.right
         except TypeError as err:
             # wrong type: not interval or NA
@@ -1142,7 +1141,7 @@ def _validate_listlike(self, value):
 
     def _validate_scalar(self, value):
         if isinstance(value, Interval):
-            self._check_inclusive_matches(value, name="value")
+            self._check_closed_matches(value, name="value")
             left, right = value.left, value.right
             # TODO: check subdtype match like _validate_setitem_value?
         elif is_valid_na_for_dtype(value, self.left.dtype):
@@ -1168,7 +1167,7 @@ def _validate_setitem_value(self, value):
 
         elif isinstance(value, Interval):
             # scalar
-            self._check_inclusive_matches(value, name="value")
+            self._check_closed_matches(value, name="value")
             value_left, value_right = value.left, value.right
             self.left._validate_fill_value(value_left)
             self.left._validate_fill_value(value_right)
@@ -1351,7 +1350,7 @@ def overlaps(self, other):
             msg = f"`other` must be Interval-like, got {type(other).__name__}"
             raise TypeError(msg)
 
-        # equality is okay if both endpoints are inclusive (overlap at a point)
+        # equality is okay if both endpoints are closed (overlap at a point)
         op1 = le if (self.closed_left and other.closed_right) else lt
         op2 = le if (other.closed_left and self.closed_right) else lt
 
@@ -1365,9 +1364,8 @@ def overlaps(self, other):
     @property
     def inclusive(self) -> IntervalInclusiveType:
         """
-        String describing the inclusive side the intervals.
-
-        Either ``left``, ``right``, ``both`` or ``neither``.
+        Whether the intervals are closed on the left-side, right-side, both or
+        neither.
         """
         return self.dtype.inclusive
 
@@ -1481,7 +1479,7 @@ def set_closed(
     def set_inclusive(
         self: IntervalArrayT, inclusive: IntervalInclusiveType
     ) -> IntervalArrayT:
-        if inclusive not in VALID_INCLUSIVE:
+        if inclusive not in VALID_CLOSED:
             msg = f"invalid option for 'inclusive': {inclusive}"
             raise ValueError(msg)