diff options
Diffstat (limited to 'python/helpers/typeshed/stdlib/@python2/builtins.pyi')
| -rw-r--r-- | python/helpers/typeshed/stdlib/@python2/builtins.pyi | 356 |
1 files changed, 187 insertions, 169 deletions
diff --git a/python/helpers/typeshed/stdlib/@python2/builtins.pyi b/python/helpers/typeshed/stdlib/@python2/builtins.pyi index 4791fd6c7a6a..453a95871463 100644 --- a/python/helpers/typeshed/stdlib/@python2/builtins.pyi +++ b/python/helpers/typeshed/stdlib/@python2/builtins.pyi @@ -1,7 +1,7 @@ # True and False are deliberately omitted because they are keywords in # Python 3, and stub files conform to Python 3 syntax. -from _typeshed import ReadableBuffer, Self, SupportsKeysAndGetItem, SupportsWrite +from _typeshed import ReadableBuffer, SupportsKeysAndGetItem, SupportsWrite from abc import ABCMeta from ast import mod from types import CodeType @@ -13,11 +13,14 @@ from typing import ( ByteString, Callable, Container, + Dict, + FrozenSet, Generic, ItemsView, Iterable, Iterator, KeysView, + List, Mapping, MutableMapping, MutableSequence, @@ -26,12 +29,15 @@ from typing import ( Protocol, Reversible, Sequence, + Set, Sized, SupportsAbs, SupportsComplex, SupportsFloat, SupportsInt, Text, + Tuple, + Type, TypeVar, ValuesView, overload, @@ -54,68 +60,70 @@ _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _T4 = TypeVar("_T4") _T5 = TypeVar("_T5") -_TT = TypeVar("_TT", bound=type) +_TT = TypeVar("_TT", bound="type") +_TBE = TypeVar("_TBE", bound="BaseException") class object: __doc__: str | None - __dict__: dict[str, Any] + __dict__: Dict[str, Any] + __slots__: Text | Iterable[Text] __module__: str @property - def __class__(self: _T) -> type[_T]: ... + def __class__(self: _T) -> Type[_T]: ... @__class__.setter - def __class__(self, __type: type[object]) -> None: ... # noqa: F811 + def __class__(self, __type: Type[object]) -> None: ... # noqa: F811 def __init__(self) -> None: ... def __new__(cls) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __eq__(self, o: object) -> bool: ... def __ne__(self, o: object) -> bool: ... - def __str__(self) -> str: ... # noqa Y029 - def __repr__(self) -> str: ... # noqa Y029 + def __str__(self) -> str: ... + def __repr__(self) -> str: ... def __hash__(self) -> int: ... def __format__(self, format_spec: str) -> str: ... def __getattribute__(self, name: str) -> Any: ... def __delattr__(self, name: str) -> None: ... def __sizeof__(self) -> int: ... - def __reduce__(self) -> str | tuple[Any, ...]: ... - def __reduce_ex__(self, protocol: int) -> str | tuple[Any, ...]: ... + def __reduce__(self) -> str | Tuple[Any, ...]: ... + def __reduce_ex__(self, protocol: int) -> str | Tuple[Any, ...]: ... class staticmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] def __init__(self, f: Callable[..., Any]) -> None: ... - def __new__(cls: type[Self], *args: Any, **kwargs: Any) -> Self: ... - def __get__(self, obj: _T, type: type[_T] | None = ...) -> Callable[..., Any]: ... + def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... + def __get__(self, obj: _T, type: Type[_T] | None = ...) -> Callable[..., Any]: ... class classmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] def __init__(self, f: Callable[..., Any]) -> None: ... - def __new__(cls: type[Self], *args: Any, **kwargs: Any) -> Self: ... - def __get__(self, obj: _T, type: type[_T] | None = ...) -> Callable[..., Any]: ... + def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... + def __get__(self, obj: _T, type: Type[_T] | None = ...) -> Callable[..., Any]: ... class type(object): __base__: type - __bases__: tuple[type, ...] + __bases__: Tuple[type, ...] __basicsize__: int - __dict__: dict[str, Any] + __dict__: Dict[str, Any] __dictoffset__: int __flags__: int __itemsize__: int __module__: str - __mro__: tuple[type, ...] + __mro__: Tuple[type, ...] __name__: str __weakrefoffset__: int @overload def __init__(self, o: object) -> None: ... @overload - def __init__(self, name: str, bases: tuple[type, ...], dict: dict[str, Any]) -> None: ... + def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ... @overload def __new__(cls, o: object) -> type: ... @overload - def __new__(cls, name: str, bases: tuple[type, ...], namespace: dict[str, Any]) -> type: ... + def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ... def __call__(self, *args: Any, **kwds: Any) -> Any: ... - def __subclasses__(self: _TT) -> list[_TT]: ... - # Note: the documentation doesn't specify what the return type is, the standard + def __subclasses__(self: _TT) -> List[_TT]: ... + # Note: the documentation doesnt specify what the return type is, the standard # implementation seems to be returning a list. - def mro(self) -> list[type]: ... + def mro(self) -> List[type]: ... def __instancecheck__(self, instance: Any) -> bool: ... def __subclasscheck__(self, subclass: type) -> bool: ... @@ -127,9 +135,9 @@ class super(object): class int: @overload - def __new__(cls: type[Self], x: Text | bytes | SupportsInt | _SupportsIndex | _SupportsTrunc = ...) -> Self: ... + def __new__(cls: Type[_T], x: Text | bytes | SupportsInt | _SupportsIndex | _SupportsTrunc = ...) -> _T: ... @overload - def __new__(cls: type[Self], x: Text | bytes | bytearray, base: int) -> Self: ... + def __new__(cls: Type[_T], x: Text | bytes | bytearray, base: int) -> _T: ... @property def real(self) -> int: ... @property @@ -147,7 +155,7 @@ class int: def __div__(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 __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: ... @@ -155,7 +163,7 @@ class int: def __rdiv__(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 __rdivmod__(self, x: int) -> Tuple[int, int]: ... @overload def __pow__(self, __x: Literal[2], __modulo: int | None = ...) -> int: ... @overload @@ -175,13 +183,14 @@ class int: def __pos__(self) -> int: ... def __invert__(self) -> int: ... def __trunc__(self) -> int: ... - def __getnewargs__(self) -> tuple[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 __str__(self) -> str: ... def __float__(self) -> float: ... def __int__(self) -> int: ... def __abs__(self) -> int: ... @@ -190,8 +199,8 @@ class int: def __index__(self) -> int: ... class float: - def __new__(cls: type[Self], x: SupportsFloat | _SupportsIndex | Text | bytes | bytearray = ...) -> Self: ... - def as_integer_ratio(self) -> tuple[int, int]: ... + def __new__(cls: Type[_T], x: SupportsFloat | _SupportsIndex | Text | bytes | bytearray = ...) -> _T: ... + def as_integer_ratio(self) -> Tuple[int, int]: ... def hex(self) -> str: ... def is_integer(self) -> bool: ... @classmethod @@ -208,7 +217,7 @@ class float: def __div__(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 __divmod__(self, x: float) -> Tuple[float, float]: ... def __pow__( self, x: float, mod: None = ... ) -> float: ... # In Python 3, returns complex if self is negative and x is not whole @@ -219,9 +228,9 @@ class float: def __rdiv__(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 __rdivmod__(self, x: float) -> Tuple[float, float]: ... def __rpow__(self, x: float, mod: None = ...) -> float: ... - def __getnewargs__(self) -> tuple[float]: ... + def __getnewargs__(self) -> Tuple[float]: ... def __trunc__(self) -> int: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... @@ -231,6 +240,7 @@ class float: def __ge__(self, x: float) -> bool: ... def __neg__(self) -> float: ... def __pos__(self) -> float: ... + def __str__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __abs__(self) -> float: ... @@ -239,9 +249,9 @@ class float: class complex: @overload - def __new__(cls: type[Self], real: float = ..., imag: float = ...) -> Self: ... + def __new__(cls: Type[_T], real: float = ..., imag: float = ...) -> _T: ... @overload - def __new__(cls: type[Self], real: str | SupportsComplex | _SupportsIndex) -> Self: ... + def __new__(cls: Type[_T], real: str | SupportsComplex | _SupportsIndex) -> _T: ... @property def real(self) -> float: ... @property @@ -263,6 +273,7 @@ class complex: def __ne__(self, x: object) -> bool: ... def __neg__(self) -> complex: ... def __pos__(self) -> complex: ... + def __str__(self) -> str: ... def __complex__(self) -> complex: ... def __abs__(self) -> float: ... def __hash__(self) -> int: ... @@ -282,7 +293,7 @@ class unicode(basestring, Sequence[unicode]): def count(self, x: unicode) -> int: ... def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ... def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ... - def endswith(self, __suffix: unicode | tuple[unicode, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... + def endswith(self, __suffix: unicode | Tuple[unicode, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... def expandtabs(self, tabsize: int = ...) -> unicode: ... def find(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def format(self, *args: object, **kwargs: object) -> unicode: ... @@ -302,21 +313,21 @@ class unicode(basestring, Sequence[unicode]): def ljust(self, width: int, fillchar: unicode = ...) -> unicode: ... def lower(self) -> unicode: ... def lstrip(self, chars: unicode = ...) -> unicode: ... - def partition(self, sep: unicode) -> tuple[unicode, unicode, unicode]: ... + def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ... def rfind(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rindex(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rjust(self, width: int, fillchar: unicode = ...) -> unicode: ... - def rpartition(self, sep: unicode) -> tuple[unicode, unicode, unicode]: ... - def rsplit(self, sep: unicode | None = ..., maxsplit: int = ...) -> list[unicode]: ... + def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... + def rsplit(self, sep: unicode | None = ..., maxsplit: int = ...) -> List[unicode]: ... def rstrip(self, chars: unicode = ...) -> unicode: ... - def split(self, sep: unicode | None = ..., maxsplit: int = ...) -> list[unicode]: ... - def splitlines(self, keepends: bool = ...) -> list[unicode]: ... - def startswith(self, __prefix: unicode | tuple[unicode, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... + def split(self, sep: unicode | None = ..., maxsplit: int = ...) -> List[unicode]: ... + def splitlines(self, keepends: bool = ...) -> List[unicode]: ... + def startswith(self, __prefix: unicode | Tuple[unicode, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... def strip(self, chars: unicode = ...) -> unicode: ... def swapcase(self) -> unicode: ... def title(self) -> unicode: ... - def translate(self, table: dict[int, Any] | unicode) -> unicode: ... + def translate(self, table: Dict[int, Any] | unicode) -> unicode: ... def upper(self) -> unicode: ... def zfill(self, width: int) -> unicode: ... @overload @@ -338,10 +349,12 @@ class unicode(basestring, Sequence[unicode]): # The argument type is incompatible with Sequence def __contains__(self, s: unicode | bytes) -> bool: ... # type: ignore def __iter__(self) -> Iterator[unicode]: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __hash__(self) -> int: ... - def __getnewargs__(self) -> tuple[unicode]: ... + def __getnewargs__(self) -> Tuple[unicode]: ... class _FormatMapMapping(Protocol): def __getitem__(self, __key: str) -> Any: ... @@ -353,7 +366,7 @@ class str(Sequence[str], basestring): def count(self, x: Text, __start: int | None = ..., __end: int | None = ...) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> unicode: ... def encode(self, encoding: Text = ..., errors: Text = ...) -> bytes: ... - def endswith(self, __suffix: Text | tuple[Text, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... + def endswith(self, __suffix: Text | Tuple[Text, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... def expandtabs(self, tabsize: int = ...) -> str: ... def find(self, sub: Text, __start: int | None = ..., __end: int | None = ...) -> int: ... def format(self, *args: object, **kwargs: object) -> str: ... @@ -374,35 +387,35 @@ class str(Sequence[str], basestring): @overload def lstrip(self, __chars: unicode) -> unicode: ... @overload - def partition(self, __sep: bytearray) -> tuple[str, bytearray, str]: ... + def partition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload - def partition(self, __sep: str) -> tuple[str, str, str]: ... + def partition(self, __sep: str) -> Tuple[str, str, str]: ... @overload - def partition(self, __sep: unicode) -> tuple[unicode, unicode, unicode]: ... + def partition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def replace(self, __old: AnyStr, __new: AnyStr, __count: int = ...) -> AnyStr: ... def rfind(self, sub: Text, __start: int | None = ..., __end: int | None = ...) -> int: ... def rindex(self, sub: Text, __start: int | None = ..., __end: int | None = ...) -> int: ... def rjust(self, __width: int, __fillchar: str = ...) -> str: ... @overload - def rpartition(self, __sep: bytearray) -> tuple[str, bytearray, str]: ... + def rpartition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload - def rpartition(self, __sep: str) -> tuple[str, str, str]: ... + def rpartition(self, __sep: str) -> Tuple[str, str, str]: ... @overload - def rpartition(self, __sep: unicode) -> tuple[unicode, unicode, unicode]: ... + def rpartition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... @overload - def rsplit(self, sep: str | None = ..., maxsplit: int = ...) -> list[str]: ... + def rsplit(self, sep: str | None = ..., maxsplit: int = ...) -> List[str]: ... @overload - def rsplit(self, sep: unicode, maxsplit: int = ...) -> list[unicode]: ... + def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... @overload def rstrip(self, __chars: str = ...) -> str: ... @overload def rstrip(self, __chars: unicode) -> unicode: ... @overload - def split(self, sep: str | None = ..., maxsplit: int = ...) -> list[str]: ... + def split(self, sep: str | None = ..., maxsplit: int = ...) -> List[str]: ... @overload - def split(self, sep: unicode, maxsplit: int = ...) -> list[unicode]: ... - def splitlines(self, keepends: bool = ...) -> list[str]: ... - def startswith(self, __prefix: Text | tuple[Text, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... + def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... + def splitlines(self, keepends: bool = ...) -> List[str]: ... + def startswith(self, __prefix: Text | Tuple[Text, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... @overload def strip(self, __chars: str = ...) -> str: ... @overload @@ -427,8 +440,10 @@ class str(Sequence[str], basestring): def __mod__(self, x: Any) -> str: ... def __mul__(self, n: int) -> str: ... def __ne__(self, x: object) -> bool: ... + def __repr__(self) -> str: ... def __rmul__(self, n: int) -> str: ... - def __getnewargs__(self) -> tuple[str]: ... + def __str__(self) -> str: ... + def __getnewargs__(self) -> Tuple[str]: ... def __getslice__(self, start: int, stop: int) -> str: ... def __float__(self) -> float: ... def __int__(self) -> int: ... @@ -450,7 +465,7 @@ class bytearray(MutableSequence[int], ByteString): def center(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def count(self, __sub: str) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ... - def endswith(self, __suffix: bytes | tuple[bytes, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... + def endswith(self, __suffix: bytes | Tuple[bytes, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... def expandtabs(self, tabsize: int = ...) -> bytearray: ... def extend(self, iterable: str | Iterable[int]) -> None: ... def find(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... @@ -467,17 +482,17 @@ class bytearray(MutableSequence[int], ByteString): def ljust(self, __width: int, __fillchar: str = ...) -> bytearray: ... def lower(self) -> bytearray: ... def lstrip(self, __bytes: bytes | None = ...) -> bytearray: ... - def partition(self, __sep: bytes) -> tuple[bytearray, bytearray, bytearray]: ... + def partition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytearray: ... def rfind(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ... def rindex(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ... def rjust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... - def rpartition(self, __sep: bytes) -> tuple[bytearray, bytearray, bytearray]: ... - def rsplit(self, sep: bytes | None = ..., maxsplit: int = ...) -> list[bytearray]: ... + def rpartition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... + def rsplit(self, sep: bytes | None = ..., maxsplit: int = ...) -> List[bytearray]: ... def rstrip(self, __bytes: bytes | None = ...) -> bytearray: ... - def split(self, sep: bytes | None = ..., maxsplit: int = ...) -> list[bytearray]: ... - def splitlines(self, keepends: bool = ...) -> list[bytearray]: ... - def startswith(self, __prefix: bytes | tuple[bytes, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... + def split(self, sep: bytes | None = ..., maxsplit: int = ...) -> List[bytearray]: ... + def splitlines(self, keepends: bool = ...) -> List[bytearray]: ... + def startswith(self, __prefix: bytes | Tuple[bytes, ...], __start: int | None = ..., __end: int | None = ...) -> bool: ... def strip(self, __bytes: bytes | None = ...) -> bytearray: ... def swapcase(self) -> bytearray: ... def title(self) -> bytearray: ... @@ -488,6 +503,8 @@ class bytearray(MutableSequence[int], ByteString): def fromhex(cls, __string: str) -> bytearray: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... __hash__: None # type: ignore @@ -517,9 +534,9 @@ class bytearray(MutableSequence[int], ByteString): class memoryview(Sized, Container[str]): format: str itemsize: int - shape: tuple[int, ...] | None - strides: tuple[int, ...] | None - suboffsets: tuple[int, ...] | None + shape: Tuple[int, ...] | None + strides: Tuple[int, ...] | None + suboffsets: Tuple[int, ...] | None readonly: bool ndim: int def __init__(self, obj: ReadableBuffer) -> None: ... @@ -535,11 +552,11 @@ class memoryview(Sized, Container[str]): @overload def __setitem__(self, i: int, o: int) -> None: ... def tobytes(self) -> bytes: ... - def tolist(self) -> list[int]: ... + def tolist(self) -> List[int]: ... @final class bool(int): - def __new__(cls: type[Self], __o: object = ...) -> Self: ... + def __new__(cls: Type[_T], __o: object = ...) -> _T: ... @overload def __and__(self, x: bool) -> bool: ... @overload @@ -564,7 +581,7 @@ class bool(int): def __rxor__(self, x: bool) -> bool: ... @overload def __rxor__(self, x: int) -> int: ... - def __getnewargs__(self) -> tuple[int]: ... + def __getnewargs__(self) -> Tuple[int]: ... class slice(object): start: Any @@ -575,27 +592,27 @@ class slice(object): @overload def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ... __hash__: None # type: ignore - def indices(self, len: int) -> tuple[int, int, int]: ... + def indices(self, len: int) -> Tuple[int, int, int]: ... class tuple(Sequence[_T_co], Generic[_T_co]): - def __new__(cls: type[Self], iterable: Iterable[_T_co] = ...) -> Self: ... + def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ... def __len__(self) -> int: ... def __contains__(self, x: object) -> bool: ... @overload def __getitem__(self, x: int) -> _T_co: ... @overload - def __getitem__(self, x: slice) -> tuple[_T_co, ...]: ... + def __getitem__(self, x: 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, 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: ... @overload - def __add__(self, x: tuple[_T_co, ...]) -> tuple[_T_co, ...]: ... + def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ... @overload - def __add__(self, x: tuple[Any, ...]) -> tuple[Any, ...]: ... - def __mul__(self, n: int) -> tuple[_T_co, ...]: ... - def __rmul__(self, n: int) -> tuple[_T_co, ...]: ... + def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ... + def __mul__(self, n: int) -> Tuple[_T_co, ...]: ... + def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ... def count(self, __value: Any) -> int: ... def index(self, __value: Any) -> int: ... @@ -621,29 +638,30 @@ class list(MutableSequence[_T], Generic[_T]): def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... + def __str__(self) -> str: ... __hash__: None # type: ignore @overload def __getitem__(self, i: int) -> _T: ... @overload - def __getitem__(self, s: slice) -> list[_T]: ... + def __getitem__(self, s: slice) -> List[_T]: ... @overload def __setitem__(self, i: int, o: _T) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... def __delitem__(self, i: int | slice) -> None: ... - def __getslice__(self, start: int, stop: int) -> list[_T]: ... + def __getslice__(self, start: int, stop: int) -> List[_T]: ... def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ... def __delslice__(self, start: int, stop: int) -> None: ... - def __add__(self, x: list[_T]) -> list[_T]: ... - def __iadd__(self: Self, x: Iterable[_T]) -> Self: ... - def __mul__(self, n: int) -> list[_T]: ... - def __rmul__(self, n: int) -> list[_T]: ... + def __add__(self, x: List[_T]) -> List[_T]: ... + def __iadd__(self: _S, x: Iterable[_T]) -> _S: ... + def __mul__(self, n: int) -> List[_T]: ... + def __rmul__(self, n: int) -> List[_T]: ... def __contains__(self, o: 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, 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: ... class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): # NOTE: Keyword arguments are special. If they are used, _KT must include @@ -653,74 +671,76 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): @overload def __init__(self, map: SupportsKeysAndGetItem[_KT, _VT], **kwargs: _VT) -> None: ... @overload - def __init__(self, iterable: Iterable[tuple[_KT, _VT]], **kwargs: _VT) -> None: ... - def __new__(cls: type[Self], *args: Any, **kwargs: Any) -> Self: ... + def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... + def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ... def has_key(self, k: _KT) -> bool: ... def clear(self) -> None: ... - def copy(self) -> dict[_KT, _VT]: ... - def popitem(self) -> tuple[_KT, _VT]: ... + def copy(self) -> Dict[_KT, _VT]: ... + def popitem(self) -> Tuple[_KT, _VT]: ... def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ... @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload - def update(self, __m: Iterable[tuple[_KT, _VT]], **kwargs: _VT) -> None: ... + def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... @overload def update(self, **kwargs: _VT) -> None: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... - def iteritems(self) -> Iterator[tuple[_KT, _VT]]: ... + def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... def viewkeys(self) -> KeysView[_KT]: ... def viewvalues(self) -> ValuesView[_VT]: ... def viewitems(self) -> ItemsView[_KT, _VT]: ... @classmethod @overload - def fromkeys(cls, __iterable: Iterable[_T]) -> dict[_T, Any]: ... + def fromkeys(cls, __iterable: Iterable[_T]) -> Dict[_T, Any]: ... @classmethod @overload - def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> dict[_T, _S]: ... + def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... def __iter__(self) -> Iterator[_KT]: ... + def __str__(self) -> str: ... __hash__: None # type: ignore class set(MutableSet[_T], Generic[_T]): def __init__(self, iterable: Iterable[_T] = ...) -> None: ... def add(self, element: _T) -> None: ... def clear(self) -> None: ... - def copy(self) -> set[_T]: ... - def difference(self, *s: Iterable[Any]) -> set[_T]: ... + def copy(self) -> Set[_T]: ... + def difference(self, *s: Iterable[Any]) -> Set[_T]: ... def difference_update(self, *s: Iterable[Any]) -> None: ... def discard(self, element: _T) -> None: ... - def intersection(self, *s: Iterable[Any]) -> set[_T]: ... + def intersection(self, *s: Iterable[Any]) -> Set[_T]: ... def intersection_update(self, *s: Iterable[Any]) -> None: ... def isdisjoint(self, s: Iterable[Any]) -> bool: ... def issubset(self, s: Iterable[Any]) -> bool: ... def issuperset(self, s: Iterable[Any]) -> bool: ... def pop(self) -> _T: ... def remove(self, element: _T) -> None: ... - def symmetric_difference(self, s: Iterable[_T]) -> set[_T]: ... + def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ... def symmetric_difference_update(self, s: Iterable[_T]) -> None: ... - def union(self, *s: Iterable[_T]) -> set[_T]: ... + def union(self, *s: Iterable[_T]) -> Set[_T]: ... def update(self, *s: Iterable[_T]) -> None: ... 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: Self, s: AbstractSet[object]) -> Self: ... - def __or__(self, s: AbstractSet[_S]) -> set[_T | _S]: ... - def __ior__(self: Self, s: AbstractSet[_T]) -> Self: ... + def __str__(self) -> str: ... + def __and__(self, s: AbstractSet[object]) -> Set[_T]: ... + def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ... + def __or__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... + def __ior__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... @overload - def __sub__(self: set[str], s: AbstractSet[Text | None]) -> set[_T]: ... + def __sub__(self: Set[str], s: AbstractSet[Text | None]) -> Set[_T]: ... @overload - def __sub__(self, s: AbstractSet[_T | None]) -> set[_T]: ... + def __sub__(self, s: AbstractSet[_T | None]) -> Set[_T]: ... @overload # type: ignore - def __isub__(self: set[str], s: AbstractSet[Text | None]) -> set[_T]: ... + def __isub__(self: Set[str], s: AbstractSet[Text | None]) -> Set[_T]: ... @overload - def __isub__(self, s: AbstractSet[_T | None]) -> set[_T]: ... - def __xor__(self, s: AbstractSet[_S]) -> set[_T | _S]: ... - def __ixor__(self: Self, s: AbstractSet[_T]) -> Self: ... + def __isub__(self, s: AbstractSet[_T | None]) -> Set[_T]: ... + def __xor__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... + def __ixor__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... def __le__(self, s: AbstractSet[object]) -> bool: ... def __lt__(self, s: AbstractSet[object]) -> bool: ... def __ge__(self, s: AbstractSet[object]) -> bool: ... @@ -729,30 +749,31 @@ class set(MutableSet[_T], Generic[_T]): class frozenset(AbstractSet[_T_co], Generic[_T_co]): def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ... - def copy(self) -> frozenset[_T_co]: ... - def difference(self, *s: Iterable[object]) -> frozenset[_T_co]: ... - def intersection(self, *s: Iterable[object]) -> frozenset[_T_co]: ... + def copy(self) -> FrozenSet[_T_co]: ... + def difference(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... + def intersection(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... def isdisjoint(self, s: Iterable[_T_co]) -> bool: ... def issubset(self, s: Iterable[object]) -> bool: ... def issuperset(self, s: Iterable[object]) -> bool: ... - def symmetric_difference(self, s: Iterable[_T_co]) -> frozenset[_T_co]: ... - def union(self, *s: Iterable[_T_co]) -> frozenset[_T_co]: ... + def symmetric_difference(self, s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... + def union(self, *s: Iterable[_T_co]) -> FrozenSet[_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 __str__(self) -> str: ... + 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: ... -class enumerate(Iterator[tuple[int, _T]], Generic[_T]): +class enumerate(Iterator[Tuple[int, _T]], Generic[_T]): def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ... - def __iter__(self) -> Iterator[tuple[int, _T]]: ... - def next(self) -> tuple[int, _T]: ... + def __iter__(self) -> Iterator[Tuple[int, _T]]: ... + def next(self) -> Tuple[int, _T]: ... class xrange(Sized, Iterable[int], Reversible[int]): @overload @@ -802,47 +823,42 @@ def cmp(__x: Any, __y: Any) -> int: ... _N1 = TypeVar("_N1", bool, int, float, complex) -def coerce(__x: _N1, __y: _N1) -> tuple[_N1, _N1]: ... +def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ... def compile(source: Text | mod, filename: Text, mode: Text, flags: int = ..., dont_inherit: int = ...) -> Any: ... def delattr(__obj: Any, __name: Text) -> None: ... -def dir(__o: object = ...) -> list[str]: ... +def dir(__o: object = ...) -> List[str]: ... _N2 = TypeVar("_N2", int, float) -def divmod(__x: _N2, __y: _N2) -> tuple[_N2, _N2]: ... +def divmod(__x: _N2, __y: _N2) -> Tuple[_N2, _N2]: ... def eval( - __source: Text | bytes | CodeType, __globals: dict[str, Any] | None = ..., __locals: Mapping[str, Any] | None = ... + __source: Text | bytes | CodeType, __globals: Dict[str, Any] | None = ..., __locals: Mapping[str, Any] | None = ... ) -> Any: ... -def execfile(__filename: str, __globals: dict[str, Any] | None = ..., __locals: dict[str, Any] | None = ...) -> None: ... +def execfile(__filename: str, __globals: Dict[str, Any] | None = ..., __locals: Dict[str, Any] | None = ...) -> None: ... def exit(code: object = ...) -> NoReturn: ... @overload def filter(__function: Callable[[AnyStr], Any], __iterable: AnyStr) -> AnyStr: ... # type: ignore @overload -def filter(__function: None, __iterable: tuple[_T | None, ...]) -> tuple[_T, ...]: ... # type: ignore +def filter(__function: None, __iterable: Tuple[_T | None, ...]) -> Tuple[_T, ...]: ... # type: ignore @overload -def filter(__function: Callable[[_T], Any], __iterable: tuple[_T, ...]) -> tuple[_T, ...]: ... # type: ignore +def filter(__function: Callable[[_T], Any], __iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ... # type: ignore @overload -def filter(__function: None, __iterable: Iterable[_T | None]) -> list[_T]: ... +def filter(__function: None, __iterable: Iterable[_T | None]) -> List[_T]: ... @overload -def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> list[_T]: ... +def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> List[_T]: ... def format(__value: object, __format_spec: str = ...) -> str: ... # TODO unicode @overload def getattr(__o: Any, name: Text) -> Any: ... -# While technically covered by the last overload, spelling out the types for None, bool -# and basic containers help mypy out in some tricky situations involving type context -# (aka bidirectional inference) +# While technically covered by the last overload, spelling out the types for None and bool +# help mypy out in some tricky situations involving type context (aka bidirectional inference) @overload def getattr(__o: Any, name: Text, __default: None) -> Any | None: ... @overload def getattr(__o: Any, name: Text, __default: bool) -> Any | bool: ... @overload -def getattr(__o: object, name: str, __default: list[Any]) -> Any | list[Any]: ... -@overload -def getattr(__o: object, name: str, __default: dict[Any, Any]) -> Any | dict[Any, Any]: ... -@overload def getattr(__o: Any, name: Text, __default: _T) -> Any | _T: ... -def globals() -> dict[str, Any]: ... +def globals() -> Dict[str, Any]: ... def hasattr(__obj: Any, __name: Text) -> bool: ... def hash(__obj: object) -> int: ... def hex(__number: int | _SupportsIndex) -> str: ... @@ -855,20 +871,20 @@ def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ... def iter(__function: Callable[[], _T | None], __sentinel: None) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ... -def isinstance(__obj: object, __class_or_tuple: type | tuple[type | tuple[Any, ...], ...]) -> bool: ... -def issubclass(__cls: type, __class_or_tuple: type | tuple[type | tuple[Any, ...], ...]) -> bool: ... +def isinstance(__obj: object, __class_or_tuple: type | Tuple[type | Tuple[Any, ...], ...]) -> bool: ... +def issubclass(__cls: type, __class_or_tuple: type | Tuple[type | Tuple[Any, ...], ...]) -> bool: ... def len(__obj: Sized) -> int: ... -def locals() -> dict[str, Any]: ... +def locals() -> Dict[str, Any]: ... @overload -def map(__func: None, __iter1: Iterable[_T1]) -> list[_T1]: ... +def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ... @overload -def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> list[tuple[_T1, _T2]]: ... +def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ... @overload -def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> list[tuple[_T1, _T2, _T3]]: ... +def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ... @overload def map( __func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] -) -> list[tuple[_T1, _T2, _T3, _T4]]: ... +) -> List[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def map( __func: None, @@ -877,7 +893,7 @@ def map( __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5], -) -> list[tuple[_T1, _T2, _T3, _T4, _T5]]: ... +) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def map( __func: None, @@ -888,15 +904,15 @@ def map( __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], -) -> list[tuple[Any, ...]]: ... +) -> List[Tuple[Any, ...]]: ... @overload -def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> list[_S]: ... +def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> List[_S]: ... @overload -def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> list[_S]: ... +def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] -) -> list[_S]: ... +) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4], _S], @@ -904,7 +920,7 @@ def map( __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], -) -> list[_S]: ... +) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S], @@ -913,7 +929,7 @@ def map( __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5], -) -> list[_S]: ... +) -> List[_S]: ... @overload def map( __func: Callable[..., _S], @@ -924,7 +940,7 @@ def map( __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], -) -> list[_S]: ... +) -> List[_S]: ... @overload def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ... @overload @@ -964,7 +980,7 @@ def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E) -> _T_co: ... @overload def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ... def quit(code: object = ...) -> NoReturn: ... -def range(__x: int, __y: int = ..., __step: int = ...) -> list[int]: ... # noqa: F811 +def range(__x: int, __y: int = ..., __step: int = ...) -> List[int]: ... # noqa: F811 def raw_input(__prompt: Any = ...) -> str: ... @overload def reduce(__function: Callable[[_T, _S], _T], __iterable: Iterable[_S], __initializer: _T) -> _T: ... @@ -987,27 +1003,27 @@ def round(number: SupportsFloat, ndigits: int) -> float: ... def setattr(__obj: Any, __name: Text, __value: Any) -> None: ... def sorted( __iterable: Iterable[_T], *, cmp: Callable[[_T, _T], int] = ..., key: Callable[[_T], Any] | None = ..., reverse: bool = ... -) -> list[_T]: ... +) -> List[_T]: ... @overload def sum(__iterable: Iterable[_T]) -> _T | int: ... @overload def sum(__iterable: Iterable[_T], __start: _S) -> _T | _S: ... def unichr(__i: int) -> unicode: ... -def vars(__object: Any = ...) -> dict[str, Any]: ... +def vars(__object: Any = ...) -> Dict[str, Any]: ... @overload -def zip(__iter1: Iterable[_T1]) -> list[tuple[_T1]]: ... +def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ... @overload -def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> list[tuple[_T1, _T2]]: ... +def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ... @overload -def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> list[tuple[_T1, _T2, _T3]]: ... +def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] -) -> list[tuple[_T1, _T2, _T3, _T4]]: ... +) -> List[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5] -) -> list[tuple[_T1, _T2, _T3, _T4, _T5]]: ... +) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def zip( __iter1: Iterable[Any], @@ -1017,7 +1033,7 @@ def zip( __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], -) -> list[tuple[Any, ...]]: ... +) -> List[Tuple[Any, ...]]: ... def __import__( name: Text, globals: Mapping[str, Any] | None = ..., @@ -1045,11 +1061,13 @@ class buffer(Sized): def __mul__(self, x: int) -> str: ... class BaseException(object): - args: tuple[Any, ...] + args: Tuple[Any, ...] message: Any def __init__(self, *args: object) -> None: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... def __getitem__(self, i: int) -> Any: ... - def __getslice__(self, start: int, stop: int) -> tuple[Any, ...]: ... + def __getslice__(self, start: int, stop: int) -> Tuple[Any, ...]: ... class GeneratorExit(BaseException): ... class KeyboardInterrupt(BaseException): ... @@ -1158,7 +1176,7 @@ class file(BinaryIO): def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... def readline(self, limit: int = ...) -> str: ... - def readlines(self, hint: int = ...) -> list[str]: ... + def readlines(self, hint: int = ...) -> List[str]: ... def write(self, data: str) -> int: ... def writelines(self, data: Iterable[str]) -> None: ... def truncate(self, pos: int | None = ...) -> int: ... |