Typeinterval part2

pandas/_libs/interval.pyi

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Generic,
+    Literal,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+import numpy as np
+import numpy.typing as npt
+
+from pandas._typing import (
+    Timedelta,
+    Timestamp,
+)
+
+VALID_CLOSED: frozenset[str]
+
+_OrderableScalarT = TypeVar("_OrderableScalarT", int, float)
+_OrderableTimesT = TypeVar("_OrderableTimesT", Timestamp, Timedelta)
+_OrderableT = TypeVar("_OrderableT", int, float, Timestamp, Timedelta)
+
+class _LengthDescriptor:
+    @overload
+    def __get__(self, instance: Interval[float], owner: Any) -> float: ...
+    @overload
+    def __get__(self, instance: Interval[int], owner: Any) -> int: ...
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableTimesT], owner: Any
+    ) -> Timedelta: ...
+    @overload
+    def __get__(
+        self, instance: IntervalTree[_OrderableT], owner: Any
+    ) -> _OrderableT: ...
+
+class _MidDescriptor:
+    @overload
+    def __get__(self, instance: Interval[_OrderableScalarT], owner: Any) -> float: ...
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableTimesT], owner: Any
+    ) -> _OrderableTimesT: ...
+    @overload
+    def __get__(
+        self, instance: IntervalTree[_OrderableT], owner: Any
+    ) -> _OrderableT: ...
+
+class IntervalMixin:
+    @property
+    def closed_left(self) -> bool: ...
+    @property
+    def closed_right(self) -> bool: ...
+    @property
+    def open_left(self) -> bool: ...
+    @property
+    def open_right(self) -> bool: ...
+    mid: _MidDescriptor
+    length: _LengthDescriptor
+    @property
+    def is_empty(self) -> bool: ...
+    def _check_closed_matches(self, other: IntervalMixin, name: str = ...) -> None: ...
+
+class Interval(IntervalMixin, Generic[_OrderableT]):
+    @property
+    def left(self: Interval[_OrderableT]) -> _OrderableT: ...
+    @property
+    def right(self: Interval[_OrderableT]) -> _OrderableT: ...
+    @property
+    def closed(self) -> Literal["left", "right", "both", "neither"]: ...
+    def __init__(
+        self,
+        left: _OrderableT,
+        right: _OrderableT,
+        closed: Literal["left", "right", "both", "neither"] = ...,
+    ): ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __contains__(self: Interval[_OrderableTimesT], _OrderableTimesT) -> bool: ...
+    @overload
+    def __contains__(
+        self: Interval[_OrderableScalarT], key: Union[int, float]
+    ) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    @overload
+    def __add__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __add__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __add__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __add__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ...
+    @overload
+    def __radd__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __radd__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __radd__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __radd__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ...
+    @overload
+    def __sub__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __sub__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __sub__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __sub__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ...
+    @overload
+    def __rsub__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __rsub__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __rsub__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __rsub__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ...
+    @overload
+    def __mul__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __mul__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __mul__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ...
+    @overload
+    def __rmul__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __rmul__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __rmul__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ...
+    @overload
+    def __truediv__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __truediv__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __truediv__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ...
+    @overload
+    def __floordiv__(self: Interval[int], y: int) -> Interval[int]: ...
+    @overload
+    def __floordiv__(self: Interval[int], y: float) -> Interval[float]: ...
+    @overload
+    def __floordiv__(
+        self: Interval[float], y: Union[int, float]
+    ) -> Interval[float]: ...
+    def overlaps(self: Interval[_OrderableT], other: Interval[_OrderableT]) -> bool: ...
+
+def intervals_to_interval_bounds(
+    intervals: np.ndarray, validate_closed: bool = ...
+) -> Tuple[np.ndarray, np.ndarray, str]: ...
+
+class IntervalTree(IntervalMixin, Generic[_OrderableT]):
+    def __init__(
+        self,
+        left: np.ndarray,
+        right: np.ndarray,
+        closed: Literal["left", "right", "both", "neither"] = ...,
+        leaf_size: int = ...,
+    ): ...
+    def get_indexer(self, target) -> npt.NDArray[np.intp]: ...
+    def get_indexer_non_unique(
+        self, target
+    ) -> Tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+    _na_count: int
+    @property
+    def is_overlapping(self) -> bool: ...
+    @property
+    def is_monotonic_increasing(self) -> bool: ...
+    def clear_mapping(self) -> None: ...

