mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-07 20:54:28 +08:00
b294782183
This pull request is a follow-up to https://github.com/python/mypy/issues/7214. In short, within that mypy issue, we found it would be helpful to determine between contextmanagers that can "swallow" exceptions vs ones that can't. This helps prevent some false positive when using flags that analyze control flow such as `--warn-unreachable`. To do this, Jelle proposed assuming that only contextmanagers where the `__exit__` returns `bool` are assumed to swallow exceptions. This unfortunately required the following typeshed changes: 1. The typing.IO, threading.Lock, and concurrent.futures.Executor were all modified so `__exit__` returns `Optional[None]` instead of None -- along with all of their subclasses. I believe these three types are meant to be subclassed, so I felt picking the more general type was correct. 2. There were also a few concrete types (e.g. see socketserver, subprocess, ftplib...) that I modified to return `None` -- I checked the source code, and these all seem to return None (and don't appear to be meant to be subclassable). 3. contextlib.suppress was changed to return bool. I also double-checked the unittest modules and modified a subset of those contextmanagers, leaving ones like `_AssertRaisesContext` alone.
1634 lines
68 KiB
Python
1634 lines
68 KiB
Python
# True and False are deliberately omitted because they are keywords in
|
|
# Python 3, and stub files conform to Python 3 syntax.
|
|
|
|
from typing import (
|
|
TypeVar, Iterator, Iterable, NoReturn, overload, Container,
|
|
Sequence, MutableSequence, Mapping, MutableMapping, Tuple, List, Any, Dict, Callable, Generic,
|
|
Set, AbstractSet, FrozenSet, MutableSet, Sized, Reversible, SupportsInt, SupportsFloat, SupportsAbs,
|
|
SupportsComplex, IO, BinaryIO, Union,
|
|
ItemsView, KeysView, ValuesView, ByteString, Optional, AnyStr, Type, Text,
|
|
Protocol,
|
|
)
|
|
from abc import abstractmethod, ABCMeta
|
|
from ast import mod, AST
|
|
from types import TracebackType, CodeType, ModuleType
|
|
import sys
|
|
|
|
if sys.version_info >= (3,):
|
|
from typing import SupportsBytes, SupportsRound
|
|
|
|
_T = TypeVar('_T')
|
|
_T_co = TypeVar('_T_co', covariant=True)
|
|
_KT = TypeVar('_KT')
|
|
_VT = TypeVar('_VT')
|
|
_S = TypeVar('_S')
|
|
_T1 = TypeVar('_T1')
|
|
_T2 = TypeVar('_T2')
|
|
_T3 = TypeVar('_T3')
|
|
_T4 = TypeVar('_T4')
|
|
_T5 = TypeVar('_T5')
|
|
_TT = TypeVar('_TT', bound='type')
|
|
|
|
class object:
|
|
__doc__: Optional[str]
|
|
__dict__: Dict[str, Any]
|
|
__slots__: Union[Text, Iterable[Text]]
|
|
__module__: str
|
|
if sys.version_info >= (3, 6):
|
|
__annotations__: Dict[str, Any]
|
|
|
|
@property
|
|
def __class__(self: _T) -> Type[_T]: ...
|
|
@__class__.setter
|
|
def __class__(self, __type: Type[object]) -> None: ...
|
|
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: ...
|
|
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) -> tuple: ...
|
|
def __reduce_ex__(self, protocol: int) -> tuple: ...
|
|
if sys.version_info >= (3,):
|
|
def __dir__(self) -> Iterable[str]: ...
|
|
if sys.version_info >= (3, 6):
|
|
def __init_subclass__(cls) -> None: ...
|
|
|
|
class staticmethod(object): # Special, only valid as a decorator.
|
|
__func__: Callable
|
|
if sys.version_info >= (3,):
|
|
__isabstractmethod__: bool
|
|
|
|
def __init__(self, f: Callable) -> None: ...
|
|
def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
|
|
def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable: ...
|
|
|
|
class classmethod(object): # Special, only valid as a decorator.
|
|
__func__: Callable
|
|
if sys.version_info >= (3,):
|
|
__isabstractmethod__: bool
|
|
|
|
def __init__(self, f: Callable) -> None: ...
|
|
def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
|
|
def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable: ...
|
|
|
|
class type(object):
|
|
__base__: type
|
|
__bases__: Tuple[type, ...]
|
|
__basicsize__: int
|
|
__dict__: Dict[str, Any]
|
|
__dictoffset__: int
|
|
__flags__: int
|
|
__itemsize__: int
|
|
__module__: str
|
|
__mro__: Tuple[type, ...]
|
|
__name__: str
|
|
if sys.version_info >= (3,):
|
|
__qualname__: str
|
|
__text_signature__: Optional[str]
|
|
__weakrefoffset__: int
|
|
|
|
@overload
|
|
def __init__(self, o: object) -> None: ...
|
|
@overload
|
|
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 __call__(self, *args: Any, **kwds: Any) -> Any: ...
|
|
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 __instancecheck__(self, instance: Any) -> bool: ...
|
|
def __subclasscheck__(self, subclass: type) -> bool: ...
|
|
if sys.version_info >= (3,):
|
|
@classmethod
|
|
def __prepare__(metacls, __name: str, __bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]: ...
|
|
|
|
class super(object):
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def __init__(self, t: Any, obj: Any) -> None: ...
|
|
@overload
|
|
def __init__(self, t: Any) -> None: ...
|
|
@overload
|
|
def __init__(self) -> None: ...
|
|
else:
|
|
@overload
|
|
def __init__(self, t: Any, obj: Any) -> None: ...
|
|
@overload
|
|
def __init__(self, t: Any) -> None: ...
|
|
|
|
class int:
|
|
@overload
|
|
def __init__(self, x: Union[Text, bytes, SupportsInt] = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, x: Union[Text, bytes, bytearray], base: int) -> None: ...
|
|
|
|
@property
|
|
def real(self) -> int: ...
|
|
@property
|
|
def imag(self) -> int: ...
|
|
@property
|
|
def numerator(self) -> int: ...
|
|
@property
|
|
def denominator(self) -> int: ...
|
|
def conjugate(self) -> int: ...
|
|
|
|
def bit_length(self) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
def to_bytes(self, length: int, byteorder: str, *, signed: bool = ...) -> bytes: ...
|
|
@classmethod
|
|
def from_bytes(cls, bytes: Sequence[int], byteorder: str, *,
|
|
signed: bool = ...) -> int: ... # TODO buffer object argument
|
|
|
|
def __add__(self, x: int) -> int: ...
|
|
def __sub__(self, x: int) -> int: ...
|
|
def __mul__(self, x: int) -> int: ...
|
|
def __floordiv__(self, x: int) -> int: ...
|
|
if sys.version_info < (3,):
|
|
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 __radd__(self, x: int) -> int: ...
|
|
def __rsub__(self, x: int) -> int: ...
|
|
def __rmul__(self, x: int) -> int: ...
|
|
def __rfloordiv__(self, x: int) -> int: ...
|
|
if sys.version_info < (3,):
|
|
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 __pow__(self, x: int) -> Any: ... # Return type can be int or float, depending on x.
|
|
def __rpow__(self, x: int) -> 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 __neg__(self) -> int: ...
|
|
def __pos__(self) -> int: ...
|
|
def __invert__(self) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
def __round__(self, ndigits: Optional[int] = ...) -> 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: ...
|
|
def __hash__(self) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
def __bool__(self) -> bool: ...
|
|
else:
|
|
def __nonzero__(self) -> bool: ...
|
|
def __index__(self) -> int: ...
|
|
|
|
class float:
|
|
def __init__(self, x: Union[SupportsFloat, Text, bytes, bytearray] = ...) -> None: ...
|
|
def as_integer_ratio(self) -> Tuple[int, int]: ...
|
|
def hex(self) -> str: ...
|
|
def is_integer(self) -> bool: ...
|
|
@classmethod
|
|
def fromhex(cls, s: str) -> float: ...
|
|
|
|
@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: ...
|
|
if sys.version_info < (3,):
|
|
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 __pow__(self, x: float) -> float: ... # In Python 3, returns complex if self is negative and x is not whole
|
|
def __radd__(self, x: float) -> float: ...
|
|
def __rsub__(self, x: float) -> float: ...
|
|
def __rmul__(self, x: float) -> float: ...
|
|
def __rfloordiv__(self, x: float) -> float: ...
|
|
if sys.version_info < (3,):
|
|
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 __rpow__(self, x: float) -> float: ...
|
|
def __getnewargs__(self) -> Tuple[float]: ...
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def __round__(self) -> int: ...
|
|
@overload
|
|
def __round__(self, ndigits: None) -> int: ...
|
|
@overload
|
|
def __round__(self, ndigits: int) -> 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 __neg__(self) -> float: ...
|
|
def __pos__(self) -> float: ...
|
|
|
|
def __str__(self) -> str: ...
|
|
def __int__(self) -> int: ...
|
|
def __float__(self) -> float: ...
|
|
def __abs__(self) -> float: ...
|
|
def __hash__(self) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
def __bool__(self) -> bool: ...
|
|
else:
|
|
def __nonzero__(self) -> bool: ...
|
|
|
|
class complex:
|
|
@overload
|
|
def __init__(self, re: float = ..., im: float = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, s: str) -> None: ...
|
|
@overload
|
|
def __init__(self, s: SupportsComplex) -> None: ...
|
|
|
|
@property
|
|
def real(self) -> float: ...
|
|
@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) -> complex: ...
|
|
if sys.version_info < (3,):
|
|
def __div__(self, x: complex) -> 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) -> complex: ...
|
|
if sys.version_info < (3,):
|
|
def __rdiv__(self, x: complex) -> complex: ...
|
|
def __rtruediv__(self, x: complex) -> complex: ...
|
|
|
|
def __eq__(self, x: object) -> bool: ...
|
|
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: ...
|
|
if sys.version_info >= (3,):
|
|
def __bool__(self) -> bool: ...
|
|
else:
|
|
def __nonzero__(self) -> bool: ...
|
|
|
|
if sys.version_info >= (3,):
|
|
_str_base = object
|
|
else:
|
|
class basestring(metaclass=ABCMeta): ...
|
|
|
|
class unicode(basestring, Sequence[unicode]):
|
|
@overload
|
|
def __init__(self) -> None: ...
|
|
@overload
|
|
def __init__(self, o: object) -> None: ...
|
|
@overload
|
|
def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ...
|
|
def capitalize(self) -> unicode: ...
|
|
def center(self, width: int, fillchar: unicode = ...) -> 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: Union[unicode, Tuple[unicode, ...]], start: int = ...,
|
|
end: int = ...) -> 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: ...
|
|
def index(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
|
|
def isalnum(self) -> bool: ...
|
|
def isalpha(self) -> bool: ...
|
|
def isdecimal(self) -> bool: ...
|
|
def isdigit(self) -> bool: ...
|
|
def isidentifier(self) -> bool: ...
|
|
def islower(self) -> bool: ...
|
|
def isnumeric(self) -> bool: ...
|
|
def isprintable(self) -> bool: ...
|
|
def isspace(self) -> bool: ...
|
|
def istitle(self) -> bool: ...
|
|
def isupper(self) -> bool: ...
|
|
def join(self, iterable: Iterable[unicode]) -> 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 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: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
|
|
def rstrip(self, chars: unicode = ...) -> unicode: ...
|
|
def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
|
|
def splitlines(self, keepends: bool = ...) -> List[unicode]: ...
|
|
def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = ...,
|
|
end: int = ...) -> bool: ...
|
|
def strip(self, chars: unicode = ...) -> unicode: ...
|
|
def swapcase(self) -> unicode: ...
|
|
def title(self) -> unicode: ...
|
|
def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ...
|
|
def upper(self) -> unicode: ...
|
|
def zfill(self, width: int) -> unicode: ...
|
|
|
|
@overload
|
|
def __getitem__(self, i: int) -> unicode: ...
|
|
@overload
|
|
def __getitem__(self, s: slice) -> unicode: ...
|
|
def __getslice__(self, start: int, stop: int) -> unicode: ...
|
|
def __add__(self, s: unicode) -> unicode: ...
|
|
def __mul__(self, n: int) -> unicode: ...
|
|
def __rmul__(self, n: int) -> unicode: ...
|
|
def __mod__(self, x: Any) -> unicode: ...
|
|
def __eq__(self, x: object) -> bool: ...
|
|
def __ne__(self, x: object) -> bool: ...
|
|
def __lt__(self, x: unicode) -> bool: ...
|
|
def __le__(self, x: unicode) -> bool: ...
|
|
def __gt__(self, x: unicode) -> bool: ...
|
|
def __ge__(self, x: unicode) -> bool: ...
|
|
|
|
def __len__(self) -> int: ...
|
|
# The argument type is incompatible with Sequence
|
|
def __contains__(self, s: Union[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]: ...
|
|
|
|
_str_base = basestring
|
|
|
|
class str(Sequence[str], _str_base):
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def __init__(self, o: object = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, o: bytes, encoding: str = ..., errors: str = ...) -> None: ...
|
|
else:
|
|
def __init__(self, o: object = ...) -> None: ...
|
|
|
|
def capitalize(self) -> str: ...
|
|
if sys.version_info >= (3, 3):
|
|
def casefold(self) -> str: ...
|
|
def center(self, width: int, fillchar: str = ...) -> str: ...
|
|
def count(self, x: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
|
|
if sys.version_info < (3,):
|
|
def decode(self, encoding: Text = ..., errors: Text = ...) -> unicode: ...
|
|
def encode(self, encoding: Text = ..., errors: Text = ...) -> bytes: ...
|
|
if sys.version_info >= (3,):
|
|
def endswith(self, suffix: Union[Text, Tuple[Text, ...]], start: Optional[int] = ...,
|
|
end: Optional[int] = ...) -> bool: ...
|
|
else:
|
|
def endswith(self, suffix: Union[Text, Tuple[Text, ...]]) -> bool: ...
|
|
def expandtabs(self, tabsize: int = ...) -> str: ...
|
|
def find(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
|
|
def format(self, *args: object, **kwargs: object) -> str: ...
|
|
if sys.version_info >= (3,):
|
|
def format_map(self, map: Mapping[str, Any]) -> str: ...
|
|
def index(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
|
|
def isalnum(self) -> bool: ...
|
|
def isalpha(self) -> bool: ...
|
|
if sys.version_info >= (3, 7):
|
|
def isascii(self) -> bool: ...
|
|
if sys.version_info >= (3,):
|
|
def isdecimal(self) -> bool: ...
|
|
def isdigit(self) -> bool: ...
|
|
if sys.version_info >= (3,):
|
|
def isidentifier(self) -> bool: ...
|
|
def islower(self) -> bool: ...
|
|
if sys.version_info >= (3,):
|
|
def isnumeric(self) -> bool: ...
|
|
def isprintable(self) -> bool: ...
|
|
def isspace(self) -> bool: ...
|
|
def istitle(self) -> bool: ...
|
|
def isupper(self) -> bool: ...
|
|
if sys.version_info >= (3,):
|
|
def join(self, iterable: Iterable[str]) -> str: ...
|
|
else:
|
|
def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ...
|
|
def ljust(self, width: int, fillchar: str = ...) -> str: ...
|
|
def lower(self) -> str: ...
|
|
if sys.version_info >= (3,):
|
|
def lstrip(self, chars: Optional[str] = ...) -> str: ...
|
|
def partition(self, sep: str) -> Tuple[str, str, str]: ...
|
|
def replace(self, old: str, new: str, count: int = ...) -> str: ...
|
|
else:
|
|
@overload
|
|
def lstrip(self, chars: str = ...) -> str: ...
|
|
@overload
|
|
def lstrip(self, chars: unicode) -> unicode: ...
|
|
@overload
|
|
def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
|
|
@overload
|
|
def partition(self, sep: str) -> Tuple[str, str, str]: ...
|
|
@overload
|
|
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: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
|
|
def rindex(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
|
|
def rjust(self, width: int, fillchar: str = ...) -> str: ...
|
|
if sys.version_info >= (3,):
|
|
def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
|
|
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
|
|
def rstrip(self, chars: Optional[str] = ...) -> str: ...
|
|
def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
|
|
else:
|
|
@overload
|
|
def rpartition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
|
|
@overload
|
|
def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
|
|
@overload
|
|
def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
|
|
@overload
|
|
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
|
|
@overload
|
|
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: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
|
|
@overload
|
|
def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
|
|
def splitlines(self, keepends: bool = ...) -> List[str]: ...
|
|
if sys.version_info >= (3,):
|
|
def startswith(self, prefix: Union[Text, Tuple[Text, ...]], start: Optional[int] = ...,
|
|
end: Optional[int] = ...) -> bool: ...
|
|
def strip(self, chars: Optional[str] = ...) -> str: ...
|
|
else:
|
|
def startswith(self, prefix: Union[Text, Tuple[Text, ...]]) -> bool: ...
|
|
@overload
|
|
def strip(self, chars: str = ...) -> str: ...
|
|
@overload
|
|
def strip(self, chars: unicode) -> unicode: ...
|
|
def swapcase(self) -> str: ...
|
|
def title(self) -> str: ...
|
|
if sys.version_info >= (3,):
|
|
def translate(self, table: Union[Mapping[int, Union[int, str, None]], Sequence[Union[int, str, None]]]) -> str: ...
|
|
else:
|
|
def translate(self, table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ...
|
|
def upper(self) -> str: ...
|
|
def zfill(self, width: int) -> str: ...
|
|
if sys.version_info >= (3,):
|
|
@staticmethod
|
|
@overload
|
|
def maketrans(x: Union[Dict[int, _T], Dict[str, _T], Dict[Union[str, int], _T]]) -> Dict[int, _T]: ...
|
|
@staticmethod
|
|
@overload
|
|
def maketrans(x: str, y: str, z: str = ...) -> Dict[int, Union[int, None]]: ...
|
|
|
|
if sys.version_info >= (3,):
|
|
def __add__(self, s: str) -> str: ...
|
|
else:
|
|
def __add__(self, s: AnyStr) -> AnyStr: ...
|
|
# Incompatible with Sequence.__contains__
|
|
def __contains__(self, o: Union[str, Text]) -> bool: ... # type: ignore
|
|
def __eq__(self, x: object) -> bool: ...
|
|
def __ge__(self, x: Text) -> bool: ...
|
|
def __getitem__(self, i: Union[int, slice]) -> str: ...
|
|
def __gt__(self, x: Text) -> bool: ...
|
|
def __hash__(self) -> int: ...
|
|
def __iter__(self) -> Iterator[str]: ...
|
|
def __le__(self, x: Text) -> bool: ...
|
|
def __len__(self) -> int: ...
|
|
def __lt__(self, x: Text) -> bool: ...
|
|
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 __str__(self) -> str: ...
|
|
def __getnewargs__(self) -> Tuple[str]: ...
|
|
|
|
if sys.version_info < (3,):
|
|
def __getslice__(self, start: int, stop: int) -> str: ...
|
|
def __float__(self) -> float: ...
|
|
def __int__(self) -> int: ...
|
|
|
|
if sys.version_info >= (3,):
|
|
class bytes(ByteString):
|
|
@overload
|
|
def __init__(self, ints: Iterable[int]) -> None: ...
|
|
@overload
|
|
def __init__(self, string: str, encoding: str,
|
|
errors: str = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, length: int) -> None: ...
|
|
@overload
|
|
def __init__(self) -> None: ...
|
|
@overload
|
|
def __init__(self, o: SupportsBytes) -> None: ...
|
|
def capitalize(self) -> bytes: ...
|
|
def center(self, width: int, fillchar: bytes = ...) -> bytes: ...
|
|
def count(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
def decode(self, encoding: str = ..., errors: str = ...) -> str: ...
|
|
def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
|
|
def expandtabs(self, tabsize: int = ...) -> bytes: ...
|
|
def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
if sys.version_info >= (3, 5):
|
|
def hex(self) -> str: ...
|
|
def index(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
def isalnum(self) -> bool: ...
|
|
def isalpha(self) -> bool: ...
|
|
if sys.version_info >= (3, 7):
|
|
def isascii(self) -> bool: ...
|
|
def isdigit(self) -> bool: ...
|
|
def islower(self) -> bool: ...
|
|
def isspace(self) -> bool: ...
|
|
def istitle(self) -> bool: ...
|
|
def isupper(self) -> bool: ...
|
|
def join(self, iterable: Iterable[Union[ByteString, memoryview]]) -> bytes: ...
|
|
def ljust(self, width: int, fillchar: bytes = ...) -> bytes: ...
|
|
def lower(self) -> bytes: ...
|
|
def lstrip(self, chars: Optional[bytes] = ...) -> bytes: ...
|
|
def partition(self, sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
|
|
def replace(self, old: bytes, new: bytes, count: int = ...) -> bytes: ...
|
|
def rfind(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
def rindex(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
def rjust(self, width: int, fillchar: bytes = ...) -> bytes: ...
|
|
def rpartition(self, sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
|
|
def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ...
|
|
def rstrip(self, chars: Optional[bytes] = ...) -> bytes: ...
|
|
def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ...
|
|
def splitlines(self, keepends: bool = ...) -> List[bytes]: ...
|
|
def startswith(
|
|
self,
|
|
prefix: Union[bytes, Tuple[bytes, ...]],
|
|
start: Optional[int] = ...,
|
|
end: Optional[int] = ...,
|
|
) -> bool: ...
|
|
def strip(self, chars: Optional[bytes] = ...) -> bytes: ...
|
|
def swapcase(self) -> bytes: ...
|
|
def title(self) -> bytes: ...
|
|
def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytes: ...
|
|
def upper(self) -> bytes: ...
|
|
def zfill(self, width: int) -> bytes: ...
|
|
@classmethod
|
|
def fromhex(cls, s: str) -> bytes: ...
|
|
@classmethod
|
|
def maketrans(cls, frm: bytes, to: bytes) -> bytes: ...
|
|
|
|
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: ...
|
|
def __hash__(self) -> int: ...
|
|
@overload
|
|
def __getitem__(self, i: int) -> int: ...
|
|
@overload
|
|
def __getitem__(self, s: slice) -> bytes: ...
|
|
def __add__(self, s: bytes) -> bytes: ...
|
|
def __mul__(self, n: int) -> bytes: ...
|
|
def __rmul__(self, n: int) -> bytes: ...
|
|
if sys.version_info >= (3, 5):
|
|
def __mod__(self, value: Any) -> bytes: ...
|
|
# Incompatible with Sequence.__contains__
|
|
def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore
|
|
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 __getnewargs__(self) -> Tuple[bytes]: ...
|
|
else:
|
|
bytes = str
|
|
|
|
class bytearray(MutableSequence[int], ByteString):
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def __init__(self) -> None: ...
|
|
@overload
|
|
def __init__(self, ints: Iterable[int]) -> None: ...
|
|
@overload
|
|
def __init__(self, string: Text, encoding: Text, errors: Text = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, length: int) -> None: ...
|
|
else:
|
|
@overload
|
|
def __init__(self) -> None: ...
|
|
@overload
|
|
def __init__(self, ints: Iterable[int]) -> None: ...
|
|
@overload
|
|
def __init__(self, string: str) -> None: ...
|
|
@overload
|
|
def __init__(self, string: Text, encoding: Text, errors: Text = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, length: int) -> None: ...
|
|
def capitalize(self) -> bytearray: ...
|
|
def center(self, width: int, fillchar: bytes = ...) -> bytearray: ...
|
|
if sys.version_info >= (3,):
|
|
def count(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
def copy(self) -> bytearray: ...
|
|
else:
|
|
def count(self, x: str) -> int: ...
|
|
def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ...
|
|
def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
|
|
def expandtabs(self, tabsize: int = ...) -> bytearray: ...
|
|
if sys.version_info >= (3,):
|
|
def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
if sys.version_info >= (3, 5):
|
|
def hex(self) -> str: ...
|
|
def index(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
else:
|
|
def find(self, sub: str, start: int = ..., end: int = ...) -> int: ...
|
|
def index(self, sub: str, start: int = ..., end: int = ...) -> int: ...
|
|
def insert(self, index: int, object: int) -> None: ...
|
|
def isalnum(self) -> bool: ...
|
|
def isalpha(self) -> bool: ...
|
|
if sys.version_info >= (3, 7):
|
|
def isascii(self) -> bool: ...
|
|
def isdigit(self) -> bool: ...
|
|
def islower(self) -> bool: ...
|
|
def isspace(self) -> bool: ...
|
|
def istitle(self) -> bool: ...
|
|
def isupper(self) -> bool: ...
|
|
if sys.version_info >= (3,):
|
|
def join(self, iterable: Iterable[Union[ByteString, memoryview]]) -> bytearray: ...
|
|
def ljust(self, width: int, fillchar: bytes = ...) -> bytearray: ...
|
|
else:
|
|
def join(self, iterable: Iterable[str]) -> bytearray: ...
|
|
def ljust(self, width: int, fillchar: str = ...) -> bytearray: ...
|
|
def lower(self) -> bytearray: ...
|
|
def lstrip(self, chars: Optional[bytes] = ...) -> bytearray: ...
|
|
def partition(self, sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
|
|
def replace(self, old: bytes, new: bytes, count: int = ...) -> bytearray: ...
|
|
if sys.version_info >= (3,):
|
|
def rfind(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
def rindex(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
|
|
else:
|
|
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: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
|
|
def rstrip(self, chars: Optional[bytes] = ...) -> bytearray: ...
|
|
def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
|
|
def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
|
|
def startswith(
|
|
self,
|
|
prefix: Union[bytes, Tuple[bytes, ...]],
|
|
start: Optional[int] = ...,
|
|
end: Optional[int] = ...,
|
|
) -> bool: ...
|
|
def strip(self, chars: Optional[bytes] = ...) -> bytearray: ...
|
|
def swapcase(self) -> bytearray: ...
|
|
def title(self) -> bytearray: ...
|
|
if sys.version_info >= (3,):
|
|
def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytearray: ...
|
|
else:
|
|
def translate(self, table: str) -> bytearray: ...
|
|
def upper(self) -> bytearray: ...
|
|
def zfill(self, width: int) -> bytearray: ...
|
|
@staticmethod
|
|
def fromhex(s: str) -> bytearray: ...
|
|
if sys.version_info >= (3,):
|
|
@classmethod
|
|
def maketrans(cls, frm: bytes, to: bytes) -> bytes: ...
|
|
|
|
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: ...
|
|
def __hash__(self) -> int: ...
|
|
@overload
|
|
def __getitem__(self, i: int) -> int: ...
|
|
@overload
|
|
def __getitem__(self, s: slice) -> bytearray: ...
|
|
@overload
|
|
def __setitem__(self, i: int, x: int) -> None: ...
|
|
@overload
|
|
def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ...
|
|
def __delitem__(self, i: Union[int, slice]) -> None: ...
|
|
if sys.version_info < (3,):
|
|
def __getslice__(self, start: int, stop: int) -> bytearray: ...
|
|
def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ...
|
|
def __delslice__(self, start: int, stop: int) -> None: ...
|
|
def __add__(self, s: bytes) -> bytearray: ...
|
|
if sys.version_info >= (3,):
|
|
def __iadd__(self, s: Iterable[int]) -> bytearray: ...
|
|
def __mul__(self, n: int) -> bytearray: ...
|
|
if sys.version_info >= (3,):
|
|
def __rmul__(self, n: int) -> bytearray: ...
|
|
def __imul__(self, n: int) -> bytearray: ...
|
|
if sys.version_info >= (3, 5):
|
|
def __mod__(self, value: Any) -> bytes: ...
|
|
# Incompatible with Sequence.__contains__
|
|
def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore
|
|
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: ...
|
|
|
|
if sys.version_info >= (3,):
|
|
_mv_container_type = int
|
|
else:
|
|
_mv_container_type = str
|
|
|
|
class memoryview(Sized, Container[_mv_container_type]):
|
|
format: str
|
|
itemsize: int
|
|
shape: Optional[Tuple[int, ...]]
|
|
strides: Optional[Tuple[int, ...]]
|
|
suboffsets: Optional[Tuple[int, ...]]
|
|
readonly: bool
|
|
ndim: int
|
|
|
|
if sys.version_info >= (3,):
|
|
c_contiguous: bool
|
|
f_contiguous: bool
|
|
contiguous: bool
|
|
nbytes: int
|
|
def __init__(self, obj: Union[bytes, bytearray, memoryview]) -> None: ...
|
|
def __enter__(self) -> memoryview: ...
|
|
def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> None: ...
|
|
else:
|
|
def __init__(self, obj: Union[bytes, bytearray, buffer, memoryview]) -> None: ...
|
|
|
|
@overload
|
|
def __getitem__(self, i: int) -> _mv_container_type: ...
|
|
@overload
|
|
def __getitem__(self, s: slice) -> memoryview: ...
|
|
|
|
def __contains__(self, x: object) -> bool: ...
|
|
def __iter__(self) -> Iterator[_mv_container_type]: ...
|
|
def __len__(self) -> int: ...
|
|
|
|
@overload
|
|
def __setitem__(self, i: int, o: bytes) -> None: ...
|
|
@overload
|
|
def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
|
|
@overload
|
|
def __setitem__(self, s: slice, o: memoryview) -> None: ...
|
|
|
|
def tobytes(self) -> bytes: ...
|
|
def tolist(self) -> List[int]: ...
|
|
|
|
if sys.version_info >= (3, 5):
|
|
def hex(self) -> str: ...
|
|
|
|
class bool(int):
|
|
def __init__(self, o: object = ...) -> None: ...
|
|
@overload
|
|
def __and__(self, x: bool) -> bool: ...
|
|
@overload
|
|
def __and__(self, x: int) -> int: ...
|
|
@overload
|
|
def __or__(self, x: bool) -> bool: ...
|
|
@overload
|
|
def __or__(self, x: int) -> int: ...
|
|
@overload
|
|
def __xor__(self, x: bool) -> bool: ...
|
|
@overload
|
|
def __xor__(self, x: int) -> int: ...
|
|
@overload
|
|
def __rand__(self, x: bool) -> bool: ...
|
|
@overload
|
|
def __rand__(self, x: int) -> int: ...
|
|
@overload
|
|
def __ror__(self, x: bool) -> bool: ...
|
|
@overload
|
|
def __ror__(self, x: int) -> int: ...
|
|
@overload
|
|
def __rxor__(self, x: bool) -> bool: ...
|
|
@overload
|
|
def __rxor__(self, x: int) -> int: ...
|
|
def __getnewargs__(self) -> Tuple[int]: ...
|
|
|
|
class slice(object):
|
|
start: Any
|
|
step: Any
|
|
stop: Any
|
|
@overload
|
|
def __init__(self, stop: Any) -> None: ...
|
|
@overload
|
|
def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ...
|
|
def indices(self, len: int) -> Tuple[int, int, int]: ...
|
|
|
|
class tuple(Sequence[_T_co], Generic[_T_co]):
|
|
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 __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 __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
|
|
def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
|
|
def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
|
|
def count(self, x: Any) -> int: ...
|
|
if sys.version_info >= (3, 5):
|
|
def index(self, x: Any, start: int = ..., end: int = ...) -> int: ...
|
|
else:
|
|
def index(self, x: Any) -> int: ...
|
|
|
|
class function:
|
|
# TODO not defined in builtins!
|
|
__name__: str
|
|
__module__: str
|
|
__code__: CodeType
|
|
if sys.version_info >= (3,):
|
|
__qualname__: str
|
|
__annotations__: Dict[str, Any]
|
|
|
|
class list(MutableSequence[_T], Generic[_T]):
|
|
@overload
|
|
def __init__(self) -> None: ...
|
|
@overload
|
|
def __init__(self, iterable: Iterable[_T]) -> None: ...
|
|
if sys.version_info >= (3,):
|
|
def clear(self) -> None: ...
|
|
def copy(self) -> List[_T]: ...
|
|
def append(self, object: _T) -> None: ...
|
|
def extend(self, iterable: Iterable[_T]) -> None: ...
|
|
def pop(self, index: int = ...) -> _T: ...
|
|
def index(self, object: _T, start: int = ..., stop: int = ...) -> int: ...
|
|
def count(self, object: _T) -> int: ...
|
|
def insert(self, index: int, object: _T) -> None: ...
|
|
def remove(self, object: _T) -> None: ...
|
|
def reverse(self) -> None: ...
|
|
if sys.version_info >= (3,):
|
|
def sort(self, *, key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> None: ...
|
|
else:
|
|
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: ...
|
|
def __hash__(self) -> int: ...
|
|
@overload
|
|
def __getitem__(self, i: int) -> _T: ...
|
|
@overload
|
|
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: Union[int, slice]) -> None: ...
|
|
if sys.version_info < (3,):
|
|
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: _S, x: Iterable[_T]) -> _S: ...
|
|
def __mul__(self, n: int) -> List[_T]: ...
|
|
def __rmul__(self, n: int) -> List[_T]: ...
|
|
if sys.version_info >= (3,):
|
|
def __imul__(self: _S, n: int) -> _S: ...
|
|
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: ...
|
|
|
|
class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
|
|
# NOTE: Keyword arguments are special. If they are used, _KT must include
|
|
# str, but we have no way of enforcing it here.
|
|
@overload
|
|
def __init__(self, **kwargs: _VT) -> None: ...
|
|
@overload
|
|
def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
|
|
@overload
|
|
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
|
|
|
|
def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ...
|
|
|
|
if sys.version_info < (3,):
|
|
def has_key(self, k: _KT) -> bool: ...
|
|
def clear(self) -> None: ...
|
|
def copy(self) -> Dict[_KT, _VT]: ...
|
|
def popitem(self) -> Tuple[_KT, _VT]: ...
|
|
def setdefault(self, k: _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: ...
|
|
@overload
|
|
def update(self, **kwargs: _VT) -> None: ...
|
|
if sys.version_info >= (3,):
|
|
def keys(self) -> KeysView[_KT]: ...
|
|
def values(self) -> ValuesView[_VT]: ...
|
|
def items(self) -> ItemsView[_KT, _VT]: ...
|
|
else:
|
|
def iterkeys(self) -> Iterator[_KT]: ...
|
|
def itervalues(self) -> Iterator[_VT]: ...
|
|
def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...
|
|
def viewkeys(self) -> KeysView[_KT]: ...
|
|
def viewvalues(self) -> ValuesView[_VT]: ...
|
|
def viewitems(self) -> ItemsView[_KT, _VT]: ...
|
|
@staticmethod
|
|
@overload
|
|
def fromkeys(seq: Iterable[_T]) -> Dict[_T, Any]: ... # TODO: Actually a class method (mypy/issues#328)
|
|
@staticmethod
|
|
@overload
|
|
def fromkeys(seq: 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: ...
|
|
|
|
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 difference_update(self, *s: Iterable[Any]) -> None: ...
|
|
def discard(self, element: _T) -> None: ...
|
|
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_update(self, s: Iterable[_T]) -> None: ...
|
|
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 __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[Union[_T, _S]]: ...
|
|
def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
|
|
def __sub__(self, s: AbstractSet[object]) -> Set[_T]: ...
|
|
def __isub__(self, s: AbstractSet[object]) -> Set[_T]: ...
|
|
def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
|
|
def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _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 frozenset(AbstractSet[_T], Generic[_T]):
|
|
def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
|
|
def copy(self) -> FrozenSet[_T]: ...
|
|
def difference(self, *s: Iterable[object]) -> FrozenSet[_T]: ...
|
|
def intersection(self, *s: Iterable[object]) -> FrozenSet[_T]: ...
|
|
def isdisjoint(self, s: Iterable[_T]) -> bool: ...
|
|
def issubset(self, s: Iterable[object]) -> bool: ...
|
|
def issuperset(self, s: Iterable[object]) -> bool: ...
|
|
def symmetric_difference(self, s: Iterable[_T]) -> FrozenSet[_T]: ...
|
|
def union(self, *s: Iterable[_T]) -> FrozenSet[_T]: ...
|
|
def __len__(self) -> int: ...
|
|
def __contains__(self, o: object) -> bool: ...
|
|
def __iter__(self) -> Iterator[_T]: ...
|
|
def __str__(self) -> str: ...
|
|
def __and__(self, s: AbstractSet[_T]) -> FrozenSet[_T]: ...
|
|
def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T, _S]]: ...
|
|
def __sub__(self, s: AbstractSet[_T]) -> FrozenSet[_T]: ...
|
|
def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T, _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]):
|
|
def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ...
|
|
def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
|
|
if sys.version_info >= (3,):
|
|
def __next__(self) -> Tuple[int, _T]: ...
|
|
else:
|
|
def next(self) -> Tuple[int, _T]: ...
|
|
|
|
if sys.version_info >= (3,):
|
|
class range(Sequence[int]):
|
|
start: int
|
|
stop: int
|
|
step: int
|
|
@overload
|
|
def __init__(self, stop: int) -> None: ...
|
|
@overload
|
|
def __init__(self, start: int, stop: int, step: int = ...) -> None: ...
|
|
def count(self, value: int) -> int: ...
|
|
def index(self, value: int, start: int = ..., stop: Optional[int] = ...) -> int: ...
|
|
def __len__(self) -> int: ...
|
|
def __contains__(self, o: object) -> bool: ...
|
|
def __iter__(self) -> Iterator[int]: ...
|
|
@overload
|
|
def __getitem__(self, i: int) -> int: ...
|
|
@overload
|
|
def __getitem__(self, s: slice) -> range: ...
|
|
def __repr__(self) -> str: ...
|
|
def __reversed__(self) -> Iterator[int]: ...
|
|
else:
|
|
class xrange(Sized, Iterable[int], Reversible[int]):
|
|
@overload
|
|
def __init__(self, stop: int) -> None: ...
|
|
@overload
|
|
def __init__(self, start: int, stop: int, step: int = ...) -> None: ...
|
|
def __len__(self) -> int: ...
|
|
def __iter__(self) -> Iterator[int]: ...
|
|
def __getitem__(self, i: int) -> int: ...
|
|
def __reversed__(self) -> Iterator[int]: ...
|
|
|
|
class property(object):
|
|
def __init__(self, fget: Optional[Callable[[Any], Any]] = ...,
|
|
fset: Optional[Callable[[Any, Any], None]] = ...,
|
|
fdel: Optional[Callable[[Any], None]] = ...,
|
|
doc: Optional[str] = ...) -> None: ...
|
|
def getter(self, fget: Callable[[Any], Any]) -> property: ...
|
|
def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
|
|
def deleter(self, fdel: Callable[[Any], None]) -> property: ...
|
|
def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ...
|
|
def __set__(self, obj: Any, value: Any) -> None: ...
|
|
def __delete__(self, obj: Any) -> None: ...
|
|
def fget(self) -> Any: ...
|
|
def fset(self, value: Any) -> None: ...
|
|
def fdel(self) -> None: ...
|
|
|
|
if sys.version_info < (3,):
|
|
long = int
|
|
|
|
NotImplemented: Any
|
|
|
|
def abs(__n: SupportsAbs[_T]) -> _T: ...
|
|
def all(__i: Iterable[object]) -> bool: ...
|
|
def any(__i: Iterable[object]) -> bool: ...
|
|
if sys.version_info < (3,):
|
|
def apply(__func: Callable[..., _T], __args: Optional[Sequence[Any]] = ..., __kwds: Optional[Mapping[str, Any]] = ...) -> _T: ...
|
|
if sys.version_info >= (3,):
|
|
def ascii(__o: object) -> str: ...
|
|
|
|
class _SupportsIndex(Protocol):
|
|
def __index__(self) -> int: ...
|
|
def bin(__number: Union[int, _SupportsIndex]) -> str: ...
|
|
|
|
if sys.version_info >= (3, 7):
|
|
def breakpoint(*args: Any, **kws: Any) -> None: ...
|
|
def callable(__o: object) -> bool: ...
|
|
def chr(__code: int) -> str: ...
|
|
if sys.version_info < (3,):
|
|
def cmp(__x: Any, __y: Any) -> int: ...
|
|
_N1 = TypeVar('_N1', bool, int, float, complex)
|
|
def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ...
|
|
if sys.version_info >= (3, 6):
|
|
# This class is to be exported as PathLike from os,
|
|
# but we define it here as _PathLike to avoid import cycle issues.
|
|
# See https://github.com/python/typeshed/pull/991#issuecomment-288160993
|
|
class _PathLike(Generic[AnyStr]):
|
|
def __fspath__(self) -> AnyStr: ...
|
|
def compile(source: Union[str, bytes, mod, AST], filename: Union[str, bytes, _PathLike], mode: str, flags: int = ..., dont_inherit: int = ..., optimize: int = ...) -> Any: ...
|
|
elif sys.version_info >= (3,):
|
|
def compile(source: Union[str, bytes, mod, AST], filename: Union[str, bytes], mode: str, flags: int = ..., dont_inherit: int = ..., optimize: int = ...) -> Any: ...
|
|
else:
|
|
def compile(source: Union[Text, mod], filename: Text, mode: Text, flags: int = ..., dont_inherit: int = ...) -> Any: ...
|
|
if sys.version_info >= (3,):
|
|
def copyright() -> None: ...
|
|
def credits() -> None: ...
|
|
def delattr(__o: Any, __name: Text) -> None: ...
|
|
def dir(__o: object = ...) -> List[str]: ...
|
|
_N2 = TypeVar('_N2', int, float)
|
|
def divmod(__a: _N2, __b: _N2) -> Tuple[_N2, _N2]: ...
|
|
def eval(__source: Union[Text, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ...) -> Any: ...
|
|
if sys.version_info >= (3,):
|
|
def exec(__object: Union[str, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ...) -> Any: ...
|
|
else:
|
|
def execfile(__filename: str, __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Dict[str, Any]] = ...) -> None: ...
|
|
def exit(code: object = ...) -> NoReturn: ...
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> Iterator[_T]: ...
|
|
@overload
|
|
def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> Iterator[_T]: ...
|
|
else:
|
|
@overload
|
|
def filter(__function: Callable[[AnyStr], Any], # type: ignore
|
|
__iterable: AnyStr) -> AnyStr: ...
|
|
@overload
|
|
def filter(__function: None, # type: ignore
|
|
__iterable: Tuple[Optional[_T], ...]) -> Tuple[_T, ...]: ...
|
|
@overload
|
|
def filter(__function: Callable[[_T], Any], # type: ignore
|
|
__iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ...
|
|
@overload
|
|
def filter(__function: None,
|
|
__iterable: Iterable[Optional[_T]]) -> List[_T]: ...
|
|
@overload
|
|
def filter(__function: Callable[[_T], Any],
|
|
__iterable: Iterable[_T]) -> List[_T]: ...
|
|
def format(__o: object, __format_spec: str = ...) -> str: ... # TODO unicode
|
|
def getattr(__o: Any, name: Text, __default: Any = ...) -> Any: ...
|
|
def globals() -> Dict[str, Any]: ...
|
|
def hasattr(__o: Any, __name: Text) -> bool: ...
|
|
def hash(__o: object) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
def help(*args: Any, **kwds: Any) -> None: ...
|
|
def hex(__i: Union[int, _SupportsIndex]) -> str: ...
|
|
def id(__o: object) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
def input(__prompt: Any = ...) -> str: ...
|
|
else:
|
|
def input(__prompt: Any = ...) -> Any: ...
|
|
def intern(__string: str) -> str: ...
|
|
@overload
|
|
def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ...
|
|
@overload
|
|
def iter(__function: Callable[[], _T], __sentinel: _T) -> Iterator[_T]: ...
|
|
def isinstance(__o: object, __t: Union[type, Tuple[Union[type, Tuple], ...]]) -> bool: ...
|
|
def issubclass(__cls: type, __classinfo: Union[type, Tuple[Union[type, Tuple], ...]]) -> bool: ...
|
|
def len(__o: Sized) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
def license() -> None: ...
|
|
def locals() -> Dict[str, Any]: ...
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> Iterator[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2]) -> Iterator[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[[_T1, _T2, _T3], _S],
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3]) -> Iterator[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[[_T1, _T2, _T3, _T4], _S],
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4]) -> Iterator[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4],
|
|
__iter5: Iterable[_T5]) -> Iterator[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[..., _S],
|
|
__iter1: Iterable[Any],
|
|
__iter2: Iterable[Any],
|
|
__iter3: Iterable[Any],
|
|
__iter4: Iterable[Any],
|
|
__iter5: Iterable[Any],
|
|
__iter6: Iterable[Any],
|
|
*iterables: Iterable[Any]) -> Iterator[_S]: ...
|
|
else:
|
|
@overload
|
|
def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ...
|
|
@overload
|
|
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]]: ...
|
|
@overload
|
|
def map(__func: None,
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
|
|
@overload
|
|
def map(__func: None,
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4],
|
|
__iter5: Iterable[_T5]) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
|
|
@overload
|
|
def map(__func: None,
|
|
__iter1: Iterable[Any],
|
|
__iter2: Iterable[Any],
|
|
__iter3: Iterable[Any],
|
|
__iter4: Iterable[Any],
|
|
__iter5: Iterable[Any],
|
|
__iter6: Iterable[Any],
|
|
*iterables: Iterable[Any]) -> List[Tuple[Any, ...]]: ...
|
|
@overload
|
|
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]: ...
|
|
@overload
|
|
def map(__func: Callable[[_T1, _T2, _T3], _S],
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3]) -> List[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[[_T1, _T2, _T3, _T4], _S],
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4]) -> List[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
|
|
__iter1: Iterable[_T1],
|
|
__iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4],
|
|
__iter5: Iterable[_T5]) -> List[_S]: ...
|
|
@overload
|
|
def map(__func: Callable[..., _S],
|
|
__iter1: Iterable[Any],
|
|
__iter2: Iterable[Any],
|
|
__iter3: Iterable[Any],
|
|
__iter4: Iterable[Any],
|
|
__iter5: Iterable[Any],
|
|
__iter6: Iterable[Any],
|
|
*iterables: Iterable[Any]) -> List[_S]: ...
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
@overload
|
|
def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
@overload
|
|
def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ..., default: _VT) -> Union[_T, _VT]: ...
|
|
else:
|
|
@overload
|
|
def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
@overload
|
|
def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
@overload
|
|
def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
@overload
|
|
def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ..., default: _VT) -> Union[_T, _VT]: ...
|
|
else:
|
|
@overload
|
|
def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
@overload
|
|
def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
|
@overload
|
|
def next(__i: Iterator[_T]) -> _T: ...
|
|
@overload
|
|
def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
|
|
def oct(__i: Union[int, _SupportsIndex]) -> str: ...
|
|
|
|
if sys.version_info >= (3, 6):
|
|
def open(file: Union[str, bytes, int, _PathLike], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ...,
|
|
errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ...,
|
|
opener: Optional[Callable[[str, int], int]] = ...) -> IO[Any]: ...
|
|
elif sys.version_info >= (3,):
|
|
def open(file: Union[str, bytes, int], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ...,
|
|
errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ...,
|
|
opener: Optional[Callable[[str, int], int]] = ...) -> IO[Any]: ...
|
|
else:
|
|
def open(name: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...
|
|
|
|
def ord(__c: Union[Text, bytes]) -> int: ...
|
|
if sys.version_info >= (3,):
|
|
class _Writer(Protocol):
|
|
def write(self, __s: str) -> Any: ...
|
|
def print(*values: object, sep: Text = ..., end: Text = ..., file: Optional[_Writer] = ..., flush: bool = ...) -> None: ...
|
|
else:
|
|
class _Writer(Protocol):
|
|
def write(self, __s: Any) -> Any: ...
|
|
# This is only available after from __future__ import print_function.
|
|
def print(*values: object, sep: Text = ..., end: Text = ..., file: Optional[_Writer] = ...) -> None: ...
|
|
@overload
|
|
def pow(__x: int, __y: int) -> Any: ... # The return type can be int or float, depending on y
|
|
@overload
|
|
def pow(__x: int, __y: int, __z: int) -> Any: ...
|
|
@overload
|
|
def pow(__x: float, __y: float) -> float: ...
|
|
@overload
|
|
def pow(__x: float, __y: float, __z: float) -> float: ...
|
|
def quit(code: object = ...) -> NoReturn: ...
|
|
if sys.version_info < (3,):
|
|
def range(__x: int, __y: int = ..., __step: int = ...) -> List[int]: ...
|
|
def raw_input(__prompt: Any = ...) -> str: ...
|
|
@overload
|
|
def reduce(__function: Callable[[_T, _S], _T], __iterable: Iterable[_S], __initializer: _T) -> _T: ...
|
|
@overload
|
|
def reduce(__function: Callable[[_T, _T], _T], __iterable: Iterable[_T]) -> _T: ...
|
|
def reload(__module: Any) -> Any: ...
|
|
@overload
|
|
def reversed(__object: Sequence[_T]) -> Iterator[_T]: ...
|
|
@overload
|
|
def reversed(__object: Reversible[_T]) -> Iterator[_T]: ...
|
|
def repr(__o: object) -> str: ...
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def round(number: float) -> int: ...
|
|
@overload
|
|
def round(number: float, ndigits: None) -> int: ...
|
|
@overload
|
|
def round(number: float, ndigits: int) -> float: ...
|
|
@overload
|
|
def round(number: SupportsRound[_T]) -> int: ...
|
|
@overload
|
|
def round(number: SupportsRound[_T], ndigits: None) -> int: ... # type: ignore
|
|
@overload
|
|
def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
|
|
else:
|
|
@overload
|
|
def round(number: float) -> float: ...
|
|
@overload
|
|
def round(number: float, ndigits: int) -> float: ...
|
|
@overload
|
|
def round(number: SupportsFloat) -> float: ...
|
|
@overload
|
|
def round(number: SupportsFloat, ndigits: int) -> float: ...
|
|
def setattr(__object: Any, __name: Text, __value: Any) -> None: ...
|
|
if sys.version_info >= (3,):
|
|
def sorted(__iterable: Iterable[_T], *,
|
|
key: Optional[Callable[[_T], Any]] = ...,
|
|
reverse: bool = ...) -> List[_T]: ...
|
|
else:
|
|
def sorted(__iterable: Iterable[_T], *,
|
|
cmp: Callable[[_T, _T], int] = ...,
|
|
key: Optional[Callable[[_T], Any]] = ...,
|
|
reverse: bool = ...) -> List[_T]: ...
|
|
@overload
|
|
def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ...
|
|
@overload
|
|
def sum(__iterable: Iterable[_T], __start: _S) -> Union[_T, _S]: ...
|
|
if sys.version_info < (3,):
|
|
def unichr(__i: int) -> unicode: ...
|
|
def vars(__object: Any = ...) -> Dict[str, Any]: ...
|
|
if sys.version_info >= (3,):
|
|
@overload
|
|
def zip(__iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
|
|
@overload
|
|
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
|
|
@overload
|
|
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2],
|
|
__iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...
|
|
@overload
|
|
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4]) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ...
|
|
@overload
|
|
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3],
|
|
__iter4: Iterable[_T4], __iter5: Iterable[_T5]) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
|
|
@overload
|
|
def zip(__iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any],
|
|
__iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any],
|
|
*iterables: Iterable[Any]) -> Iterator[Tuple[Any, ...]]: ...
|
|
else:
|
|
@overload
|
|
def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
|
|
@overload
|
|
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]]: ...
|
|
@overload
|
|
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3],
|
|
__iter4: Iterable[_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]]: ...
|
|
@overload
|
|
def zip(__iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any],
|
|
__iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any],
|
|
*iterables: Iterable[Any]) -> List[Tuple[Any, ...]]: ...
|
|
def __import__(name: Text, globals: Optional[Mapping[str, Any]] = ...,
|
|
locals: Optional[Mapping[str, Any]] = ...,
|
|
fromlist: Sequence[str] = ...,
|
|
level: int = ...) -> ModuleType: ...
|
|
|
|
# Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
|
|
# not exposed anywhere under that name, we make it private here.
|
|
class ellipsis: ...
|
|
Ellipsis: ellipsis
|
|
|
|
if sys.version_info < (3,):
|
|
# TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check.
|
|
_AnyBuffer = TypeVar('_AnyBuffer', str, unicode, bytearray, buffer)
|
|
|
|
class buffer(Sized):
|
|
def __init__(self, object: _AnyBuffer, offset: int = ..., size: int = ...) -> None: ...
|
|
def __add__(self, other: _AnyBuffer) -> str: ...
|
|
def __cmp__(self, other: _AnyBuffer) -> bool: ...
|
|
def __getitem__(self, key: Union[int, slice]) -> str: ...
|
|
def __getslice__(self, i: int, j: int) -> str: ...
|
|
def __len__(self) -> int: ...
|
|
def __mul__(self, x: int) -> str: ...
|
|
|
|
class BaseException(object):
|
|
args: Tuple[Any, ...]
|
|
if sys.version_info < (3,):
|
|
message: Any
|
|
if sys.version_info >= (3,):
|
|
__cause__: Optional[BaseException]
|
|
__context__: Optional[BaseException]
|
|
__suppress_context__: bool
|
|
__traceback__: Optional[TracebackType]
|
|
def __init__(self, *args: object) -> None: ...
|
|
if sys.version_info < (3,):
|
|
def __getitem__(self, i: int) -> Any: ...
|
|
def __getslice__(self, start: int, stop: int) -> Tuple[Any, ...]: ...
|
|
if sys.version_info >= (3,):
|
|
def with_traceback(self, tb: Optional[TracebackType]) -> BaseException: ...
|
|
|
|
class GeneratorExit(BaseException): ...
|
|
class KeyboardInterrupt(BaseException): ...
|
|
class SystemExit(BaseException):
|
|
code: int
|
|
class Exception(BaseException): ...
|
|
class StopIteration(Exception):
|
|
if sys.version_info >= (3,):
|
|
value: Any
|
|
if sys.version_info >= (3,):
|
|
_StandardError = Exception
|
|
class OSError(Exception):
|
|
errno: int
|
|
strerror: str
|
|
# filename, filename2 are actually Union[str, bytes, None]
|
|
filename: Any
|
|
filename2: Any
|
|
EnvironmentError = OSError
|
|
IOError = OSError
|
|
else:
|
|
class StandardError(Exception): ...
|
|
_StandardError = StandardError
|
|
class EnvironmentError(StandardError):
|
|
errno: int
|
|
strerror: str
|
|
# TODO can this be unicode?
|
|
filename: str
|
|
class OSError(EnvironmentError): ...
|
|
class IOError(EnvironmentError): ...
|
|
|
|
class ArithmeticError(_StandardError): ...
|
|
class AssertionError(_StandardError): ...
|
|
class AttributeError(_StandardError): ...
|
|
class BufferError(_StandardError): ...
|
|
class EOFError(_StandardError): ...
|
|
class ImportError(_StandardError):
|
|
if sys.version_info >= (3,):
|
|
name: str
|
|
path: str
|
|
class LookupError(_StandardError): ...
|
|
class MemoryError(_StandardError): ...
|
|
class NameError(_StandardError): ...
|
|
class ReferenceError(_StandardError): ...
|
|
class RuntimeError(_StandardError): ...
|
|
if sys.version_info >= (3, 5):
|
|
class StopAsyncIteration(Exception):
|
|
value: Any
|
|
class SyntaxError(_StandardError):
|
|
msg: str
|
|
lineno: int
|
|
offset: Optional[int]
|
|
text: Optional[str]
|
|
filename: str
|
|
class SystemError(_StandardError): ...
|
|
class TypeError(_StandardError): ...
|
|
class ValueError(_StandardError): ...
|
|
|
|
class FloatingPointError(ArithmeticError): ...
|
|
class OverflowError(ArithmeticError): ...
|
|
class ZeroDivisionError(ArithmeticError): ...
|
|
|
|
if sys.version_info >= (3, 6):
|
|
class ModuleNotFoundError(ImportError): ...
|
|
|
|
class IndexError(LookupError): ...
|
|
class KeyError(LookupError): ...
|
|
|
|
class UnboundLocalError(NameError): ...
|
|
|
|
class WindowsError(OSError):
|
|
winerror: int
|
|
if sys.version_info >= (3,):
|
|
class BlockingIOError(OSError):
|
|
characters_written: int
|
|
class ChildProcessError(OSError): ...
|
|
class ConnectionError(OSError): ...
|
|
class BrokenPipeError(ConnectionError): ...
|
|
class ConnectionAbortedError(ConnectionError): ...
|
|
class ConnectionRefusedError(ConnectionError): ...
|
|
class ConnectionResetError(ConnectionError): ...
|
|
class FileExistsError(OSError): ...
|
|
class FileNotFoundError(OSError): ...
|
|
class InterruptedError(OSError): ...
|
|
class IsADirectoryError(OSError): ...
|
|
class NotADirectoryError(OSError): ...
|
|
class PermissionError(OSError): ...
|
|
class ProcessLookupError(OSError): ...
|
|
class TimeoutError(OSError): ...
|
|
|
|
class NotImplementedError(RuntimeError): ...
|
|
if sys.version_info >= (3, 5):
|
|
class RecursionError(RuntimeError): ...
|
|
|
|
class IndentationError(SyntaxError): ...
|
|
class TabError(IndentationError): ...
|
|
|
|
class UnicodeError(ValueError): ...
|
|
class UnicodeDecodeError(UnicodeError):
|
|
encoding: str
|
|
object: bytes
|
|
start: int
|
|
end: int
|
|
reason: str
|
|
def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int,
|
|
__reason: str) -> None: ...
|
|
class UnicodeEncodeError(UnicodeError):
|
|
encoding: str
|
|
object: Text
|
|
start: int
|
|
end: int
|
|
reason: str
|
|
def __init__(self, __encoding: str, __object: Text, __start: int, __end: int,
|
|
__reason: str) -> None: ...
|
|
class UnicodeTranslateError(UnicodeError): ...
|
|
|
|
class Warning(Exception): ...
|
|
class UserWarning(Warning): ...
|
|
class DeprecationWarning(Warning): ...
|
|
class SyntaxWarning(Warning): ...
|
|
class RuntimeWarning(Warning): ...
|
|
class FutureWarning(Warning): ...
|
|
class PendingDeprecationWarning(Warning): ...
|
|
class ImportWarning(Warning): ...
|
|
class UnicodeWarning(Warning): ...
|
|
class BytesWarning(Warning): ...
|
|
if sys.version_info >= (3, 2):
|
|
class ResourceWarning(Warning): ...
|
|
|
|
if sys.version_info < (3,):
|
|
class file(BinaryIO):
|
|
@overload
|
|
def __init__(self, file: str, mode: str = ..., buffering: int = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, file: unicode, mode: str = ..., buffering: int = ...) -> None: ...
|
|
@overload
|
|
def __init__(self, file: int, mode: str = ..., buffering: int = ...) -> None: ...
|
|
def __iter__(self) -> Iterator[str]: ...
|
|
def next(self) -> str: ...
|
|
def read(self, n: int = ...) -> str: ...
|
|
def __enter__(self) -> BinaryIO: ...
|
|
def __exit__(self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ...) -> Optional[bool]: ...
|
|
def flush(self) -> None: ...
|
|
def fileno(self) -> int: ...
|
|
def isatty(self) -> bool: ...
|
|
def close(self) -> None: ...
|
|
|
|
def readable(self) -> bool: ...
|
|
def writable(self) -> bool: ...
|
|
def seekable(self) -> bool: ...
|
|
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 write(self, data: str) -> int: ...
|
|
def writelines(self, data: Iterable[str]) -> None: ...
|
|
def truncate(self, pos: Optional[int] = ...) -> int: ...
|