|
1 | 1 | from __future__ import annotations
|
2 |
| -import sys |
3 |
| -from typing import Generic, overload, Union, Protocol, TypeVar |
4 |
| -from _typing import Timedelta, Timestamp |
5 |
| -import datetime |
6 | 2 |
|
7 |
| -if sys.version_info >= (3, 8): |
8 |
| - from typing import Literal |
9 |
| -else: |
10 |
| - from typing_extensions import Literal |
| 3 | +from typing import ( |
| 4 | + Any, |
| 5 | + Generic, |
| 6 | + Literal, |
| 7 | + Tuple, |
| 8 | + TypeVar, |
| 9 | + Union, |
| 10 | + overload, |
| 11 | +) |
11 | 12 |
|
12 |
| -OrderableScalar = TypeVar("OrderableScalar", int, float) |
13 |
| -OrderableTimes = TypeVar("OrderableTimes", datetime.date, datetime.datetime, datetime.timedelta, Timestamp, Timedelta) |
14 |
| -Orderable = TypeVar("Orderable", int, float, datetime.date, datetime.datetime, datetime.timedelta, Timestamp, Timedelta) |
| 13 | +import numpy as np |
| 14 | +import numpy.typing as npt |
15 | 15 |
|
16 |
| -class IntervalMixinProtocol(Protocol): ... |
| 16 | +from pandas._typing import ( |
| 17 | + Timedelta, |
| 18 | + Timestamp, |
| 19 | +) |
| 20 | + |
| 21 | +VALID_CLOSED: frozenset[str] |
| 22 | + |
| 23 | +_OrderableScalarT = TypeVar("_OrderableScalarT", int, float) |
| 24 | +_OrderableTimesT = TypeVar("_OrderableTimesT", Timestamp, Timedelta) |
| 25 | +_OrderableT = TypeVar("_OrderableT", int, float, Timestamp, Timedelta) |
| 26 | + |
| 27 | +class _LengthDescriptor: |
| 28 | + @overload |
| 29 | + def __get__(self, instance: Interval[float], owner: Any) -> float: ... |
| 30 | + @overload |
| 31 | + def __get__(self, instance: Interval[int], owner: Any) -> int: ... |
| 32 | + @overload |
| 33 | + def __get__( |
| 34 | + self, instance: Interval[_OrderableTimesT], owner: Any |
| 35 | + ) -> Timedelta: ... |
| 36 | + @overload |
| 37 | + def __get__(self, instance: IntervalTree, owner: Any) -> np.ndarray: ... |
| 38 | + |
| 39 | +class _MidDescriptor: |
| 40 | + @overload |
| 41 | + def __get__(self, instance: Interval[_OrderableScalarT], owner: Any) -> float: ... |
| 42 | + @overload |
| 43 | + def __get__( |
| 44 | + self, instance: Interval[_OrderableTimesT], owner: Any |
| 45 | + ) -> _OrderableTimesT: ... |
| 46 | + @overload |
| 47 | + def __get__(self, instance: IntervalTree, owner: Any) -> np.ndarray: ... |
17 | 48 |
|
18 | 49 | class IntervalMixin:
|
19 | 50 | @property
|
20 |
| - def closed_left(self: IntervalMixinProtocol) -> bool: ... |
| 51 | + def closed_left(self) -> bool: ... |
21 | 52 | @property
|
22 |
| - def closed_right(self: IntervalMixinProtocol) -> bool: ... |
| 53 | + def closed_right(self) -> bool: ... |
23 | 54 | @property
|
24 |
| - def open_left(self: IntervalMixinProtocol) -> bool: ... |
| 55 | + def open_left(self) -> bool: ... |
25 | 56 | @property
|
26 |
| - def open_right(self: IntervalMixinProtocol) -> bool: ... |
| 57 | + def open_right(self) -> bool: ... |
| 58 | + mid: _MidDescriptor |
| 59 | + length: _LengthDescriptor |
27 | 60 | @property
|
28 |
| - def mid(self: IntervalMixinProtocol) -> float: ... |
29 |
| - @property |
30 |
| - def is_empty(self: IntervalMixinProtocol) -> bool: ... |
| 61 | + def is_empty(self) -> bool: ... |
| 62 | + def _check_closed_matches(self, other: IntervalMixin, name: str = ...) -> None: ... |
31 | 63 |
|
32 |
| -class Interval(IntervalMixin, Generic[Orderable]): |
33 |
| - @overload |
34 |
| - def left(self: Interval[OrderableScalar]) -> OrderableScalar: ... |
35 |
| - @overload |
36 |
| - def left(self: Interval[OrderableTimes]) -> OrderableTimes: ... |
| 64 | +class Interval(IntervalMixin, Generic[_OrderableT]): |
37 | 65 | @property
|
38 |
| - @overload |
39 |
| - def left(self: Interval[Orderable]) -> Orderable: ... |
40 |
| - @overload |
41 |
| - def right(self: Interval[OrderableScalar]) -> OrderableScalar: ... |
42 |
| - @overload |
43 |
| - def right(self: Interval[OrderableTimes]) -> OrderableTimes: ... |
| 66 | + def left(self: Interval[_OrderableT]) -> _OrderableT: ... |
44 | 67 | @property
|
45 |
| - @overload |
46 |
| - def right(self: Interval[Orderable]) -> Orderable: ... |
| 68 | + def right(self: Interval[_OrderableT]) -> _OrderableT: ... |
47 | 69 | @property
|
48 |
| - def closed(self) -> str: ... |
| 70 | + def closed(self) -> Literal["left", "right", "both", "neither"]: ... |
49 | 71 | def __init__(
|
50 | 72 | self,
|
51 |
| - left: Orderable, |
52 |
| - right: Orderable, |
53 |
| - closed: Union[str, Literal["left", "right", "both", "neither"]] = ..., |
54 |
| - ) -> None: ... |
55 |
| - @overload |
56 |
| - def length(self: Interval[OrderableScalar]) -> float: ... |
| 73 | + left: _OrderableT, |
| 74 | + right: _OrderableT, |
| 75 | + closed: Literal["left", "right", "both", "neither"] = ..., |
| 76 | + ): ... |
| 77 | + def __hash__(self) -> int: ... |
57 | 78 | @overload
|
58 |
| - def length(self: Interval[OrderableTimes]) -> Timedelta: ... |
59 |
| - @property |
| 79 | + def __contains__(self: Interval[_OrderableTimesT], _OrderableTimesT) -> bool: ... |
60 | 80 | @overload
|
61 |
| - def length(self: Interval[Orderable]) -> Orderable: ... |
62 |
| - def __hash__(self) -> int: ... |
63 |
| - def __contains__(self, key: Orderable) -> bool: ... |
| 81 | + def __contains__( |
| 82 | + self: Interval[_OrderableScalarT], key: Union[int, float] |
| 83 | + ) -> bool: ... |
64 | 84 | def __repr__(self) -> str: ...
|
65 | 85 | def __str__(self) -> str: ...
|
66 |
| - def __add__(self: Interval[Orderable], y: float) -> Interval[Orderable]: ... |
67 |
| - def __sub__(self: Interval[Orderable], y: float) -> Interval[Orderable]: ... |
68 |
| - def __mul__(self: Interval[Orderable], y: float) -> Interval[Orderable]: ... |
69 |
| - def __truediv__(self: Interval[Orderable], y: float) -> Interval[Orderable]: ... |
70 |
| - def __floordiv__(self: Interval[Orderable], y: float) -> Interval[Orderable]: ... |
71 |
| - def overlaps(self: Interval[Orderable], other: Interval[Orderable]) -> bool: ... |
| 86 | + @overload |
| 87 | + def __add__( |
| 88 | + self: Interval[_OrderableTimesT], y: Timedelta |
| 89 | + ) -> Interval[_OrderableTimesT]: ... |
| 90 | + @overload |
| 91 | + def __add__(self: Interval[int], y: int) -> Interval[int]: ... |
| 92 | + @overload |
| 93 | + def __add__(self: Interval[int], y: float) -> Interval[float]: ... |
| 94 | + @overload |
| 95 | + def __add__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ... |
| 96 | + @overload |
| 97 | + def __radd__( |
| 98 | + self: Interval[_OrderableTimesT], y: Timedelta |
| 99 | + ) -> Interval[_OrderableTimesT]: ... |
| 100 | + @overload |
| 101 | + def __radd__(self: Interval[int], y: int) -> Interval[int]: ... |
| 102 | + @overload |
| 103 | + def __radd__(self: Interval[int], y: float) -> Interval[float]: ... |
| 104 | + @overload |
| 105 | + def __radd__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ... |
| 106 | + @overload |
| 107 | + def __sub__( |
| 108 | + self: Interval[_OrderableTimesT], y: Timedelta |
| 109 | + ) -> Interval[_OrderableTimesT]: ... |
| 110 | + @overload |
| 111 | + def __sub__(self: Interval[int], y: int) -> Interval[int]: ... |
| 112 | + @overload |
| 113 | + def __sub__(self: Interval[int], y: float) -> Interval[float]: ... |
| 114 | + @overload |
| 115 | + def __sub__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ... |
| 116 | + @overload |
| 117 | + def __rsub__( |
| 118 | + self: Interval[_OrderableTimesT], y: Timedelta |
| 119 | + ) -> Interval[_OrderableTimesT]: ... |
| 120 | + @overload |
| 121 | + def __rsub__(self: Interval[int], y: int) -> Interval[int]: ... |
| 122 | + @overload |
| 123 | + def __rsub__(self: Interval[int], y: float) -> Interval[float]: ... |
| 124 | + @overload |
| 125 | + def __rsub__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ... |
| 126 | + @overload |
| 127 | + def __mul__(self: Interval[int], y: int) -> Interval[int]: ... |
| 128 | + @overload |
| 129 | + def __mul__(self: Interval[int], y: float) -> Interval[float]: ... |
| 130 | + @overload |
| 131 | + def __mul__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ... |
| 132 | + @overload |
| 133 | + def __rmul__(self: Interval[int], y: int) -> Interval[int]: ... |
| 134 | + @overload |
| 135 | + def __rmul__(self: Interval[int], y: float) -> Interval[float]: ... |
| 136 | + @overload |
| 137 | + def __rmul__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ... |
| 138 | + @overload |
| 139 | + def __truediv__(self: Interval[int], y: int) -> Interval[int]: ... |
| 140 | + @overload |
| 141 | + def __truediv__(self: Interval[int], y: float) -> Interval[float]: ... |
| 142 | + @overload |
| 143 | + def __truediv__(self: Interval[float], y: Union[int, float]) -> Interval[float]: ... |
| 144 | + @overload |
| 145 | + def __floordiv__(self: Interval[int], y: int) -> Interval[int]: ... |
| 146 | + @overload |
| 147 | + def __floordiv__(self: Interval[int], y: float) -> Interval[float]: ... |
| 148 | + @overload |
| 149 | + def __floordiv__( |
| 150 | + self: Interval[float], y: Union[int, float] |
| 151 | + ) -> Interval[float]: ... |
| 152 | + def overlaps(self: Interval[_OrderableT], other: Interval[_OrderableT]) -> bool: ... |
| 153 | + |
| 154 | +def intervals_to_interval_bounds( |
| 155 | + intervals: np.ndarray, validate_closed: bool = ... |
| 156 | +) -> Tuple[np.ndarray, np.ndarray, str]: ... |
| 157 | + |
| 158 | +class IntervalTree(IntervalMixin): |
| 159 | + def __init__( |
| 160 | + self, |
| 161 | + left: np.ndarray, |
| 162 | + right: np.ndarray, |
| 163 | + closed: Literal["left", "right", "both", "neither"] = ..., |
| 164 | + leaf_size: int = ..., |
| 165 | + ): ... |
| 166 | + def get_indexer(self, target) -> npt.NDArray[np.intp]: ... |
| 167 | + def get_indexer_non_unique( |
| 168 | + self, target |
| 169 | + ) -> Tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ... |
| 170 | + _na_count: int |
| 171 | + @property |
| 172 | + def is_overlapping(self) -> bool: ... |
| 173 | + @property |
| 174 | + def is_monotonic_increasing(self) -> bool: ... |
| 175 | + def clear_mapping(self) -> None: ... |
0 commit comments