pandas/_typing.py

@@ -83,7 +83,7 @@
 PythonScalar = Union[str, int, float, bool]
 DatetimeLikeScalar = Union["Period", "Timestamp", "Timedelta"]
 PandasScalar = Union["Period", "Timestamp", "Timedelta", "Interval"]
-Scalar = Union[PythonScalar, PandasScalar]
+Scalar = Union[PythonScalar, PandasScalar, np.datetime64, np.timedelta64, datetime]
 IntStrT = TypeVar("IntStrT", int, str)
 
 

pandas/core/algorithms.py

@@ -759,7 +759,7 @@ def factorize(
     else:
         dtype = values.dtype
         values = _ensure_data(values)
-        na_value: Scalar
+        na_value: Scalar | None
 
         if original.dtype.kind in ["m", "M"]:
             # Note: factorize_array will cast NaT bc it has a __int__

pandas/core/arrays/interval.py

@@ -7,6 +7,7 @@
 )
 import textwrap
 from typing import (
+    Any,
     Sequence,
     TypeVar,
     Union,
@@ -197,6 +198,11 @@ class IntervalArray(IntervalMixin, ExtensionArray):
     can_hold_na = True
     _na_value = _fill_value = np.nan
 
+    # To make mypy recognize the fields
+    _left: Any
+    _right: Any
+    _dtype: Any
+
     # ---------------------------------------------------------------------
     # Constructors
 

pandas/core/arrays/masked.py

@@ -336,7 +336,7 @@ def to_numpy(
         self,
         dtype: npt.DTypeLike | None = None,
         copy: bool = False,
-        na_value: Scalar = lib.no_default,
+        na_value: Scalar | lib.NoDefault | libmissing.NAType = lib.no_default,
     ) -> np.ndarray:
         """
         Convert to a NumPy Array.

pandas/core/arrays/string_arrow.py

@@ -762,7 +762,7 @@ def _str_replace(
         return type(self)(result)
 
     def _str_match(
-        self, pat: str, case: bool = True, flags: int = 0, na: Scalar = None
+        self, pat: str, case: bool = True, flags: int = 0, na: Scalar | None = None
     ):
         if pa_version_under4p0:
             return super()._str_match(pat, case, flags, na)
@@ -771,7 +771,9 @@ def _str_match(
             pat = "^" + pat
         return self._str_contains(pat, case, flags, na, regex=True)
 
-    def _str_fullmatch(self, pat, case: bool = True, flags: int = 0, na: Scalar = None):
+    def _str_fullmatch(
+        self, pat, case: bool = True, flags: int = 0, na: Scalar | None = None
+    ):
         if pa_version_under4p0:
             return super()._str_fullmatch(pat, case, flags, na)
 

pandas/core/common.py

@@ -517,7 +517,7 @@ def f(x):
 
 
 def convert_to_list_like(
-    values: Scalar | Iterable | AnyArrayLike,
+    values: Scalar | Iterable | AnyArrayLike | Hashable,
 ) -> list | AnyArrayLike:
     """
     Convert list-like or scalar input to list-like. List, numpy and pandas array-like

pandas/core/indexes/interval.py

@@ -9,6 +9,7 @@
 from typing import (
     Any,
     Hashable,
+    Literal,
 )
 
 import numpy as np
@@ -191,10 +192,12 @@ class IntervalIndex(ExtensionIndex):
     _typ = "intervalindex"
 
     # annotate properties pinned via inherit_names
-    closed: str
+    closed: Literal["left", "right", "both", "neither"]
     is_non_overlapping_monotonic: bool
     closed_left: bool
     closed_right: bool
+    open_left: bool
+    open_right: bool
 
     _data: IntervalArray
     _values: IntervalArray
@@ -317,9 +320,10 @@ def from_tuples(
         return cls._simple_new(arr, name=name)
 
     # --------------------------------------------------------------------
-
+    # error: Return type "IntervalTree" of "_engine" incompatible with return type
+    # "Union[IndexEngine, ExtensionEngine]" in supertype "Index"
     @cache_readonly
-    def _engine(self) -> IntervalTree:
+    def _engine(self) -> IntervalTree:  # type: ignore[override]
         left = self._maybe_convert_i8(self.left)
         right = self._maybe_convert_i8(self.right)
         return IntervalTree(left, right, closed=self.closed)
@@ -511,7 +515,10 @@ def _maybe_convert_i8(self, key):
             left = self._maybe_convert_i8(key.left)
             right = self._maybe_convert_i8(key.right)
             constructor = Interval if scalar else IntervalIndex.from_arrays
-            return constructor(left, right, closed=self.closed)
+            # error: "object" not callable
+            return constructor(
+                left, right, closed=self.closed
+            )  # type: ignore[operator]
 
         if scalar:
             # Timestamp/Timedelta
@@ -543,7 +550,7 @@ def _maybe_convert_i8(self, key):
 
         return key_i8
 
-    def _searchsorted_monotonic(self, label, side: str = "left"):
+    def _searchsorted_monotonic(self, label, side: Literal["left", "right"] = "left"):
         if not self.is_non_overlapping_monotonic:
             raise KeyError(
                 "can only get slices from an IntervalIndex if bounds are "

pandas/core/tools/datetimes.py

@@ -10,8 +10,8 @@
     Hashable,
     List,
     Tuple,
-    TypeVar,
     Union,
+    cast,
     overload,
 )
 import warnings
@@ -66,6 +66,7 @@
 )
 from pandas.core import algorithms
 from pandas.core.algorithms import unique
+from pandas.core.arrays.base import ExtensionArray
 from pandas.core.arrays.datetimes import (
     maybe_convert_dtype,
     objects_to_datetime64ns,
@@ -85,7 +86,8 @@
 
 ArrayConvertible = Union[List, Tuple, AnyArrayLike, "Series"]
 Scalar = Union[int, float, str]
-DatetimeScalar = TypeVar("DatetimeScalar", Scalar, datetime)
+DatetimeScalar = Union[Scalar, datetime]
+
 DatetimeScalarOrArrayConvertible = Union[DatetimeScalar, ArrayConvertible]
 start_caching_at = 50
 
@@ -638,7 +640,7 @@ def to_datetime(
     infer_datetime_format: bool = ...,
     origin=...,
     cache: bool = ...,
-) -> DatetimeScalar | NaTType:
+) -> Timestamp | NaTType:
     ...
 
 
@@ -1061,6 +1063,13 @@ def to_datetime(
             result = convert_listlike(arg, format, name=arg.name)
     elif is_list_like(arg):
         try:
+            # error: Argument 1 to "_maybe_cache" has incompatible type
+            # "Union[float, str, datetime, List[Any], Tuple[Any, ...], ExtensionArray,
+            # ndarray[Any, Any], Series]"; expected "Union[List[Any], Tuple[Any, ...],
+            # Union[Union[ExtensionArray, ndarray[Any, Any]], Index, Series], Series]"
+            arg = cast(
+                Union[list, tuple, ExtensionArray, np.ndarray, "Series", Index], arg
+            )
             cache_array = _maybe_cache(arg, format, cache, convert_listlike)
         except OutOfBoundsDatetime:
             # caching attempts to create a DatetimeIndex, which may raise