mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-08 13:04:46 +08:00
Stdlib: correct many parameter names (#9815)
This commit is contained in:
Alex Waygood
@@ -92,8 +92,8 @@ class object:
|
||||
# Overriding them in subclasses has different semantics, even if the override has an identical signature.
|
||||
def __setattr__(self, __name: str, __value: Any) -> None: ...
|
||||
def __delattr__(self, __name: str) -> None: ...
|
||||
def __eq__(self, __o: object) -> bool: ...
|
||||
def __ne__(self, __o: object) -> bool: ...
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __ne__(self, __value: object) -> bool: ...
|
||||
def __str__(self) -> str: ... # noqa: Y029
|
||||
def __repr__(self) -> str: ... # noqa: Y029
|
||||
def __hash__(self) -> int: ...
|
||||
@@ -183,8 +183,8 @@ class type:
|
||||
@classmethod
|
||||
def __prepare__(metacls, __name: str, __bases: tuple[type, ...], **kwds: Any) -> Mapping[str, object]: ...
|
||||
if sys.version_info >= (3, 10):
|
||||
def __or__(self, __t: Any) -> types.UnionType: ...
|
||||
def __ror__(self, __t: Any) -> types.UnionType: ...
|
||||
def __or__(self, __value: Any) -> types.UnionType: ...
|
||||
def __ror__(self, __value: Any) -> types.UnionType: ...
|
||||
|
||||
class super:
|
||||
@overload
|
||||
@@ -242,45 +242,45 @@ class int:
|
||||
signed: bool = False,
|
||||
) -> Self: ...
|
||||
|
||||
def __add__(self, __x: int) -> int: ...
|
||||
def __sub__(self, __x: int) -> int: ...
|
||||
def __mul__(self, __x: int) -> int: ...
|
||||
def __floordiv__(self, __x: int) -> int: ...
|
||||
def __truediv__(self, __x: int) -> float: ...
|
||||
def __mod__(self, __x: int) -> int: ...
|
||||
def __divmod__(self, __x: int) -> tuple[int, int]: ...
|
||||
def __radd__(self, __x: int) -> int: ...
|
||||
def __rsub__(self, __x: int) -> int: ...
|
||||
def __rmul__(self, __x: int) -> int: ...
|
||||
def __rfloordiv__(self, __x: int) -> int: ...
|
||||
def __rtruediv__(self, __x: int) -> float: ...
|
||||
def __rmod__(self, __x: int) -> int: ...
|
||||
def __rdivmod__(self, __x: int) -> tuple[int, int]: ...
|
||||
def __add__(self, __value: int) -> int: ...
|
||||
def __sub__(self, __value: int) -> int: ...
|
||||
def __mul__(self, __value: int) -> int: ...
|
||||
def __floordiv__(self, __value: int) -> int: ...
|
||||
def __truediv__(self, __value: int) -> float: ...
|
||||
def __mod__(self, __value: int) -> int: ...
|
||||
def __divmod__(self, __value: int) -> tuple[int, int]: ...
|
||||
def __radd__(self, __value: int) -> int: ...
|
||||
def __rsub__(self, __value: int) -> int: ...
|
||||
def __rmul__(self, __value: int) -> int: ...
|
||||
def __rfloordiv__(self, __value: int) -> int: ...
|
||||
def __rtruediv__(self, __value: int) -> float: ...
|
||||
def __rmod__(self, __value: int) -> int: ...
|
||||
def __rdivmod__(self, __value: int) -> tuple[int, int]: ...
|
||||
@overload
|
||||
def __pow__(self, __x: Literal[0]) -> Literal[1]: ...
|
||||
@overload
|
||||
def __pow__(self, __x: Literal[0], __modulo: None) -> Literal[1]: ...
|
||||
def __pow__(self, __value: Literal[0], __mod: None) -> Literal[1]: ...
|
||||
@overload
|
||||
def __pow__(self, __x: _PositiveInteger, __modulo: None = None) -> int: ...
|
||||
def __pow__(self, __value: _PositiveInteger, __mod: None = None) -> int: ...
|
||||
@overload
|
||||
def __pow__(self, __x: _NegativeInteger, __modulo: None = None) -> float: ...
|
||||
def __pow__(self, __value: _NegativeInteger, __mod: None = None) -> float: ...
|
||||
# positive x -> int; negative x -> float
|
||||
# return type must be Any as `int | float` causes too many false-positive errors
|
||||
@overload
|
||||
def __pow__(self, __x: int, __modulo: None = None) -> Any: ...
|
||||
def __pow__(self, __value: int, __mod: None = None) -> Any: ...
|
||||
@overload
|
||||
def __pow__(self, __x: int, __modulo: int) -> int: ...
|
||||
def __rpow__(self, __x: int, __mod: int | None = None) -> Any: ...
|
||||
def __and__(self, __n: int) -> int: ...
|
||||
def __or__(self, __n: int) -> int: ...
|
||||
def __xor__(self, __n: int) -> int: ...
|
||||
def __lshift__(self, __n: int) -> int: ...
|
||||
def __rshift__(self, __n: int) -> int: ...
|
||||
def __rand__(self, __n: int) -> int: ...
|
||||
def __ror__(self, __n: int) -> int: ...
|
||||
def __rxor__(self, __n: int) -> int: ...
|
||||
def __rlshift__(self, __n: int) -> int: ...
|
||||
def __rrshift__(self, __n: int) -> int: ...
|
||||
def __pow__(self, __value: int, __mod: int) -> int: ...
|
||||
def __rpow__(self, __value: int, __mod: int | None = None) -> Any: ...
|
||||
def __and__(self, __value: int) -> int: ...
|
||||
def __or__(self, __value: int) -> int: ...
|
||||
def __xor__(self, __value: int) -> int: ...
|
||||
def __lshift__(self, __value: int) -> int: ...
|
||||
def __rshift__(self, __value: int) -> int: ...
|
||||
def __rand__(self, __value: int) -> int: ...
|
||||
def __ror__(self, __value: int) -> int: ...
|
||||
def __rxor__(self, __value: int) -> int: ...
|
||||
def __rlshift__(self, __value: int) -> int: ...
|
||||
def __rrshift__(self, __value: int) -> int: ...
|
||||
def __neg__(self) -> int: ...
|
||||
def __pos__(self) -> int: ...
|
||||
def __invert__(self) -> int: ...
|
||||
@@ -289,12 +289,12 @@ class int:
|
||||
def __floor__(self) -> int: ...
|
||||
def __round__(self, __ndigits: SupportsIndex = ...) -> int: ...
|
||||
def __getnewargs__(self) -> tuple[int]: ...
|
||||
def __eq__(self, __x: object) -> bool: ...
|
||||
def __ne__(self, __x: object) -> bool: ...
|
||||
def __lt__(self, __x: int) -> bool: ...
|
||||
def __le__(self, __x: int) -> bool: ...
|
||||
def __gt__(self, __x: int) -> bool: ...
|
||||
def __ge__(self, __x: int) -> bool: ...
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __ne__(self, __value: object) -> bool: ...
|
||||
def __lt__(self, __value: int) -> bool: ...
|
||||
def __le__(self, __value: int) -> bool: ...
|
||||
def __gt__(self, __value: int) -> bool: ...
|
||||
def __ge__(self, __value: int) -> bool: ...
|
||||
def __float__(self) -> float: ...
|
||||
def __int__(self) -> int: ...
|
||||
def __abs__(self) -> int: ...
|
||||
@@ -307,39 +307,39 @@ class float:
|
||||
def hex(self) -> str: ...
|
||||
def is_integer(self) -> bool: ...
|
||||
@classmethod
|
||||
def fromhex(cls, __s: str) -> Self: ...
|
||||
def fromhex(cls, __string: str) -> Self: ...
|
||||
@property
|
||||
def real(self) -> float: ...
|
||||
@property
|
||||
def imag(self) -> float: ...
|
||||
def conjugate(self) -> float: ...
|
||||
def __add__(self, __x: float) -> float: ...
|
||||
def __sub__(self, __x: float) -> float: ...
|
||||
def __mul__(self, __x: float) -> float: ...
|
||||
def __floordiv__(self, __x: float) -> float: ...
|
||||
def __truediv__(self, __x: float) -> float: ...
|
||||
def __mod__(self, __x: float) -> float: ...
|
||||
def __divmod__(self, __x: float) -> tuple[float, float]: ...
|
||||
def __add__(self, __value: float) -> float: ...
|
||||
def __sub__(self, __value: float) -> float: ...
|
||||
def __mul__(self, __value: float) -> float: ...
|
||||
def __floordiv__(self, __value: float) -> float: ...
|
||||
def __truediv__(self, __value: float) -> float: ...
|
||||
def __mod__(self, __value: float) -> float: ...
|
||||
def __divmod__(self, __value: float) -> tuple[float, float]: ...
|
||||
@overload
|
||||
def __pow__(self, __x: int, __mod: None = None) -> float: ...
|
||||
def __pow__(self, __value: int, __mod: None = None) -> float: ...
|
||||
# positive x -> float; negative x -> complex
|
||||
# return type must be Any as `float | complex` causes too many false-positive errors
|
||||
@overload
|
||||
def __pow__(self, __x: float, __mod: None = None) -> Any: ...
|
||||
def __radd__(self, __x: float) -> float: ...
|
||||
def __rsub__(self, __x: float) -> float: ...
|
||||
def __rmul__(self, __x: float) -> float: ...
|
||||
def __rfloordiv__(self, __x: float) -> float: ...
|
||||
def __rtruediv__(self, __x: float) -> float: ...
|
||||
def __rmod__(self, __x: float) -> float: ...
|
||||
def __rdivmod__(self, __x: float) -> tuple[float, float]: ...
|
||||
def __pow__(self, __value: float, __mod: None = None) -> Any: ...
|
||||
def __radd__(self, __value: float) -> float: ...
|
||||
def __rsub__(self, __value: float) -> float: ...
|
||||
def __rmul__(self, __value: float) -> float: ...
|
||||
def __rfloordiv__(self, __value: float) -> float: ...
|
||||
def __rtruediv__(self, __value: float) -> float: ...
|
||||
def __rmod__(self, __value: float) -> float: ...
|
||||
def __rdivmod__(self, __value: float) -> tuple[float, float]: ...
|
||||
@overload
|
||||
def __rpow__(self, __x: _PositiveInteger, __modulo: None = None) -> float: ...
|
||||
def __rpow__(self, __value: _PositiveInteger, __mod: None = None) -> float: ...
|
||||
@overload
|
||||
def __rpow__(self, __x: _NegativeInteger, __mod: None = None) -> complex: ...
|
||||
def __rpow__(self, __value: _NegativeInteger, __mod: None = None) -> complex: ...
|
||||
# Returning `complex` for the general case gives too many false-positive errors.
|
||||
@overload
|
||||
def __rpow__(self, __x: float, __mod: None = None) -> Any: ...
|
||||
def __rpow__(self, __value: float, __mod: None = None) -> Any: ...
|
||||
def __getnewargs__(self) -> tuple[float]: ...
|
||||
def __trunc__(self) -> int: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
@@ -350,12 +350,12 @@ class float:
|
||||
def __round__(self, __ndigits: None = None) -> int: ...
|
||||
@overload
|
||||
def __round__(self, __ndigits: SupportsIndex) -> float: ...
|
||||
def __eq__(self, __x: object) -> bool: ...
|
||||
def __ne__(self, __x: object) -> bool: ...
|
||||
def __lt__(self, __x: float) -> bool: ...
|
||||
def __le__(self, __x: float) -> bool: ...
|
||||
def __gt__(self, __x: float) -> bool: ...
|
||||
def __ge__(self, __x: float) -> bool: ...
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __ne__(self, __value: object) -> bool: ...
|
||||
def __lt__(self, __value: float) -> bool: ...
|
||||
def __le__(self, __value: float) -> bool: ...
|
||||
def __gt__(self, __value: float) -> bool: ...
|
||||
def __ge__(self, __value: float) -> bool: ...
|
||||
def __neg__(self) -> float: ...
|
||||
def __pos__(self) -> float: ...
|
||||
def __int__(self) -> int: ...
|
||||
@@ -385,18 +385,18 @@ class complex:
|
||||
@property
|
||||
def imag(self) -> float: ...
|
||||
def conjugate(self) -> complex: ...
|
||||
def __add__(self, __x: complex) -> complex: ...
|
||||
def __sub__(self, __x: complex) -> complex: ...
|
||||
def __mul__(self, __x: complex) -> complex: ...
|
||||
def __pow__(self, __x: complex, __mod: None = None) -> complex: ...
|
||||
def __truediv__(self, __x: complex) -> complex: ...
|
||||
def __radd__(self, __x: complex) -> complex: ...
|
||||
def __rsub__(self, __x: complex) -> complex: ...
|
||||
def __rmul__(self, __x: complex) -> complex: ...
|
||||
def __rpow__(self, __x: complex, __mod: None = None) -> complex: ...
|
||||
def __rtruediv__(self, __x: complex) -> complex: ...
|
||||
def __eq__(self, __x: object) -> bool: ...
|
||||
def __ne__(self, __x: object) -> bool: ...
|
||||
def __add__(self, __value: complex) -> complex: ...
|
||||
def __sub__(self, __value: complex) -> complex: ...
|
||||
def __mul__(self, __value: complex) -> complex: ...
|
||||
def __pow__(self, __value: complex, __mod: None = None) -> complex: ...
|
||||
def __truediv__(self, __value: complex) -> complex: ...
|
||||
def __radd__(self, __value: complex) -> complex: ...
|
||||
def __rsub__(self, __value: complex) -> complex: ...
|
||||
def __rmul__(self, __value: complex) -> complex: ...
|
||||
def __rpow__(self, __value: complex, __mod: None = None) -> complex: ...
|
||||
def __rtruediv__(self, __value: complex) -> complex: ...
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __ne__(self, __value: object) -> bool: ...
|
||||
def __neg__(self) -> complex: ...
|
||||
def __pos__(self) -> complex: ...
|
||||
def __abs__(self) -> float: ...
|
||||
@@ -558,35 +558,35 @@ class str(Sequence[str]):
|
||||
@overload
|
||||
def maketrans(__x: str, __y: str, __z: str) -> dict[int, int | None]: ...
|
||||
@overload
|
||||
def __add__(self: LiteralString, __s: LiteralString) -> LiteralString: ...
|
||||
def __add__(self: LiteralString, __value: LiteralString) -> LiteralString: ...
|
||||
@overload
|
||||
def __add__(self, __s: str) -> str: ... # type: ignore[misc]
|
||||
def __add__(self, __value: str) -> str: ... # type: ignore[misc]
|
||||
# Incompatible with Sequence.__contains__
|
||||
def __contains__(self, __o: str) -> bool: ... # type: ignore[override]
|
||||
def __eq__(self, __x: object) -> bool: ...
|
||||
def __ge__(self, __x: str) -> bool: ...
|
||||
def __getitem__(self, __i: SupportsIndex | slice) -> str: ...
|
||||
def __gt__(self, __x: str) -> bool: ...
|
||||
def __contains__(self, __key: str) -> bool: ... # type: ignore[override]
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __ge__(self, __value: str) -> bool: ...
|
||||
def __getitem__(self, __key: SupportsIndex | slice) -> str: ...
|
||||
def __gt__(self, __value: str) -> bool: ...
|
||||
@overload
|
||||
def __iter__(self: LiteralString) -> Iterator[LiteralString]: ...
|
||||
@overload
|
||||
def __iter__(self) -> Iterator[str]: ... # type: ignore[misc]
|
||||
def __le__(self, __x: str) -> bool: ...
|
||||
def __le__(self, __value: str) -> bool: ...
|
||||
def __len__(self) -> int: ...
|
||||
def __lt__(self, __x: str) -> bool: ...
|
||||
def __lt__(self, __value: str) -> bool: ...
|
||||
@overload
|
||||
def __mod__(self: LiteralString, __x: LiteralString | tuple[LiteralString, ...]) -> LiteralString: ...
|
||||
def __mod__(self: LiteralString, __value: LiteralString | tuple[LiteralString, ...]) -> LiteralString: ...
|
||||
@overload
|
||||
def __mod__(self, __x: Any) -> str: ...
|
||||
def __mod__(self, __value: Any) -> str: ...
|
||||
@overload
|
||||
def __mul__(self: LiteralString, __n: SupportsIndex) -> LiteralString: ...
|
||||
def __mul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
|
||||
@overload
|
||||
def __mul__(self, __n: SupportsIndex) -> str: ... # type: ignore[misc]
|
||||
def __ne__(self, __x: object) -> bool: ...
|
||||
def __mul__(self, __value: SupportsIndex) -> str: ... # type: ignore[misc]
|
||||
def __ne__(self, __value: object) -> bool: ...
|
||||
@overload
|
||||
def __rmul__(self: LiteralString, __n: SupportsIndex) -> LiteralString: ...
|
||||
def __rmul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
|
||||
@overload
|
||||
def __rmul__(self, __n: SupportsIndex) -> str: ... # type: ignore[misc]
|
||||
def __rmul__(self, __value: SupportsIndex) -> str: ... # type: ignore[misc]
|
||||
def __getnewargs__(self) -> tuple[str]: ...
|
||||
|
||||
class bytes(ByteString):
|
||||
@@ -667,27 +667,27 @@ class bytes(ByteString):
|
||||
def upper(self) -> bytes: ...
|
||||
def zfill(self, __width: SupportsIndex) -> bytes: ...
|
||||
@classmethod
|
||||
def fromhex(cls, __s: str) -> Self: ...
|
||||
def fromhex(cls, __string: str) -> Self: ...
|
||||
@staticmethod
|
||||
def maketrans(__frm: ReadableBuffer, __to: ReadableBuffer) -> bytes: ...
|
||||
def __len__(self) -> int: ...
|
||||
def __iter__(self) -> Iterator[int]: ...
|
||||
@overload
|
||||
def __getitem__(self, __i: SupportsIndex) -> int: ...
|
||||
def __getitem__(self, __key: SupportsIndex) -> int: ...
|
||||
@overload
|
||||
def __getitem__(self, __s: slice) -> bytes: ...
|
||||
def __add__(self, __s: ReadableBuffer) -> bytes: ...
|
||||
def __mul__(self, __n: SupportsIndex) -> bytes: ...
|
||||
def __rmul__(self, __n: SupportsIndex) -> bytes: ...
|
||||
def __getitem__(self, __key: slice) -> bytes: ...
|
||||
def __add__(self, __value: ReadableBuffer) -> bytes: ...
|
||||
def __mul__(self, __value: SupportsIndex) -> bytes: ...
|
||||
def __rmul__(self, __value: SupportsIndex) -> bytes: ...
|
||||
def __mod__(self, __value: Any) -> bytes: ...
|
||||
# Incompatible with Sequence.__contains__
|
||||
def __contains__(self, __o: SupportsIndex | ReadableBuffer) -> bool: ... # type: ignore[override]
|
||||
def __eq__(self, __x: object) -> bool: ...
|
||||
def __ne__(self, __x: object) -> bool: ...
|
||||
def __lt__(self, __x: bytes) -> bool: ...
|
||||
def __le__(self, __x: bytes) -> bool: ...
|
||||
def __gt__(self, __x: bytes) -> bool: ...
|
||||
def __ge__(self, __x: bytes) -> bool: ...
|
||||
def __contains__(self, __key: SupportsIndex | ReadableBuffer) -> bool: ... # type: ignore[override]
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __ne__(self, __value: object) -> bool: ...
|
||||
def __lt__(self, __value: bytes) -> bool: ...
|
||||
def __le__(self, __value: bytes) -> bool: ...
|
||||
def __gt__(self, __value: bytes) -> bool: ...
|
||||
def __ge__(self, __value: bytes) -> bool: ...
|
||||
def __getnewargs__(self) -> tuple[bytes]: ...
|
||||
if sys.version_info >= (3, 11):
|
||||
def __bytes__(self) -> bytes: ...
|
||||
@@ -783,29 +783,29 @@ class bytearray(MutableSequence[int], ByteString):
|
||||
def __iter__(self) -> Iterator[int]: ...
|
||||
__hash__: ClassVar[None] # type: ignore[assignment]
|
||||
@overload
|
||||
def __getitem__(self, __i: SupportsIndex) -> int: ...
|
||||
def __getitem__(self, __key: SupportsIndex) -> int: ...
|
||||
@overload
|
||||
def __getitem__(self, __s: slice) -> bytearray: ...
|
||||
def __getitem__(self, __key: slice) -> bytearray: ...
|
||||
@overload
|
||||
def __setitem__(self, __i: SupportsIndex, __x: SupportsIndex) -> None: ...
|
||||
def __setitem__(self, __key: SupportsIndex, __value: SupportsIndex) -> None: ...
|
||||
@overload
|
||||
def __setitem__(self, __s: slice, __x: Iterable[SupportsIndex] | bytes) -> None: ...
|
||||
def __delitem__(self, __i: SupportsIndex | slice) -> None: ...
|
||||
def __add__(self, __s: ReadableBuffer) -> bytearray: ...
|
||||
def __setitem__(self, __key: slice, __value: Iterable[SupportsIndex] | bytes) -> None: ...
|
||||
def __delitem__(self, __key: SupportsIndex | slice) -> None: ...
|
||||
def __add__(self, __value: ReadableBuffer) -> bytearray: ...
|
||||
# The superclass wants us to accept Iterable[int], but that fails at runtime.
|
||||
def __iadd__(self, __s: ReadableBuffer) -> Self: ... # type: ignore[override]
|
||||
def __mul__(self, __n: SupportsIndex) -> bytearray: ...
|
||||
def __rmul__(self, __n: SupportsIndex) -> bytearray: ...
|
||||
def __imul__(self, __n: SupportsIndex) -> Self: ...
|
||||
def __iadd__(self, __value: ReadableBuffer) -> Self: ... # type: ignore[override]
|
||||
def __mul__(self, __value: SupportsIndex) -> bytearray: ...
|
||||
def __rmul__(self, __value: SupportsIndex) -> bytearray: ...
|
||||
def __imul__(self, __value: SupportsIndex) -> Self: ...
|
||||
def __mod__(self, __value: Any) -> bytes: ...
|
||||
# Incompatible with Sequence.__contains__
|
||||
def __contains__(self, __o: SupportsIndex | ReadableBuffer) -> bool: ... # type: ignore[override]
|
||||
def __eq__(self, __x: object) -> bool: ...
|
||||
def __ne__(self, __x: object) -> bool: ...
|
||||
def __lt__(self, __x: ReadableBuffer) -> bool: ...
|
||||
def __le__(self, __x: ReadableBuffer) -> bool: ...
|
||||
def __gt__(self, __x: ReadableBuffer) -> bool: ...
|
||||
def __ge__(self, __x: ReadableBuffer) -> bool: ...
|
||||
def __contains__(self, __key: SupportsIndex | ReadableBuffer) -> bool: ... # type: ignore[override]
|
||||
def __eq__(self, __value: object) -> bool: ...
|
||||
def __ne__(self, __value: object) -> bool: ...
|
||||
def __lt__(self, __value: ReadableBuffer) -> bool: ...
|
||||
def __le__(self, __value: ReadableBuffer) -> bool: ...
|
||||
def __gt__(self, __value: ReadableBuffer) -> bool: ...
|
||||
def __ge__(self, __value: ReadableBuffer) -> bool: ...
|
||||
def __alloc__(self) -> int: ...
|
||||
|
||||
@final
|
||||
@@ -841,16 +841,16 @@ class memoryview(Sequence[int]):
|
||||
) -> None: ...
|
||||
def cast(self, format: str, shape: list[int] | tuple[int, ...] = ...) -> memoryview: ...
|
||||
@overload
|
||||
def __getitem__(self, __i: SupportsIndex) -> int: ...
|
||||
def __getitem__(self, __key: SupportsIndex) -> int: ...
|
||||
@overload
|
||||
def __getitem__(self, __s: slice) -> memoryview: ...
|
||||
def __getitem__(self, __key: slice) -> memoryview: ...
|
||||
def __contains__(self, __x: object) -> bool: ...
|
||||
def __iter__(self) -> Iterator[int]: ...
|
||||
def __len__(self) -> int: ...
|
||||
@overload
|
||||
def __setitem__(self, __s: slice, __o: ReadableBuffer) -> None: ...
|
||||
def __setitem__(self, __key: slice, __value: ReadableBuffer) -> None: ...
|
||||
@overload
|
||||
def __setitem__(self, __i: SupportsIndex, __o: SupportsIndex) -> None: ...
|
||||
def __setitem__(self, __key: SupportsIndex, __value: SupportsIndex) -> None: ...
|
||||
if sys.version_info >= (3, 10):
|
||||
def tobytes(self, order: Literal["C", "F", "A"] | None = "C") -> bytes: ...
|
||||
elif sys.version_info >= (3, 8):
|
||||
@@ -874,29 +874,29 @@ class bool(int):
|
||||
# The following overloads could be represented more elegantly with a TypeVar("_B", bool, int),
|
||||
# however mypy has a bug regarding TypeVar constraints (https://github.com/python/mypy/issues/11880).
|
||||
@overload
|
||||
def __and__(self, __x: bool) -> bool: ...
|
||||
def __and__(self, __value: bool) -> bool: ...
|
||||
@overload
|
||||
def __and__(self, __x: int) -> int: ...
|
||||
def __and__(self, __value: int) -> int: ...
|
||||
@overload
|
||||
def __or__(self, __x: bool) -> bool: ...
|
||||
def __or__(self, __value: bool) -> bool: ...
|
||||
@overload
|
||||
def __or__(self, __x: int) -> int: ...
|
||||
def __or__(self, __value: int) -> int: ...
|
||||
@overload
|
||||
def __xor__(self, __x: bool) -> bool: ...
|
||||
def __xor__(self, __value: bool) -> bool: ...
|
||||
@overload
|
||||
def __xor__(self, __x: int) -> int: ...
|
||||
def __xor__(self, __value: int) -> int: ...
|
||||
@overload
|
||||
def __rand__(self, __x: bool) -> bool: ...
|
||||
def __rand__(self, __value: bool) -> bool: ...
|
||||
@overload
|
||||
def __rand__(self, __x: int) -> int: ...
|
||||
def __rand__(self, __value: int) -> int: ...
|
||||
@overload
|
||||
def __ror__(self, __x: bool) -> bool: ...
|
||||
def __ror__(self, __value: bool) -> bool: ...
|
||||
@overload
|
||||
def __ror__(self, __x: int) -> int: ...
|
||||
def __ror__(self, __value: int) -> int: ...
|
||||
@overload
|
||||
def __rxor__(self, __x: bool) -> bool: ...
|
||||
def __rxor__(self, __value: bool) -> bool: ...
|
||||
@overload
|
||||
def __rxor__(self, __x: int) -> int: ...
|
||||
def __rxor__(self, __value: int) -> int: ...
|
||||
def __getnewargs__(self) -> tuple[int]: ...
|
||||
|
||||
@final
|
||||
@@ -917,22 +917,22 @@ class slice:
|
||||
class tuple(Sequence[_T_co], Generic[_T_co]):
|
||||
def __new__(cls, __iterable: Iterable[_T_co] = ...) -> Self: ...
|
||||
def __len__(self) -> int: ...
|
||||
def __contains__(self, __x: object) -> bool: ...
|
||||
def __contains__(self, __key: object) -> bool: ...
|
||||
@overload
|
||||
def __getitem__(self, __x: SupportsIndex) -> _T_co: ...
|
||||
def __getitem__(self, __key: SupportsIndex) -> _T_co: ...
|
||||
@overload
|
||||
def __getitem__(self, __x: slice) -> tuple[_T_co, ...]: ...
|
||||
def __getitem__(self, __key: slice) -> tuple[_T_co, ...]: ...
|
||||
def __iter__(self) -> Iterator[_T_co]: ...
|
||||
def __lt__(self, __x: tuple[_T_co, ...]) -> bool: ...
|
||||
def __le__(self, __x: tuple[_T_co, ...]) -> bool: ...
|
||||
def __gt__(self, __x: tuple[_T_co, ...]) -> bool: ...
|
||||
def __ge__(self, __x: tuple[_T_co, ...]) -> bool: ...
|
||||
def __lt__(self, __value: tuple[_T_co, ...]) -> bool: ...
|
||||
def __le__(self, __value: tuple[_T_co, ...]) -> bool: ...
|
||||
def __gt__(self, __value: tuple[_T_co, ...]) -> bool: ...
|
||||
def __ge__(self, __value: tuple[_T_co, ...]) -> bool: ...
|
||||
@overload
|
||||
def __add__(self, __x: tuple[_T_co, ...]) -> tuple[_T_co, ...]: ...
|
||||
def __add__(self, __value: tuple[_T_co, ...]) -> tuple[_T_co, ...]: ...
|
||||
@overload
|
||||
def __add__(self, __x: tuple[_T, ...]) -> tuple[_T_co | _T, ...]: ...
|
||||
def __mul__(self, __n: SupportsIndex) -> tuple[_T_co, ...]: ...
|
||||
def __rmul__(self, __n: SupportsIndex) -> tuple[_T_co, ...]: ...
|
||||
def __add__(self, __value: tuple[_T, ...]) -> tuple[_T_co | _T, ...]: ...
|
||||
def __mul__(self, __value: SupportsIndex) -> tuple[_T_co, ...]: ...
|
||||
def __rmul__(self, __value: SupportsIndex) -> tuple[_T_co, ...]: ...
|
||||
def count(self, __value: Any) -> int: ...
|
||||
def index(self, __value: Any, __start: SupportsIndex = 0, __stop: SupportsIndex = sys.maxsize) -> int: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
@@ -994,25 +994,25 @@ class list(MutableSequence[_T], Generic[_T]):
|
||||
@overload
|
||||
def __getitem__(self, __s: slice) -> list[_T]: ...
|
||||
@overload
|
||||
def __setitem__(self, __i: SupportsIndex, __o: _T) -> None: ...
|
||||
def __setitem__(self, __key: SupportsIndex, __value: _T) -> None: ...
|
||||
@overload
|
||||
def __setitem__(self, __s: slice, __o: Iterable[_T]) -> None: ...
|
||||
def __delitem__(self, __i: SupportsIndex | slice) -> None: ...
|
||||
def __setitem__(self, __key: slice, __value: Iterable[_T]) -> None: ...
|
||||
def __delitem__(self, __key: SupportsIndex | slice) -> None: ...
|
||||
# Overloading looks unnecessary, but is needed to work around complex mypy problems
|
||||
@overload
|
||||
def __add__(self, __x: list[_T]) -> list[_T]: ...
|
||||
def __add__(self, __value: list[_T]) -> list[_T]: ...
|
||||
@overload
|
||||
def __add__(self, __x: list[_S]) -> list[_S | _T]: ...
|
||||
def __iadd__(self, __x: Iterable[_T]) -> Self: ... # type: ignore[misc]
|
||||
def __mul__(self, __n: SupportsIndex) -> list[_T]: ...
|
||||
def __rmul__(self, __n: SupportsIndex) -> list[_T]: ...
|
||||
def __imul__(self, __n: SupportsIndex) -> Self: ...
|
||||
def __contains__(self, __o: object) -> bool: ...
|
||||
def __add__(self, __value: list[_S]) -> list[_S | _T]: ...
|
||||
def __iadd__(self, __value: Iterable[_T]) -> Self: ... # type: ignore[misc]
|
||||
def __mul__(self, __value: SupportsIndex) -> list[_T]: ...
|
||||
def __rmul__(self, __value: SupportsIndex) -> list[_T]: ...
|
||||
def __imul__(self, __value: SupportsIndex) -> Self: ...
|
||||
def __contains__(self, __key: object) -> bool: ...
|
||||
def __reversed__(self) -> Iterator[_T]: ...
|
||||
def __gt__(self, __x: list[_T]) -> bool: ...
|
||||
def __ge__(self, __x: list[_T]) -> bool: ...
|
||||
def __lt__(self, __x: list[_T]) -> bool: ...
|
||||
def __le__(self, __x: list[_T]) -> bool: ...
|
||||
def __gt__(self, __value: list[_T]) -> bool: ...
|
||||
def __ge__(self, __value: list[_T]) -> bool: ...
|
||||
def __lt__(self, __value: list[_T]) -> bool: ...
|
||||
def __le__(self, __value: list[_T]) -> bool: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
|
||||
|
||||
@@ -1099,18 +1099,18 @@ class set(MutableSet[_T], Generic[_T]):
|
||||
def __len__(self) -> int: ...
|
||||
def __contains__(self, __o: object) -> bool: ...
|
||||
def __iter__(self) -> Iterator[_T]: ...
|
||||
def __and__(self, __s: AbstractSet[object]) -> set[_T]: ...
|
||||
def __iand__(self, __s: AbstractSet[object]) -> Self: ...
|
||||
def __or__(self, __s: AbstractSet[_S]) -> set[_T | _S]: ...
|
||||
def __ior__(self, __s: AbstractSet[_T]) -> Self: ... # type: ignore[override,misc]
|
||||
def __sub__(self, __s: AbstractSet[_T | None]) -> set[_T]: ...
|
||||
def __isub__(self, __s: AbstractSet[object]) -> Self: ...
|
||||
def __xor__(self, __s: AbstractSet[_S]) -> set[_T | _S]: ...
|
||||
def __ixor__(self, __s: AbstractSet[_T]) -> Self: ... # type: ignore[override,misc]
|
||||
def __le__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __lt__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __ge__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __gt__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __and__(self, __value: AbstractSet[object]) -> set[_T]: ...
|
||||
def __iand__(self, __value: AbstractSet[object]) -> Self: ...
|
||||
def __or__(self, __value: AbstractSet[_S]) -> set[_T | _S]: ...
|
||||
def __ior__(self, __value: AbstractSet[_T]) -> Self: ... # type: ignore[override,misc]
|
||||
def __sub__(self, __value: AbstractSet[_T | None]) -> set[_T]: ...
|
||||
def __isub__(self, __value: AbstractSet[object]) -> Self: ...
|
||||
def __xor__(self, __value: AbstractSet[_S]) -> set[_T | _S]: ...
|
||||
def __ixor__(self, __value: AbstractSet[_T]) -> Self: ... # type: ignore[override,misc]
|
||||
def __le__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
def __lt__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
def __ge__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
def __gt__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
__hash__: ClassVar[None] # type: ignore[assignment]
|
||||
if sys.version_info >= (3, 9):
|
||||
def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
|
||||
@@ -1131,14 +1131,14 @@ class frozenset(AbstractSet[_T_co], Generic[_T_co]):
|
||||
def __len__(self) -> int: ...
|
||||
def __contains__(self, __o: object) -> bool: ...
|
||||
def __iter__(self) -> Iterator[_T_co]: ...
|
||||
def __and__(self, __s: AbstractSet[_T_co]) -> frozenset[_T_co]: ...
|
||||
def __or__(self, __s: AbstractSet[_S]) -> frozenset[_T_co | _S]: ...
|
||||
def __sub__(self, __s: AbstractSet[_T_co]) -> frozenset[_T_co]: ...
|
||||
def __xor__(self, __s: AbstractSet[_S]) -> frozenset[_T_co | _S]: ...
|
||||
def __le__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __lt__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __ge__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __gt__(self, __s: AbstractSet[object]) -> bool: ...
|
||||
def __and__(self, __value: AbstractSet[_T_co]) -> frozenset[_T_co]: ...
|
||||
def __or__(self, __value: AbstractSet[_S]) -> frozenset[_T_co | _S]: ...
|
||||
def __sub__(self, __value: AbstractSet[_T_co]) -> frozenset[_T_co]: ...
|
||||
def __xor__(self, __value: AbstractSet[_S]) -> frozenset[_T_co | _S]: ...
|
||||
def __le__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
def __lt__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
def __ge__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
def __gt__(self, __value: AbstractSet[object]) -> bool: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
|
||||
|
||||
@@ -1164,12 +1164,12 @@ class range(Sequence[int]):
|
||||
def count(self, __value: int) -> int: ...
|
||||
def index(self, __value: int) -> int: ... # type: ignore[override]
|
||||
def __len__(self) -> int: ...
|
||||
def __contains__(self, __o: object) -> bool: ...
|
||||
def __contains__(self, __key: object) -> bool: ...
|
||||
def __iter__(self) -> Iterator[int]: ...
|
||||
@overload
|
||||
def __getitem__(self, __i: SupportsIndex) -> int: ...
|
||||
def __getitem__(self, __key: SupportsIndex) -> int: ...
|
||||
@overload
|
||||
def __getitem__(self, __s: slice) -> range: ...
|
||||
def __getitem__(self, __key: slice) -> range: ...
|
||||
def __reversed__(self) -> Iterator[int]: ...
|
||||
|
||||
class property:
|
||||
@@ -1648,35 +1648,35 @@ if sys.version_info >= (3, 8):
|
||||
|
||||
else:
|
||||
@overload
|
||||
def pow(__base: int, __exp: int, __mod: int) -> int: ...
|
||||
def pow(__x: int, __y: int, __z: int) -> int: ...
|
||||
@overload
|
||||
def pow(__base: int, __exp: Literal[0], __mod: None = None) -> Literal[1]: ...
|
||||
def pow(__x: int, __y: Literal[0], __z: None = None) -> Literal[1]: ...
|
||||
@overload
|
||||
def pow(__base: int, __exp: _PositiveInteger, __mod: None = None) -> int: ...
|
||||
def pow(__x: int, __y: _PositiveInteger, __z: None = None) -> int: ...
|
||||
@overload
|
||||
def pow(__base: int, __exp: _NegativeInteger, __mod: None = None) -> float: ...
|
||||
def pow(__x: int, __y: _NegativeInteger, __z: None = None) -> float: ...
|
||||
@overload
|
||||
def pow(__base: int, __exp: int, __mod: None = None) -> Any: ...
|
||||
def pow(__x: int, __y: int, __z: None = None) -> Any: ...
|
||||
@overload
|
||||
def pow(__base: _PositiveInteger, __exp: float, __mod: None = None) -> float: ...
|
||||
def pow(__x: _PositiveInteger, __y: float, __z: None = None) -> float: ...
|
||||
@overload
|
||||
def pow(__base: _NegativeInteger, __exp: float, __mod: None = None) -> complex: ...
|
||||
def pow(__x: _NegativeInteger, __y: float, __z: None = None) -> complex: ...
|
||||
@overload
|
||||
def pow(__base: float, __exp: int, __mod: None = None) -> float: ...
|
||||
def pow(__x: float, __y: int, __z: None = None) -> float: ...
|
||||
@overload
|
||||
def pow(__base: float, __exp: complex | _SupportsSomeKindOfPow, __mod: None = None) -> Any: ...
|
||||
def pow(__x: float, __y: complex | _SupportsSomeKindOfPow, __z: None = None) -> Any: ...
|
||||
@overload
|
||||
def pow(__base: complex, __exp: complex | _SupportsSomeKindOfPow, __mod: None = None) -> complex: ...
|
||||
def pow(__x: complex, __y: complex | _SupportsSomeKindOfPow, __z: None = None) -> complex: ...
|
||||
@overload
|
||||
def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E, __mod: None = None) -> _T_co: ...
|
||||
def pow(__x: _SupportsPow2[_E, _T_co], __y: _E, __z: None = None) -> _T_co: ...
|
||||
@overload
|
||||
def pow(__base: _SupportsPow3NoneOnly[_E, _T_co], __exp: _E, __mod: None = None) -> _T_co: ...
|
||||
def pow(__x: _SupportsPow3NoneOnly[_E, _T_co], __y: _E, __z: None = None) -> _T_co: ...
|
||||
@overload
|
||||
def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ...
|
||||
def pow(__x: _SupportsPow3[_E, _M, _T_co], __y: _E, __z: _M) -> _T_co: ...
|
||||
@overload
|
||||
def pow(__base: _SupportsSomeKindOfPow, __exp: float, __mod: None = None) -> Any: ...
|
||||
def pow(__x: _SupportsSomeKindOfPow, __y: float, __z: None = None) -> Any: ...
|
||||
@overload
|
||||
def pow(__base: _SupportsSomeKindOfPow, __exp: complex, __mod: None = None) -> complex: ...
|
||||
def pow(__x: _SupportsSomeKindOfPow, __y: complex, __z: None = None) -> complex: ...
|
||||
|
||||
def quit(code: sys._ExitCode = None) -> NoReturn: ...
|
||||
|
||||
|
||||
Reference in New Issue
Block a user