1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
import sys
from _operator import (
abs as abs,
add as add,
and_ as and_,
concat as concat,
contains as contains,
countOf as countOf,
delitem as delitem,
eq as eq,
floordiv as floordiv,
ge as ge,
getitem as getitem,
gt as gt,
iadd as iadd,
iand as iand,
iconcat as iconcat,
ifloordiv as ifloordiv,
ilshift as ilshift,
imatmul as imatmul,
imod as imod,
imul as imul,
index as index,
indexOf as indexOf,
inv as inv,
invert as invert,
ior as ior,
ipow as ipow,
irshift as irshift,
is_ as is_,
is_not as is_not,
isub as isub,
itruediv as itruediv,
ixor as ixor,
le as le,
length_hint as length_hint,
lshift as lshift,
lt as lt,
matmul as matmul,
mod as mod,
mul as mul,
ne as ne,
neg as neg,
not_ as not_,
or_ as or_,
pos as pos,
pow as pow,
rshift as rshift,
setitem as setitem,
sub as sub,
truediv as truediv,
truth as truth,
xor as xor,
)
from _typeshed import SupportsGetItem
from typing import Any, Generic, TypeVar, final, overload
from typing_extensions import TypeVarTuple, Unpack
_T = TypeVar("_T")
_T_co = TypeVar("_T_co", covariant=True)
_T1 = TypeVar("_T1")
_T2 = TypeVar("_T2")
_Ts = TypeVarTuple("_Ts")
__all__ = [
"abs",
"add",
"and_",
"attrgetter",
"concat",
"contains",
"countOf",
"delitem",
"eq",
"floordiv",
"ge",
"getitem",
"gt",
"iadd",
"iand",
"iconcat",
"ifloordiv",
"ilshift",
"imatmul",
"imod",
"imul",
"index",
"indexOf",
"inv",
"invert",
"ior",
"ipow",
"irshift",
"is_",
"is_not",
"isub",
"itemgetter",
"itruediv",
"ixor",
"le",
"length_hint",
"lshift",
"lt",
"matmul",
"methodcaller",
"mod",
"mul",
"ne",
"neg",
"not_",
"or_",
"pos",
"pow",
"rshift",
"setitem",
"sub",
"truediv",
"truth",
"xor",
]
if sys.version_info >= (3, 11):
from _operator import call as call
__all__ += ["call"]
if sys.version_info >= (3, 14):
from _operator import is_none as is_none, is_not_none as is_not_none
__all__ += ["is_none", "is_not_none"]
__lt__ = lt
__le__ = le
__eq__ = eq
__ne__ = ne
__ge__ = ge
__gt__ = gt
__not__ = not_
__abs__ = abs
__add__ = add
__and__ = and_
__floordiv__ = floordiv
__index__ = index
__inv__ = inv
__invert__ = invert
__lshift__ = lshift
__mod__ = mod
__mul__ = mul
__matmul__ = matmul
__neg__ = neg
__or__ = or_
__pos__ = pos
__pow__ = pow
__rshift__ = rshift
__sub__ = sub
__truediv__ = truediv
__xor__ = xor
__concat__ = concat
__contains__ = contains
__delitem__ = delitem
__getitem__ = getitem
__setitem__ = setitem
__iadd__ = iadd
__iand__ = iand
__iconcat__ = iconcat
__ifloordiv__ = ifloordiv
__ilshift__ = ilshift
__imod__ = imod
__imul__ = imul
__imatmul__ = imatmul
__ior__ = ior
__ipow__ = ipow
__irshift__ = irshift
__isub__ = isub
__itruediv__ = itruediv
__ixor__ = ixor
if sys.version_info >= (3, 11):
__call__ = call
# At runtime, these classes are implemented in C as part of the _operator module
# However, they consider themselves to live in the operator module, so we'll put
# them here.
@final
class attrgetter(Generic[_T_co]):
@overload
def __new__(cls, attr: str, /) -> attrgetter[Any]: ...
@overload
def __new__(cls, attr: str, attr2: str, /) -> attrgetter[tuple[Any, Any]]: ...
@overload
def __new__(cls, attr: str, attr2: str, attr3: str, /) -> attrgetter[tuple[Any, Any, Any]]: ...
@overload
def __new__(cls, attr: str, attr2: str, attr3: str, attr4: str, /) -> attrgetter[tuple[Any, Any, Any, Any]]: ...
@overload
def __new__(cls, attr: str, /, *attrs: str) -> attrgetter[tuple[Any, ...]]: ...
def __call__(self, obj: Any, /) -> _T_co: ...
@final
class itemgetter(Generic[_T_co]):
@overload
def __new__(cls, item: _T, /) -> itemgetter[_T]: ...
@overload
def __new__(cls, item1: _T1, item2: _T2, /, *items: Unpack[_Ts]) -> itemgetter[tuple[_T1, _T2, Unpack[_Ts]]]: ...
# __key: _KT_contra in SupportsGetItem seems to be causing variance issues, ie:
# TypeVar "_KT_contra@SupportsGetItem" is contravariant
# "tuple[int, int]" is incompatible with protocol "SupportsIndex"
# preventing [_T_co, ...] instead of [Any, ...]
#
# A suspected mypy issue prevents using [..., _T] instead of [..., Any] here.
# https://github.com/python/mypy/issues/14032
def __call__(self, obj: SupportsGetItem[Any, Any]) -> Any: ...
@final
class methodcaller:
def __init__(self, name: str, /, *args: Any, **kwargs: Any) -> None: ...
def __call__(self, obj: Any) -> Any: ...
|
