--- /dev/null
+# NB: __builtin__.pyi and builtins.pyi must remain consistent!\r
+# Stubs for builtins (Python 2.7)\r
+\r
+# True and False are deliberately omitted because they are keywords in\r
+# Python 3, and stub files conform to Python 3 syntax.\r
+\r
+from typing import (\r
+ TypeVar, Iterator, Iterable, NoReturn, overload,\r
+ Sequence, Mapping, Tuple, List, Any, Dict, Callable, Generic, Set,\r
+ AbstractSet, FrozenSet, Sized, Reversible, SupportsInt, SupportsFloat, SupportsAbs,\r
+ SupportsComplex, SupportsRound, IO, BinaryIO, Union, AnyStr, MutableSequence, MutableMapping,\r
+ MutableSet, ItemsView, KeysView, ValuesView, Optional, Container, Type\r
+)\r
+from abc import abstractmethod, ABCMeta\r
+\r
+_T = TypeVar('_T')\r
+_T_co = TypeVar('_T_co', covariant=True)\r
+_KT = TypeVar('_KT')\r
+_VT = TypeVar('_VT')\r
+_S = TypeVar('_S')\r
+_T1 = TypeVar('_T1')\r
+_T2 = TypeVar('_T2')\r
+_T3 = TypeVar('_T3')\r
+_T4 = TypeVar('_T4')\r
+_T5 = TypeVar('_T5')\r
+_TT = TypeVar('_TT', bound='type')\r
+\r
+class object:\r
+ __doc__ = ... # type: Optional[str]\r
+ __class__ = ... # type: type\r
+ __dict__ = ... # type: Dict[str, Any]\r
+ __slots__ = ... # type: Union[str, unicode, Iterable[Union[str, unicode]]]\r
+ __module__ = ... # type: str\r
+\r
+ def __init__(self) -> None: ...\r
+ def __new__(cls) -> Any: ...\r
+ def __setattr__(self, name: str, value: Any) -> None: ...\r
+ def __eq__(self, o: object) -> bool: ...\r
+ def __ne__(self, o: object) -> bool: ...\r
+ def __str__(self) -> str: ...\r
+ def __repr__(self) -> str: ...\r
+ def __hash__(self) -> int: ...\r
+ def __format__(self, format_spec: str) -> str: ...\r
+ def __getattribute__(self, name: str) -> Any: ...\r
+ def __delattr__(self, name: str) -> None: ...\r
+ def __sizeof__(self) -> int: ...\r
+ def __reduce__(self) -> tuple: ...\r
+ def __reduce_ex__(self, protocol: int) -> tuple: ...\r
+\r
+class staticmethod(object): # Special, only valid as a decorator.\r
+ __func__ = ... # type: function\r
+\r
+ def __init__(self, f: function) -> None: ...\r
+ def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...\r
+ def __get__(self, obj: _T, type: Optional[Type[_T]]=...) -> function: ...\r
+\r
+class classmethod(object): # Special, only valid as a decorator.\r
+ __func__ = ... # type: function\r
+\r
+ def __init__(self, f: function) -> None: ...\r
+ def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...\r
+ def __get__(self, obj: _T, type: Optional[Type[_T]]=...) -> function: ...\r
+\r
+class type(object):\r
+ __bases__ = ... # type: Tuple[type, ...]\r
+ __name__ = ... # type: str\r
+ __module__ = ... # type: str\r
+\r
+ @overload\r
+ def __init__(self, o: object) -> None: ...\r
+ @overload\r
+ def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...\r
+ # TODO: __new__ may have to be special and not a static method.\r
+ @overload\r
+ def __new__(cls, o: object) -> type: ...\r
+ @overload\r
+ def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...\r
+ def __call__(self, *args: Any, **kwds: Any) -> Any: ...\r
+\r
+ # Only new-style classes\r
+ __mro__ = ... # type: Tuple[type, ...]\r
+ # Note: the documentation doesnt specify what the return type is, the standard\r
+ # implementation seems to be returning a list.\r
+ def mro(self) -> List[type]: ...\r
+ def __subclasses__(self: _TT) -> List[_TT]: ...\r
+ def __instancecheck__(self, instance: Any) -> bool: ...\r
+ def __subclasscheck__(self, subclass: type) -> bool: ...\r
+\r
+class int:\r
+ @overload\r
+ def __init__(self, x: SupportsInt = ...) -> None: ...\r
+ @overload\r
+ def __init__(self, x: Union[str, unicode, bytearray], base: int = ...) -> None: ...\r
+\r
+ def bit_length(self) -> int: ...\r
+\r
+ def __add__(self, x: int) -> int: ...\r
+ def __sub__(self, x: int) -> int: ...\r
+ def __mul__(self, x: int) -> int: ...\r
+ def __floordiv__(self, x: int) -> int: ...\r
+ def __div__(self, x: int) -> int: ...\r
+ def __truediv__(self, x: int) -> float: ...\r
+ def __mod__(self, x: int) -> int: ...\r
+ def __divmod__(self, x: int) -> Tuple[int, int]: ...\r
+ def __radd__(self, x: int) -> int: ...\r
+ def __rsub__(self, x: int) -> int: ...\r
+ def __rmul__(self, x: int) -> int: ...\r
+ def __rfloordiv__(self, x: int) -> int: ...\r
+ def __rdiv__(self, x: int) -> int: ...\r
+ def __rtruediv__(self, x: int) -> float: ...\r
+ def __rmod__(self, x: int) -> int: ...\r
+ def __rdivmod__(self, x: int) -> Tuple[int, int]: ...\r
+ def __pow__(self, x: int) -> Any: ... # Return type can be int or float, depending on x.\r
+ def __rpow__(self, x: int) -> Any: ...\r
+ def __and__(self, n: int) -> int: ...\r
+ def __or__(self, n: int) -> int: ...\r
+ def __xor__(self, n: int) -> int: ...\r
+ def __lshift__(self, n: int) -> int: ...\r
+ def __rshift__(self, n: int) -> int: ...\r
+ def __rand__(self, n: int) -> int: ...\r
+ def __ror__(self, n: int) -> int: ...\r
+ def __rxor__(self, n: int) -> int: ...\r
+ def __rlshift__(self, n: int) -> int: ...\r
+ def __rrshift__(self, n: int) -> int: ...\r
+ def __neg__(self) -> int: ...\r
+ def __pos__(self) -> int: ...\r
+ def __invert__(self) -> int: ...\r
+\r
+ def __eq__(self, x: object) -> bool: ...\r
+ def __ne__(self, x: object) -> bool: ...\r
+ def __lt__(self, x: int) -> bool: ...\r
+ def __le__(self, x: int) -> bool: ...\r
+ def __gt__(self, x: int) -> bool: ...\r
+ def __ge__(self, x: int) -> bool: ...\r
+\r
+ def __str__(self) -> str: ...\r
+ def __float__(self) -> float: ...\r
+ def __int__(self) -> int: ...\r
+ def __abs__(self) -> int: ...\r
+ def __hash__(self) -> int: ...\r
+ def __nonzero__(self) -> bool: ...\r
+\r
+class float:\r
+ def __init__(self, x: Union[SupportsFloat, str, unicode, bytearray] = ...) -> None: ...\r
+ def as_integer_ratio(self) -> Tuple[int, int]: ...\r
+ def hex(self) -> str: ...\r
+ def is_integer(self) -> bool: ...\r
+ @classmethod\r
+ def fromhex(cls, s: str) -> float: ...\r
+\r
+ def __add__(self, x: float) -> float: ...\r
+ def __sub__(self, x: float) -> float: ...\r
+ def __mul__(self, x: float) -> float: ...\r
+ def __floordiv__(self, x: float) -> float: ...\r
+ def __div__(self, x: float) -> float: ...\r
+ def __truediv__(self, x: float) -> float: ...\r
+ def __mod__(self, x: float) -> float: ...\r
+ def __divmod__(self, x: float) -> Tuple[float, float]: ...\r
+ def __pow__(self, x: float) -> float: ...\r
+ def __radd__(self, x: float) -> float: ...\r
+ def __rsub__(self, x: float) -> float: ...\r
+ def __rmul__(self, x: float) -> float: ...\r
+ def __rfloordiv__(self, x: float) -> float: ...\r
+ def __rdiv__(self, x: float) -> float: ...\r
+ def __rtruediv__(self, x: float) -> float: ...\r
+ def __rmod__(self, x: float) -> float: ...\r
+ def __rdivmod__(self, x: float) -> Tuple[float, float]: ...\r
+ def __rpow__(self, x: float) -> float: ...\r
+\r
+ def __eq__(self, x: object) -> bool: ...\r
+ def __ne__(self, x: object) -> bool: ...\r
+ def __lt__(self, x: float) -> bool: ...\r
+ def __le__(self, x: float) -> bool: ...\r
+ def __gt__(self, x: float) -> bool: ...\r
+ def __ge__(self, x: float) -> bool: ...\r
+ def __neg__(self) -> float: ...\r
+ def __pos__(self) -> float: ...\r
+\r
+ def __str__(self) -> str: ...\r
+ def __int__(self) -> int: ...\r
+ def __float__(self) -> float: ...\r
+ def __abs__(self) -> float: ...\r
+ def __hash__(self) -> int: ...\r
+ def __nonzero__(self) -> bool: ...\r
+\r
+class complex:\r
+ @overload\r
+ def __init__(self, re: float = ..., im: float = ...) -> None: ...\r
+ @overload\r
+ def __init__(self, s: str) -> None: ...\r
+ @overload\r
+ def __init__(self, s: SupportsComplex) -> None: ...\r
+\r
+ @property\r
+ def real(self) -> float: ...\r
+ @property\r
+ def imag(self) -> float: ...\r
+\r
+ def conjugate(self) -> complex: ...\r
+\r
+ def __add__(self, x: complex) -> complex: ...\r
+ def __sub__(self, x: complex) -> complex: ...\r
+ def __mul__(self, x: complex) -> complex: ...\r
+ def __pow__(self, x: complex) -> complex: ...\r
+ def __div__(self, x: complex) -> complex: ...\r
+ def __truediv__(self, x: complex) -> complex: ...\r
+ def __radd__(self, x: complex) -> complex: ...\r
+ def __rsub__(self, x: complex) -> complex: ...\r
+ def __rmul__(self, x: complex) -> complex: ...\r
+ def __rpow__(self, x: complex) -> complex: ...\r
+ def __rdiv__(self, x: complex) -> complex: ...\r
+ def __rtruediv__(self, x: complex) -> complex: ...\r
+\r
+ def __eq__(self, x: object) -> bool: ...\r
+ def __ne__(self, x: object) -> bool: ...\r
+ def __neg__(self) -> complex: ...\r
+ def __pos__(self) -> complex: ...\r
+\r
+ def __complex__(self) -> complex: ...\r
+ def __str__(self) -> str: ...\r
+ def __abs__(self) -> float: ...\r
+ def __hash__(self) -> int: ...\r
+ def __nonzero__(self) -> bool: ...\r
+\r
+class super(object):\r
+ @overload\r
+ def __init__(self, t: Any, obj: Any) -> None: ...\r
+ @overload\r
+ def __init__(self, t: Any) -> None: ...\r
+\r
+class basestring(metaclass=ABCMeta): ...\r
+\r
+class unicode(basestring, Sequence[unicode]):\r
+ @overload\r
+ def __init__(self) -> None: ...\r
+ @overload\r
+ def __init__(self, o: object) -> None: ...\r
+ @overload\r
+ def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ...\r
+ def capitalize(self) -> unicode: ...\r
+ def center(self, width: int, fillchar: unicode = ...) -> unicode: ...\r
+ def count(self, x: unicode) -> int: ...\r
+ def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...\r
+ def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...\r
+ def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = ...,\r
+ end: int = ...) -> bool: ...\r
+ def expandtabs(self, tabsize: int = ...) -> unicode: ...\r
+ def find(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...\r
+ def format(self, *args: Any, **kwargs: Any) -> unicode: ...\r
+ def format_map(self, map: Mapping[unicode, Any]) -> unicode: ...\r
+ def index(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...\r
+ def isalnum(self) -> bool: ...\r
+ def isalpha(self) -> bool: ...\r
+ def isdecimal(self) -> bool: ...\r
+ def isdigit(self) -> bool: ...\r
+ def isidentifier(self) -> bool: ...\r
+ def islower(self) -> bool: ...\r
+ def isnumeric(self) -> bool: ...\r
+ def isprintable(self) -> bool: ...\r
+ def isspace(self) -> bool: ...\r
+ def istitle(self) -> bool: ...\r
+ def isupper(self) -> bool: ...\r
+ def join(self, iterable: Iterable[unicode]) -> unicode: ...\r
+ def ljust(self, width: int, fillchar: unicode = ...) -> unicode: ...\r
+ def lower(self) -> unicode: ...\r
+ def lstrip(self, chars: unicode = ...) -> unicode: ...\r
+ def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...\r
+ def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ...\r
+ def rfind(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...\r
+ def rindex(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...\r
+ def rjust(self, width: int, fillchar: unicode = ...) -> unicode: ...\r
+ def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...\r
+ def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...\r
+ def rstrip(self, chars: unicode = ...) -> unicode: ...\r
+ def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...\r
+ def splitlines(self, keepends: bool = ...) -> List[unicode]: ...\r
+ def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = ...,\r
+ end: int = ...) -> bool: ...\r
+ def strip(self, chars: unicode = ...) -> unicode: ...\r
+ def swapcase(self) -> unicode: ...\r
+ def title(self) -> unicode: ...\r
+ def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ...\r
+ def upper(self) -> unicode: ...\r
+ def zfill(self, width: int) -> unicode: ...\r
+\r
+ @overload\r
+ def __getitem__(self, i: int) -> unicode: ...\r
+ @overload\r
+ def __getitem__(self, s: slice) -> unicode: ...\r
+ def __getslice__(self, start: int, stop: int) -> unicode: ...\r
+ def __add__(self, s: unicode) -> unicode: ...\r
+ def __mul__(self, n: int) -> unicode: ...\r
+ def __rmul__(self, n: int) -> unicode: ...\r
+ def __mod__(self, x: Any) -> unicode: ...\r
+ def __eq__(self, x: object) -> bool: ...\r
+ def __ne__(self, x: object) -> bool: ...\r
+ def __lt__(self, x: unicode) -> bool: ...\r
+ def __le__(self, x: unicode) -> bool: ...\r
+ def __gt__(self, x: unicode) -> bool: ...\r
+ def __ge__(self, x: unicode) -> bool: ...\r
+\r
+ def __len__(self) -> int: ...\r
+ def __contains__(self, s: object) -> bool: ...\r
+ def __iter__(self) -> Iterator[unicode]: ...\r
+ def __str__(self) -> str: ...\r
+ def __repr__(self) -> str: ...\r
+ def __int__(self) -> int: ...\r
+ def __float__(self) -> float: ...\r
+ def __hash__(self) -> int: ...\r
+\r
+class str(basestring, Sequence[str]):\r
+ def __init__(self, object: object = ...) -> None: ...\r
+ def capitalize(self) -> str: ...\r
+ def center(self, width: int, fillchar: str = ...) -> str: ...\r
+ def count(self, x: unicode, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...\r
+ def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...\r
+ def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...\r
+ def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...\r
+ def expandtabs(self, tabsize: int = ...) -> str: ...\r
+ def find(self, sub: unicode, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...\r
+ def format(self, *args: Any, **kwargs: Any) -> str: ...\r
+ def index(self, sub: unicode, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...\r
+ def isalnum(self) -> bool: ...\r
+ def isalpha(self) -> bool: ...\r
+ def isdigit(self) -> bool: ...\r
+ def islower(self) -> bool: ...\r
+ def isspace(self) -> bool: ...\r
+ def istitle(self) -> bool: ...\r
+ def isupper(self) -> bool: ...\r
+ def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ...\r
+ def ljust(self, width: int, fillchar: str = ...) -> str: ...\r
+ def lower(self) -> str: ...\r
+ @overload\r
+ def lstrip(self, chars: str = ...) -> str: ...\r
+ @overload\r
+ def lstrip(self, chars: unicode) -> unicode: ...\r
+ @overload\r
+ def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...\r
+ @overload\r
+ def partition(self, sep: str) -> Tuple[str, str, str]: ...\r
+ @overload\r
+ def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...\r
+ def replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ...\r
+ def rfind(self, sub: unicode, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...\r
+ def rindex(self, sub: unicode, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...\r
+ def rjust(self, width: int, fillchar: str = ...) -> str: ...\r
+ @overload\r
+ def rpartition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...\r
+ @overload\r
+ def rpartition(self, sep: str) -> Tuple[str, str, str]: ...\r
+ @overload\r
+ def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...\r
+ @overload\r
+ def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...\r
+ @overload\r
+ def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...\r
+ @overload\r
+ def rstrip(self, chars: str = ...) -> str: ...\r
+ @overload\r
+ def rstrip(self, chars: unicode) -> unicode: ...\r
+ @overload\r
+ def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...\r
+ @overload\r
+ def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...\r
+ def splitlines(self, keepends: bool = ...) -> List[str]: ...\r
+ def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...\r
+ @overload\r
+ def strip(self, chars: str = ...) -> str: ...\r
+ @overload\r
+ def strip(self, chars: unicode) -> unicode: ...\r
+ def swapcase(self) -> str: ...\r
+ def title(self) -> str: ...\r
+ def translate(self, table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ...\r
+ def upper(self) -> str: ...\r
+ def zfill(self, width: int) -> str: ...\r
+\r
+ def __len__(self) -> int: ...\r
+ def __iter__(self) -> Iterator[str]: ...\r
+ def __str__(self) -> str: ...\r
+ def __repr__(self) -> str: ...\r
+ def __int__(self) -> int: ...\r
+ def __float__(self) -> float: ...\r
+ def __hash__(self) -> int: ...\r
+ @overload\r
+ def __getitem__(self, i: int) -> str: ...\r
+ @overload\r
+ def __getitem__(self, s: slice) -> str: ...\r
+ def __getslice__(self, start: int, stop: int) -> str: ...\r
+ def __add__(self, s: AnyStr) -> AnyStr: ...\r
+ def __mul__(self, n: int) -> str: ...\r
+ def __rmul__(self, n: int) -> str: ...\r
+ def __contains__(self, o: object) -> bool: ...\r
+ def __eq__(self, x: object) -> bool: ...\r
+ def __ne__(self, x: object) -> bool: ...\r
+ def __lt__(self, x: unicode) -> bool: ...\r
+ def __le__(self, x: unicode) -> bool: ...\r
+ def __gt__(self, x: unicode) -> bool: ...\r
+ def __ge__(self, x: unicode) -> bool: ...\r
+ def __mod__(self, x: Any) -> str: ...\r
+\r
+class bytearray(MutableSequence[int]):\r
+ @overload\r
+ def __init__(self) -> None: ...\r
+ @overload\r
+ def __init__(self, x: Union[Iterable[int], str]) -> None: ...\r
+ @overload\r
+ def __init__(self, x: unicode, encoding: unicode,\r
+ errors: unicode = ...) -> None: ...\r
+ @overload\r
+ def __init__(self, length: int) -> None: ...\r
+ def capitalize(self) -> bytearray: ...\r
+ def center(self, width: int, fillchar: str = ...) -> bytearray: ...\r
+ def count(self, x: str) -> int: ...\r
+ def decode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...\r
+ def endswith(self, suffix: Union[str, Tuple[str, ...]]) -> bool: ...\r
+ def expandtabs(self, tabsize: int = ...) -> bytearray: ...\r
+ def find(self, sub: str, start: int = ..., end: int = ...) -> int: ...\r
+ def index(self, sub: str, start: int = ..., end: int = ...) -> int: ...\r
+ def insert(self, index: int, object: int) -> None: ...\r
+ def isalnum(self) -> bool: ...\r
+ def isalpha(self) -> bool: ...\r
+ def isdigit(self) -> bool: ...\r
+ def islower(self) -> bool: ...\r
+ def isspace(self) -> bool: ...\r
+ def istitle(self) -> bool: ...\r
+ def isupper(self) -> bool: ...\r
+ def join(self, iterable: Iterable[str]) -> bytearray: ...\r
+ def ljust(self, width: int, fillchar: str = ...) -> bytearray: ...\r
+ def lower(self) -> bytearray: ...\r
+ def lstrip(self, chars: str = ...) -> bytearray: ...\r
+ def partition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...\r
+ def replace(self, old: str, new: str, count: int = ...) -> bytearray: ...\r
+ def rfind(self, sub: str, start: int = ..., end: int = ...) -> int: ...\r
+ def rindex(self, sub: str, start: int = ..., end: int = ...) -> int: ...\r
+ def rjust(self, width: int, fillchar: str = ...) -> bytearray: ...\r
+ def rpartition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...\r
+ def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...\r
+ def rstrip(self, chars: str = ...) -> bytearray: ...\r
+ def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...\r
+ def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...\r
+ def startswith(self, prefix: Union[str, Tuple[str, ...]]) -> bool: ...\r
+ def strip(self, chars: str = ...) -> bytearray: ...\r
+ def swapcase(self) -> bytearray: ...\r
+ def title(self) -> bytearray: ...\r
+ def translate(self, table: str) -> bytearray: ...\r
+ def upper(self) -> bytearray: ...\r
+ def zfill(self, width: int) -> bytearray: ...\r
+ @staticmethod\r
+ def fromhex(x: str) -> bytearray: ...\r
+\r
+ def __len__(self) -> int: ...\r
+ def __iter__(self) -> Iterator[int]: ...\r
+ def __str__(self) -> str: ...\r
+ def __repr__(self) -> str: ...\r
+ def __int__(self) -> int: ...\r
+ def __float__(self) -> float: ...\r
+ def __hash__(self) -> int: ...\r
+ @overload\r
+ def __getitem__(self, i: int) -> int: ...\r
+ @overload\r
+ def __getitem__(self, s: slice) -> bytearray: ...\r
+ def __getslice__(self, start: int, stop: int) -> bytearray: ...\r
+ @overload\r
+ def __setitem__(self, i: int, x: int) -> None: ...\r
+ @overload\r
+ def __setitem__(self, s: slice, x: Union[Iterable[int], str]) -> None: ...\r
+ def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ...\r
+ def __delitem__(self, i: Union[int, slice]) -> None: ...\r
+ def __delslice__(self, start: int, stop: int) -> None: ...\r
+ def __add__(self, s: str) -> bytearray: ...\r
+ def __mul__(self, n: int) -> bytearray: ...\r
+ def __contains__(self, o: object) -> bool: ...\r
+ def __eq__(self, x: object) -> bool: ...\r
+ def __ne__(self, x: object) -> bool: ...\r
+ def __lt__(self, x: str) -> bool: ...\r
+ def __le__(self, x: str) -> bool: ...\r
+ def __gt__(self, x: str) -> bool: ...\r
+ def __ge__(self, x: str) -> bool: ...\r
+\r
+class bool(int):\r
+ def __init__(self, o: object = ...) -> None: ...\r
+ @overload # type: ignore\r
+ def __and__(self, x: bool) -> bool: ...\r
+ @overload # type: ignore\r
+ def __and__(self, x: int) -> int: ...\r
+ @overload # type: ignore\r
+ def __or__(self, x: bool) -> bool: ...\r
+ @overload # type: ignore\r
+ def __or__(self, x: int) -> int: ...\r
+ @overload # type: ignore\r
+ def __xor__(self, x: bool) -> bool: ...\r
+ @overload # type: ignore\r
+ def __xor__(self, x: int) -> int: ...\r
+ @overload # type: ignore\r
+ def __rand__(self, x: bool) -> bool: ...\r
+ @overload # type: ignore\r
+ def __rand__(self, x: int) -> int: ...\r
+ @overload # type: ignore\r
+ def __ror__(self, x: bool) -> bool: ...\r
+ @overload # type: ignore\r
+ def __ror__(self, x: int) -> int: ...\r
+ @overload # type: ignore\r
+ def __rxor__(self, x: bool) -> bool: ...\r
+ @overload # type: ignore\r
+ def __rxor__(self, x: int) -> int: ...\r
+\r
+class slice(object):\r
+ start = ... # type: Optional[int]\r
+ step = ... # type: Optional[int]\r
+ stop = ... # type: Optional[int]\r
+ @overload\r
+ def __init__(self, stop: Optional[int]) -> None: ...\r
+ @overload\r
+ def __init__(self, start: Optional[int], stop: Optional[int], step: Optional[int] = ...) -> None: ...\r
+ def indices(self, len: int) -> Tuple[int, int, int]: ...\r
+\r
+class tuple(Sequence[_T_co], Generic[_T_co]):\r
+ def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ...\r
+ def __len__(self) -> int: ...\r
+ def __contains__(self, x: object) -> bool: ...\r
+ @overload\r
+ def __getitem__(self, x: int) -> _T_co: ...\r
+ @overload\r
+ def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...\r
+ def __iter__(self) -> Iterator[_T_co]: ...\r
+ def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...\r
+ def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...\r
+ def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...\r
+ def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...\r
+ def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...\r
+ def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...\r
+ def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...\r
+ def count(self, x: Any) -> int: ...\r
+ def index(self, x: Any) -> int: ...\r
+\r
+class function:\r
+ # TODO name of the class (corresponds to Python 'function' class)\r
+ __name__ = ... # type: str\r
+ __module__ = ... # type: str\r
+\r
+class list(MutableSequence[_T], Generic[_T]):\r
+ @overload\r
+ def __init__(self) -> None: ...\r
+ @overload\r
+ def __init__(self, iterable: Iterable[_T]) -> None: ...\r
+ def append(self, object: _T) -> None: ...\r
+ def extend(self, iterable: Iterable[_T]) -> None: ...\r
+ def pop(self, index: int = ...) -> _T: ...\r
+ def index(self, object: _T, start: int = ..., stop: int = ...) -> int: ...\r
+ def count(self, object: _T) -> int: ...\r
+ def insert(self, index: int, object: _T) -> None: ...\r
+ def remove(self, object: _T) -> None: ...\r
+ def reverse(self) -> None: ...\r
+ def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ...\r
+\r
+ def __len__(self) -> int: ...\r
+ def __iter__(self) -> Iterator[_T]: ...\r
+ def __str__(self) -> str: ...\r
+ def __hash__(self) -> int: ...\r
+ @overload\r
+ def __getitem__(self, i: int) -> _T: ...\r
+ @overload\r
+ def __getitem__(self, s: slice) -> List[_T]: ...\r
+ def __getslice__(self, start: int, stop: int) -> List[_T]: ...\r
+ @overload\r
+ def __setitem__(self, i: int, o: _T) -> None: ...\r
+ @overload\r
+ def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...\r
+ def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ...\r
+ def __delitem__(self, i: Union[int, slice]) -> None: ...\r
+ def __delslice__(self, start: int, stop: int) -> None: ...\r
+ def __add__(self, x: List[_T]) -> List[_T]: ...\r
+ def __iadd__(self, x: Iterable[_T]) -> List[_T]: ...\r
+ def __mul__(self, n: int) -> List[_T]: ...\r
+ def __rmul__(self, n: int) -> List[_T]: ...\r
+ def __contains__(self, o: object) -> bool: ...\r
+ def __reversed__(self) -> Iterator[_T]: ...\r
+ def __gt__(self, x: List[_T]) -> bool: ...\r
+ def __ge__(self, x: List[_T]) -> bool: ...\r
+ def __lt__(self, x: List[_T]) -> bool: ...\r
+ def __le__(self, x: List[_T]) -> bool: ...\r
+\r
+class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):\r
+ # NOTE: Keyword arguments are special. If they are used, _KT must include\r
+ # str, but we have no way of enforcing it here.\r
+ @overload\r
+ def __init__(self, **kwargs: _VT) -> None: ...\r
+ @overload\r
+ def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...\r
+ @overload\r
+ def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...\r
+\r
+ def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ...\r
+\r
+ def has_key(self, k: _KT) -> bool: ...\r
+ def clear(self) -> None: ...\r
+ def copy(self) -> Dict[_KT, _VT]: ...\r
+ def popitem(self) -> Tuple[_KT, _VT]: ...\r
+ def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...\r
+ @overload\r
+ def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...\r
+ @overload\r
+ def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...\r
+ @overload\r
+ def update(self, **kwargs: _VT) -> None: ...\r
+ def iterkeys(self) -> Iterator[_KT]: ...\r
+ def itervalues(self) -> Iterator[_VT]: ...\r
+ def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...\r
+ def viewkeys(self) -> KeysView[_KT]: ...\r
+ def viewvalues(self) -> ValuesView[_VT]: ...\r
+ def viewitems(self) -> ItemsView[_KT, _VT]: ...\r
+ @staticmethod\r
+ @overload\r
+ def fromkeys(seq: Sequence[_T]) -> Dict[_T, Any]: ... # TODO: Actually a class method (mypy/issues#328)\r
+ @staticmethod\r
+ @overload\r
+ def fromkeys(seq: Sequence[_T], value: _S) -> Dict[_T, _S]: ...\r
+ def __len__(self) -> int: ...\r
+ def __getitem__(self, k: _KT) -> _VT: ...\r
+ def __setitem__(self, k: _KT, v: _VT) -> None: ...\r
+ def __delitem__(self, v: _KT) -> None: ...\r
+ def __iter__(self) -> Iterator[_KT]: ...\r
+ def __str__(self) -> str: ...\r
+\r
+class set(MutableSet[_T], Generic[_T]):\r
+ def __init__(self, iterable: Iterable[_T] = ...) -> None: ...\r
+ def add(self, element: _T) -> None: ...\r
+ def clear(self) -> None: ...\r
+ def copy(self) -> Set[_T]: ...\r
+ def difference(self, *s: Iterable[Any]) -> Set[_T]: ...\r
+ def difference_update(self, *s: Iterable[Any]) -> None: ...\r
+ def discard(self, element: _T) -> None: ...\r
+ def intersection(self, *s: Iterable[Any]) -> Set[_T]: ...\r
+ def intersection_update(self, *s: Iterable[Any]) -> None: ...\r
+ def isdisjoint(self, s: Iterable[object]) -> bool: ...\r
+ def issubset(self, s: Iterable[object]) -> bool: ...\r
+ def issuperset(self, s: Iterable[object]) -> bool: ...\r
+ def pop(self) -> _T: ...\r
+ def remove(self, element: _T) -> None: ...\r
+ def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ...\r
+ def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...\r
+ def union(self, *s: Iterable[_T]) -> Set[_T]: ...\r
+ def update(self, *s: Iterable[_T]) -> None: ...\r
+ def __len__(self) -> int: ...\r
+ def __contains__(self, o: object) -> bool: ...\r
+ def __iter__(self) -> Iterator[_T]: ...\r
+ def __str__(self) -> str: ...\r
+ def __and__(self, s: AbstractSet[object]) -> Set[_T]: ...\r
+ def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ...\r
+ def __or__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...\r
+ def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...\r
+ def __sub__(self, s: AbstractSet[object]) -> Set[_T]: ...\r
+ def __isub__(self, s: AbstractSet[object]) -> Set[_T]: ...\r
+ def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...\r
+ def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...\r
+ def __le__(self, s: AbstractSet[object]) -> bool: ...\r
+ def __lt__(self, s: AbstractSet[object]) -> bool: ...\r
+ def __ge__(self, s: AbstractSet[object]) -> bool: ...\r
+ def __gt__(self, s: AbstractSet[object]) -> bool: ...\r
+\r
+class frozenset(AbstractSet[_T], Generic[_T]):\r
+ @overload\r
+ def __init__(self) -> None: ...\r
+ @overload\r
+ def __init__(self, iterable: Iterable[_T]) -> None: ...\r
+ def copy(self) -> FrozenSet[_T]: ...\r
+ def difference(self, *s: Iterable[object]) -> FrozenSet[_T]: ...\r
+ def intersection(self, *s: Iterable[object]) -> FrozenSet[_T]: ...\r
+ def isdisjoint(self, s: Iterable[_T]) -> bool: ...\r
+ def issubset(self, s: Iterable[object]) -> bool: ...\r
+ def issuperset(self, s: Iterable[object]) -> bool: ...\r
+ def symmetric_difference(self, s: Iterable[_T]) -> FrozenSet[_T]: ...\r
+ def union(self, *s: Iterable[_T]) -> FrozenSet[_T]: ...\r
+ def __len__(self) -> int: ...\r
+ def __contains__(self, o: object) -> bool: ...\r
+ def __iter__(self) -> Iterator[_T]: ...\r
+ def __str__(self) -> str: ...\r
+ def __and__(self, s: AbstractSet[_T]) -> FrozenSet[_T]: ...\r
+ def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T, _S]]: ...\r
+ def __sub__(self, s: AbstractSet[_T]) -> FrozenSet[_T]: ...\r
+ def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T, _S]]: ...\r
+ def __le__(self, s: AbstractSet[object]) -> bool: ...\r
+ def __lt__(self, s: AbstractSet[object]) -> bool: ...\r
+ def __ge__(self, s: AbstractSet[object]) -> bool: ...\r
+ def __gt__(self, s: AbstractSet[object]) -> bool: ...\r
+\r
+class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):\r
+ def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ...\r
+ def __iter__(self) -> Iterator[Tuple[int, _T]]: ...\r
+ def next(self) -> Tuple[int, _T]: ...\r
+ # TODO __getattribute__\r
+\r
+class xrange(Sized, Iterable[int], Reversible[int]):\r
+ @overload\r
+ def __init__(self, stop: int) -> None: ...\r
+ @overload\r
+ def __init__(self, start: int, stop: int, step: int = ...) -> None: ...\r
+ def __len__(self) -> int: ...\r
+ def __iter__(self) -> Iterator[int]: ...\r
+ def __getitem__(self, i: int) -> int: ...\r
+ def __reversed__(self) -> Iterator[int]: ...\r
+\r
+class property(object):\r
+ def __init__(self, fget: Optional[Callable[[Any], Any]] = ...,\r
+ fset: Optional[Callable[[Any, Any], None]] = ...,\r
+ fdel: Optional[Callable[[Any], None]] = ..., doc: Optional[str] = ...) -> None: ...\r
+ def getter(self, fget: Callable[[Any], Any]) -> property: ...\r
+ def setter(self, fset: Callable[[Any, Any], None]) -> property: ...\r
+ def deleter(self, fdel: Callable[[Any], None]) -> property: ...\r
+ def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ...\r
+ def __set__(self, obj: Any, value: Any) -> None: ...\r
+ def __delete__(self, obj: Any) -> None: ...\r
+ def fget(self) -> Any: ...\r
+ def fset(self, value: Any) -> None: ...\r
+ def fdel(self) -> None: ...\r
+\r
+long = int\r
+bytes = str\r
+\r
+NotImplemented = ... # type: Any\r
+\r
+def abs(n: SupportsAbs[_T]) -> _T: ...\r
+def all(i: Iterable[object]) -> bool: ...\r
+def any(i: Iterable[object]) -> bool: ...\r
+def bin(number: int) -> str: ...\r
+def callable(o: object) -> bool: ...\r
+def chr(code: int) -> str: ...\r
+def compile(source: Any, filename: unicode, mode: str, flags: int = ...,\r
+ dont_inherit: int = ...) -> Any: ...\r
+def delattr(o: Any, name: unicode) -> None: ...\r
+def dir(o: object = ...) -> List[str]: ...\r
+@overload\r
+def divmod(a: int, b: int) -> Tuple[int, int]: ...\r
+@overload\r
+def divmod(a: float, b: float) -> Tuple[float, float]: ...\r
+def exit(code: Any = ...) -> NoReturn: ...\r
+@overload\r
+def filter(function: None,\r
+ iterable: Iterable[Optional[_T]]) -> List[_T]: ...\r
+@overload\r
+def filter(function: Callable[[_T], Any],\r
+ iterable: Iterable[_T]) -> List[_T]: ...\r
+def format(o: object, format_spec: str = ...) -> str: ... # TODO unicode\r
+def getattr(o: Any, name: unicode, default: Optional[Any] = ...) -> Any: ...\r
+def hasattr(o: Any, name: unicode) -> bool: ...\r
+def hash(o: object) -> int: ...\r
+def hex(i: int) -> str: ... # TODO __index__\r
+def id(o: object) -> int: ...\r
+def input(prompt: Any = ...) -> Any: ...\r
+def intern(string: str) -> str: ...\r
+@overload\r
+def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...\r
+@overload\r
+def iter(function: Callable[[], _T], sentinel: _T) -> Iterator[_T]: ...\r
+def isinstance(o: object, t: Union[type, Tuple[Union[type, Tuple], ...]]) -> bool: ...\r
+def issubclass(cls: type, classinfo: Union[type, Tuple[Union[type, Tuple], ...]]) -> bool: ...\r
+def len(o: Sized) -> int: ...\r
+@overload\r
+def map(func: None, iter1: Iterable[_T1]) -> List[_T1]: ...\r
+@overload\r
+def map(func: None,\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...\r
+@overload\r
+def map(func: None,\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2],\r
+ iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...\r
+@overload\r
+def map(func: None,\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2],\r
+ iter3: Iterable[_T3],\r
+ iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...\r
+@overload\r
+def map(func: None,\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2],\r
+ iter3: Iterable[_T3],\r
+ iter4: Iterable[_T4],\r
+ iter5: Iterable[_T5]) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...\r
+@overload\r
+def map(func: None,\r
+ iter1: Iterable[Any],\r
+ iter2: Iterable[Any],\r
+ iter3: Iterable[Any],\r
+ iter4: Iterable[Any],\r
+ iter5: Iterable[Any],\r
+ iter6: Iterable[Any],\r
+ *iterables: Iterable[Any]) -> List[Tuple[Any, ...]]: ...\r
+@overload\r
+def map(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> List[_S]: ...\r
+@overload\r
+def map(func: Callable[[_T1, _T2], _S],\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2]) -> List[_S]: ...\r
+@overload\r
+def map(func: Callable[[_T1, _T2, _T3], _S],\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2],\r
+ iter3: Iterable[_T3]) -> List[_S]: ...\r
+@overload\r
+def map(func: Callable[[_T1, _T2, _T3, _T4], _S],\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2],\r
+ iter3: Iterable[_T3],\r
+ iter4: Iterable[_T4]) -> List[_S]: ...\r
+@overload\r
+def map(func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],\r
+ iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2],\r
+ iter3: Iterable[_T3],\r
+ iter4: Iterable[_T4],\r
+ iter5: Iterable[_T5]) -> List[_S]: ...\r
+@overload\r
+def map(func: Callable[..., _S],\r
+ iter1: Iterable[Any],\r
+ iter2: Iterable[Any],\r
+ iter3: Iterable[Any],\r
+ iter4: Iterable[Any],\r
+ iter5: Iterable[Any],\r
+ iter6: Iterable[Any],\r
+ *iterables: Iterable[Any]) -> List[_S]: ...\r
+@overload\r
+def max(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...\r
+@overload\r
+def max(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...\r
+@overload\r
+def min(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...\r
+@overload\r
+def min(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...\r
+@overload\r
+def next(i: Iterator[_T]) -> _T: ...\r
+@overload\r
+def next(i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...\r
+def oct(i: int) -> str: ... # TODO __index__\r
+@overload\r
+def open(file: str, mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...\r
+@overload\r
+def open(file: unicode, mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...\r
+@overload\r
+def open(file: int, mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...\r
+def ord(c: unicode) -> int: ...\r
+# This is only available after from __future__ import print_function.\r
+def print(*values: Any, sep: unicode = ..., end: unicode = ...,\r
+ file: IO[Any] = ...) -> None: ...\r
+@overload\r
+def pow(x: int, y: int) -> Any: ... # The return type can be int or float, depending on y.\r
+@overload\r
+def pow(x: int, y: int, z: int) -> Any: ...\r
+@overload\r
+def pow(x: float, y: float) -> float: ...\r
+@overload\r
+def pow(x: float, y: float, z: float) -> float: ...\r
+def quit(code: int = ...) -> None: ...\r
+def range(x: int, y: int = ..., step: int = ...) -> List[int]: ...\r
+def raw_input(prompt: Any = ...) -> str: ...\r
+\r
+@overload\r
+def reduce(function: Callable[[_T, _S], _T], iterable: Iterable[_S], initializer: _T) -> _T: ...\r
+@overload\r
+def reduce(function: Callable[[_T, _T], _T], iterable: Iterable[_T]) -> _T: ...\r
+\r
+def reload(module: Any) -> Any: ...\r
+@overload\r
+def reversed(object: Sequence[_T]) -> Iterator[_T]: ...\r
+@overload\r
+def reversed(object: Reversible[_T]) -> Iterator[_T]: ...\r
+def repr(o: object) -> str: ...\r
+@overload\r
+def round(number: float) -> float: ...\r
+@overload\r
+def round(number: float, ndigits: int) -> float: ... # Always return a float if given ndigits.\r
+@overload\r
+def round(number: SupportsRound[_T]) -> _T: ...\r
+@overload\r
+def round(number: SupportsRound[_T], ndigits: int) -> _T: ...\r
+def setattr(object: Any, name: unicode, value: Any) -> None: ...\r
+def sorted(iterable: Iterable[_T], *,\r
+ cmp: Callable[[_T, _T], int] = ...,\r
+ key: Callable[[_T], Any] = ...,\r
+ reverse: bool = ...) -> List[_T]: ...\r
+@overload\r
+def sum(iterable: Iterable[_T]) -> Union[_T, int]: ...\r
+@overload\r
+def sum(iterable: Iterable[_T], start: _S) -> Union[_T, _S]: ...\r
+def unichr(i: int) -> unicode: ...\r
+def vars(object: Any = ...) -> Dict[str, Any]: ...\r
+@overload\r
+def zip(iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...\r
+@overload\r
+def zip(iter1: Iterable[_T1],\r
+ iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...\r
+@overload\r
+def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],\r
+ iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...\r
+@overload\r
+def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],\r
+ iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2,\r
+ _T3, _T4]]: ...\r
+@overload\r
+def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],\r
+ iter4: Iterable[_T4], iter5: Iterable[_T5]) -> List[Tuple[_T1, _T2,\r
+ _T3, _T4, _T5]]: ...\r
+@overload\r
+def zip(iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any],\r
+ iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any],\r
+ *iterables: Iterable[Any]) -> List[Tuple[Any, ...]]: ...\r
+def __import__(name: unicode,\r
+ globals: Dict[str, Any] = ...,\r
+ locals: Dict[str, Any] = ...,\r
+ fromlist: List[str] = ..., level: int = ...) -> Any: ...\r
+\r
+def globals() -> Dict[str, Any]: ...\r
+def locals() -> Dict[str, Any]: ...\r
+\r
+# Actually the type of Ellipsis is <type 'ellipsis'>, but since it's\r
+# not exposed anywhere under that name, we make it private here.\r
+class ellipsis: ...\r
+Ellipsis = ... # type: ellipsis\r
+\r
+# TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check.\r
+_AnyBuffer = TypeVar('_AnyBuffer', str, unicode, bytearray, buffer)\r
+\r
+class buffer(Sized):\r
+ def __init__(self, object: _AnyBuffer, offset: int = ..., size: int = ...) -> None: ...\r
+ def __add__(self, other: _AnyBuffer) -> str: ...\r
+ def __cmp__(self, other: _AnyBuffer) -> bool: ...\r
+ def __getitem__(self, key: Union[int, slice]) -> str: ...\r
+ def __getslice__(self, i: int, j: int) -> str: ...\r
+ def __len__(self) -> int: ...\r
+ def __mul__(self, x: int) -> str: ...\r
+\r
+class memoryview(Sized, Container[bytes]):\r
+ format = ... # type: str\r
+ itemsize = ... # type: int\r
+ shape = ... # type: Optional[Tuple[int, ...]]\r
+ strides = ... # type: Optional[Tuple[int, ...]]\r
+ suboffsets = ... # type: Optional[Tuple[int, ...]]\r
+ readonly = ... # type: bool\r
+ ndim = ... # type: int\r
+\r
+ def __init__(self, obj: Union[str, bytearray, buffer, memoryview]) -> None: ...\r
+\r
+ @overload\r
+ def __getitem__(self, i: int) -> bytes: ...\r
+ @overload\r
+ def __getitem__(self, s: slice) -> memoryview: ...\r
+\r
+ def __contains__(self, x: object) -> bool: ...\r
+ def __iter__(self) -> Iterator[bytes]: ...\r
+ def __len__(self) -> int: ...\r
+\r
+ @overload\r
+ def __setitem__(self, i: int, o: bytes) -> None: ...\r
+ @overload\r
+ def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...\r
+ @overload\r
+ def __setitem__(self, s: slice, o: memoryview) -> None: ...\r
+\r
+ def tobytes(self) -> bytes: ...\r
+ def tolist(self) -> List[int]: ...\r
+\r
+class BaseException(object):\r
+ args = ... # type: Tuple[Any, ...]\r
+ message = ... # type: Any\r
+ def __init__(self, *args: object, **kwargs: object) -> None: ...\r
+ def __getitem__(self, i: int) -> Any: ...\r
+ def __getslice__(self, start: int, stop: int) -> Tuple[Any, ...]: ...\r
+\r
+class GeneratorExit(BaseException): ...\r
+class KeyboardInterrupt(BaseException): ...\r
+class SystemExit(BaseException):\r
+ code = 0\r
+class Exception(BaseException): ...\r
+class StopIteration(Exception): ...\r
+class StandardError(Exception): ...\r
+class ArithmeticError(StandardError): ...\r
+class BufferError(StandardError): ...\r
+class EnvironmentError(StandardError):\r
+ errno = 0\r
+ strerror = ... # type: str\r
+ # TODO can this be unicode?\r
+ filename = ... # type: str\r
+class LookupError(StandardError): ...\r
+class RuntimeError(StandardError): ...\r
+class ValueError(StandardError): ...\r
+class AssertionError(StandardError): ...\r
+class AttributeError(StandardError): ...\r
+class EOFError(StandardError): ...\r
+class FloatingPointError(ArithmeticError): ...\r
+class IOError(EnvironmentError): ...\r
+class ImportError(StandardError): ...\r
+class IndexError(LookupError): ...\r
+class KeyError(LookupError): ...\r
+class MemoryError(StandardError): ...\r
+class NameError(StandardError): ...\r
+class NotImplementedError(RuntimeError): ...\r
+class OSError(EnvironmentError): ...\r
+class WindowsError(OSError):\r
+ winerror = ... # type: int\r
+class OverflowError(ArithmeticError): ...\r
+class ReferenceError(StandardError): ...\r
+class SyntaxError(StandardError):\r
+ msg = ... # type: str\r
+ lineno = ... # type: int\r
+ offset = ... # type: int\r
+ text = ... # type: str\r
+ filename = ... # type: str\r
+class IndentationError(SyntaxError): ...\r
+class TabError(IndentationError): ...\r
+class SystemError(StandardError): ...\r
+class TypeError(StandardError): ...\r
+class UnboundLocalError(NameError): ...\r
+class UnicodeError(ValueError): ...\r
+class UnicodeDecodeError(UnicodeError):\r
+ encoding: bytes\r
+ object: bytes\r
+ start: int\r
+ end: int\r
+ reason: bytes\r
+ def __init__(self, __encoding: bytes, __object: bytes, __start: int, __end: int,\r
+ __reason: bytes) -> None: ...\r
+class UnicodeEncodeError(UnicodeError):\r
+ encoding: bytes\r
+ object: unicode\r
+ start: int\r
+ end: int\r
+ reason: bytes\r
+ def __init__(self, __encoding: bytes, __object: unicode, __start: int, __end: int,\r
+ __reason: bytes) -> None: ...\r
+class UnicodeTranslateError(UnicodeError): ...\r
+class ZeroDivisionError(ArithmeticError): ...\r
+\r
+class Warning(Exception): ...\r
+class UserWarning(Warning): ...\r
+class DeprecationWarning(Warning): ...\r
+class SyntaxWarning(Warning): ...\r
+class RuntimeWarning(Warning): ...\r
+class FutureWarning(Warning): ...\r
+class PendingDeprecationWarning(Warning): ...\r
+class ImportWarning(Warning): ...\r
+class UnicodeWarning(Warning): ...\r
+class BytesWarning(Warning): ...\r
+\r
+def eval(s: Union[str, unicode], globals: Dict[str, Any] = ..., locals: Dict[str, Any] = ...) -> Any: ...\r
+def exec(object: str,\r
+ globals: Optional[Dict[str, Any]] = ...,\r
+ locals: Optional[Dict[str, Any]] = ...) -> Any: ... # TODO code object as source\r
+\r
+def cmp(x: Any, y: Any) -> int: ...\r
+\r
+def execfile(filename: str, globals: Optional[Dict[str, Any]] = ..., locals: Optional[Dict[str, Any]] = ...) -> None: ...\r
+\r
+class file(BinaryIO):\r
+ @overload\r
+ def __init__(self, file: str, mode: str = ..., buffering: int = ...) -> None: ...\r
+ @overload\r
+ def __init__(self, file: unicode, mode: str = ..., buffering: int = ...) -> None: ...\r
+ @overload\r
+ def __init__(self, file: int, mode: str = ..., buffering: int = ...) -> None: ...\r
+ def __iter__(self) -> Iterator[str]: ...\r
+ def next(self) -> str: ...\r
+ def read(self, n: int = ...) -> str: ...\r
+ def __enter__(self) -> BinaryIO: ...\r
+ def __exit__(self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ...) -> bool: ...\r
+ def flush(self) -> None: ...\r
+ def fileno(self) -> int: ...\r
+ def isatty(self) -> bool: ...\r
+ def close(self) -> None: ...\r
+\r
+ def readable(self) -> bool: ...\r
+ def writable(self) -> bool: ...\r
+ def seekable(self) -> bool: ...\r
+ def seek(self, offset: int, whence: int = ...) -> int: ...\r
+ def tell(self) -> int: ...\r
+ def readline(self, limit: int = ...) -> str: ...\r
+ def readlines(self, hint: int = ...) -> List[str]: ...\r
+ def write(self, data: str) -> int: ...\r
+ def writelines(self, data: Iterable[str]) -> None: ...\r
+ def truncate(self, pos: Optional[int] = ...) -> int: ...\r
+\r
+# Very old builtins\r
+def apply(func: Callable[..., _T], args: Optional[Sequence[Any]] = ..., kwds: Optional[Mapping[str, Any]] = ...) -> _T: ...\r
+_N = TypeVar('_N', bool, int, float, complex)\r
+def coerce(x: _N, y: _N) -> Tuple[_N, _N]: ...\r
projects / dotfiles / .git / blobdiff