diff --git a/stdlib/2/__builtin__.pyi b/stdlib/2/__builtin__.pyi index 4b238a383fd1..7254b719c6bc 100644 --- a/stdlib/2/__builtin__.pyi +++ b/stdlib/2/__builtin__.pyi @@ -419,7 +419,7 @@ class str(Sequence[str], _str_base): def capitalize(self) -> str: ... if sys.version_info >= (3, 3): def casefold(self) -> str: ... - def center(self, width: int, fillchar: str = ...) -> 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: ... @@ -452,50 +452,50 @@ class str(Sequence[str], _str_base): def istitle(self) -> bool: ... def isupper(self) -> bool: ... if sys.version_info >= (3,): - def join(self, iterable: Iterable[str]) -> str: ... + def join(self, __iterable: Iterable[str]) -> str: ... else: - def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ... - def ljust(self, width: int, fillchar: str = ...) -> str: ... + 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: ... + 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: ... + def lstrip(self, __chars: str = ...) -> str: ... @overload - def lstrip(self, chars: unicode) -> unicode: ... + def lstrip(self, __chars: unicode) -> unicode: ... @overload - def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ... + def partition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload - def partition(self, sep: str) -> Tuple[str, str, str]: ... + def partition(self, __sep: str) -> Tuple[str, str, str]: ... @overload - def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... - def replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ... + 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: ... + def rjust(self, __width: int, __fillchar: str = ...) -> str: ... if sys.version_info >= (3,): - def rpartition(self, sep: str) -> Tuple[str, str, str]: ... + 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 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]: ... + def rpartition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload - def rpartition(self, sep: str) -> Tuple[str, str, str]: ... + def rpartition(self, __sep: str) -> Tuple[str, str, str]: ... @overload - def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... + def rpartition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... @overload def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... @overload - def rstrip(self, chars: str = ...) -> str: ... + def rstrip(self, __chars: str = ...) -> str: ... @overload - def rstrip(self, chars: unicode) -> unicode: ... + def rstrip(self, __chars: unicode) -> unicode: ... @overload def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload @@ -504,28 +504,28 @@ class str(Sequence[str], _str_base): 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: ... + def strip(self, __chars: Optional[str] = ...) -> str: ... else: def startswith(self, prefix: Union[Text, Tuple[Text, ...]]) -> bool: ... @overload - def strip(self, chars: str = ...) -> str: ... + 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: ... + 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 translate(self, __table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ... def upper(self) -> str: ... - def zfill(self, width: int) -> 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]: ... + 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]]: ... + def maketrans(__x: str, __y: str, __z: Optional[str] = ...) -> Dict[int, Union[int, None]]: ... if sys.version_info >= (3,): def __add__(self, s: str) -> str: ... @@ -569,7 +569,7 @@ if sys.version_info >= (3,): @overload def __init__(self, o: SupportsBytes) -> None: ... def capitalize(self) -> bytes: ... - def center(self, width: int, fillchar: bytes = ...) -> 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: ... @@ -589,18 +589,18 @@ if sys.version_info >= (3,): 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 join(self, __iterable_of_bytes: 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 lstrip(self, __bytes: 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 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 rstrip(self, __bytes: Optional[bytes] = ...) -> bytes: ... def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ... def splitlines(self, keepends: bool = ...) -> List[bytes]: ... def startswith( @@ -609,12 +609,12 @@ if sys.version_info >= (3,): start: Optional[int] = ..., end: Optional[int] = ..., ) -> bool: ... - def strip(self, chars: Optional[bytes] = ...) -> bytes: ... + def strip(self, __bytes: Optional[bytes] = ...) -> bytes: ... def swapcase(self) -> bytes: ... def title(self) -> bytes: ... - def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytes: ... + def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytes: ... def upper(self) -> bytes: ... - def zfill(self, width: int) -> bytes: ... + def zfill(self, __width: int) -> bytes: ... @classmethod def fromhex(cls, s: str) -> bytes: ... @classmethod @@ -670,26 +670,26 @@ class bytearray(MutableSequence[int], ByteString): @overload def __init__(self, length: int) -> None: ... def capitalize(self) -> bytearray: ... - def center(self, width: int, fillchar: bytes = ...) -> 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 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 count(self, __sub: str) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ... - def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... + def endswith(self, __suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> bytearray: ... if sys.version_info < (3,): def extend(self, iterable: Union[str, Iterable[int]]) -> None: ... if sys.version_info >= (3,): - def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... + 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 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 find(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... + def index(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... + def insert(self, __index: int, __item: int) -> None: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... if sys.version_info >= (3, 7): @@ -700,47 +700,47 @@ class bytearray(MutableSequence[int], ByteString): 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: ... + def join(self, __iterable_of_bytes: 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 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: ... + def lstrip(self, __bytes: 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: ... + 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 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 rstrip(self, __bytes: 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] = ..., + __prefix: Union[bytes, Tuple[bytes, ...]], + __start: Optional[int] = ..., + __end: Optional[int] = ..., ) -> bool: ... - def strip(self, chars: Optional[bytes] = ...) -> bytearray: ... + def strip(self, __bytes: 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: ... + def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytearray: ... else: - def translate(self, table: str) -> bytearray: ... + def translate(self, __table: str) -> bytearray: ... def upper(self) -> bytearray: ... - def zfill(self, width: int) -> bytearray: ... + def zfill(self, __width: int) -> bytearray: ... @staticmethod - def fromhex(s: str) -> bytearray: ... + def fromhex(__string: str) -> bytearray: ... if sys.version_info >= (3,): @classmethod - def maketrans(cls, frm: bytes, to: bytes) -> bytes: ... + def maketrans(cls, __frm: bytes, __to: bytes) -> bytes: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... @@ -895,11 +895,11 @@ class tuple(Sequence[_T_co], Generic[_T_co]): def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ... def __mul__(self, n: int) -> Tuple[_T_co, ...]: ... def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ... - def count(self, x: Any) -> int: ... + def count(self, __value: Any) -> int: ... if sys.version_info >= (3, 5): - def index(self, x: Any, start: int = ..., end: int = ...) -> int: ... + def index(self, __value: Any, __start: int = ..., __stop: int = ...) -> int: ... else: - def index(self, x: Any) -> int: ... + def index(self, __value: Any) -> int: ... class function: # TODO not defined in builtins! @@ -918,13 +918,13 @@ class list(MutableSequence[_T], Generic[_T]): 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 append(self, __object: _T) -> None: ... + def extend(self, __iterable: Iterable[_T]) -> None: ... + def pop(self, __index: int = ...) -> _T: ... + def index(self, __value: _T, __start: int = ..., __stop: int = ...) -> int: ... + def count(self, __value: _T) -> int: ... + def insert(self, __index: int, __object: _T) -> None: ... + def remove(self, __value: _T) -> None: ... def reverse(self) -> None: ... if sys.version_info >= (3,): def sort(self, *, key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> None: ... @@ -978,7 +978,7 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): def clear(self) -> None: ... def copy(self) -> Dict[_KT, _VT]: ... def popitem(self) -> Tuple[_KT, _VT]: ... - def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ... + def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ... @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload @@ -998,10 +998,10 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _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) + def fromkeys(__iterable: 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 fromkeys(__iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... @@ -1131,20 +1131,20 @@ if sys.version_info < (3,): NotImplemented: Any -def abs(__n: SupportsAbs[_T]) -> _T: ... -def all(__i: Iterable[object]) -> bool: ... -def any(__i: Iterable[object]) -> bool: ... +def abs(__x: SupportsAbs[_T]) -> _T: ... +def all(__iterable: Iterable[object]) -> bool: ... +def any(__iterable: 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: ... + def ascii(__obj: object) -> str: ... 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: ... +def callable(__obj: object) -> bool: ... +def chr(__i: int) -> str: ... if sys.version_info < (3,): def cmp(__x: Any, __y: Any) -> int: ... _N1 = TypeVar('_N1', bool, int, float, complex) @@ -1163,13 +1163,13 @@ else: if sys.version_info >= (3,): def copyright() -> None: ... def credits() -> None: ... -def delattr(__o: Any, __name: Text) -> None: ... +def delattr(__obj: 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 divmod(__x: _N2, __y: _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: ... + def exec(__source: 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: ... @@ -1189,15 +1189,15 @@ else: 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 format(__value: 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: ... +def hasattr(__obj: Any, __name: Text) -> bool: ... +def hash(__obj: 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: ... +def hex(__number: Union[int, _SupportsIndex]) -> str: ... +def id(__obj: object) -> int: ... if sys.version_info >= (3,): def input(__prompt: Any = ...) -> str: ... else: @@ -1209,9 +1209,9 @@ def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ... def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ... -def isinstance(__o: object, __t: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... -def issubclass(__cls: type, __classinfo: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... -def len(__o: Sized) -> int: ... +def isinstance(__obj: object, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... +def issubclass(__cls: type, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... +def len(__obj: Sized) -> int: ... if sys.version_info >= (3,): def license() -> None: ... def locals() -> Dict[str, Any]: ... @@ -1343,7 +1343,7 @@ else: def next(__i: Iterator[_T]) -> _T: ... @overload def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ... -def oct(__i: Union[int, _SupportsIndex]) -> str: ... +def oct(__number: Union[int, _SupportsIndex]) -> str: ... if sys.version_info >= (3, 6): def open(file: Union[str, bytes, int, _PathLike[Any]], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., @@ -1391,7 +1391,7 @@ if sys.version_info < (3,): def reversed(__object: Sequence[_T]) -> Iterator[_T]: ... @overload def reversed(__object: Reversible[_T]) -> Iterator[_T]: ... -def repr(__o: object) -> str: ... +def repr(__obj: object) -> str: ... if sys.version_info >= (3,): @overload def round(number: float) -> int: ... @@ -1414,7 +1414,7 @@ else: def round(number: SupportsFloat) -> float: ... @overload def round(number: SupportsFloat, ndigits: int) -> float: ... -def setattr(__object: Any, __name: Text, __value: Any) -> None: ... +def setattr(__obj: Any, __name: Text, __value: Any) -> None: ... if sys.version_info >= (3,): def sorted(__iterable: Iterable[_T], *, key: Optional[Callable[[_T], Any]] = ..., diff --git a/stdlib/2and3/builtins.pyi b/stdlib/2and3/builtins.pyi index 4b238a383fd1..7254b719c6bc 100644 --- a/stdlib/2and3/builtins.pyi +++ b/stdlib/2and3/builtins.pyi @@ -419,7 +419,7 @@ class str(Sequence[str], _str_base): def capitalize(self) -> str: ... if sys.version_info >= (3, 3): def casefold(self) -> str: ... - def center(self, width: int, fillchar: str = ...) -> 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: ... @@ -452,50 +452,50 @@ class str(Sequence[str], _str_base): def istitle(self) -> bool: ... def isupper(self) -> bool: ... if sys.version_info >= (3,): - def join(self, iterable: Iterable[str]) -> str: ... + def join(self, __iterable: Iterable[str]) -> str: ... else: - def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ... - def ljust(self, width: int, fillchar: str = ...) -> str: ... + 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: ... + 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: ... + def lstrip(self, __chars: str = ...) -> str: ... @overload - def lstrip(self, chars: unicode) -> unicode: ... + def lstrip(self, __chars: unicode) -> unicode: ... @overload - def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ... + def partition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload - def partition(self, sep: str) -> Tuple[str, str, str]: ... + def partition(self, __sep: str) -> Tuple[str, str, str]: ... @overload - def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... - def replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ... + 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: ... + def rjust(self, __width: int, __fillchar: str = ...) -> str: ... if sys.version_info >= (3,): - def rpartition(self, sep: str) -> Tuple[str, str, str]: ... + 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 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]: ... + def rpartition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload - def rpartition(self, sep: str) -> Tuple[str, str, str]: ... + def rpartition(self, __sep: str) -> Tuple[str, str, str]: ... @overload - def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... + def rpartition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... @overload def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... @overload - def rstrip(self, chars: str = ...) -> str: ... + def rstrip(self, __chars: str = ...) -> str: ... @overload - def rstrip(self, chars: unicode) -> unicode: ... + def rstrip(self, __chars: unicode) -> unicode: ... @overload def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload @@ -504,28 +504,28 @@ class str(Sequence[str], _str_base): 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: ... + def strip(self, __chars: Optional[str] = ...) -> str: ... else: def startswith(self, prefix: Union[Text, Tuple[Text, ...]]) -> bool: ... @overload - def strip(self, chars: str = ...) -> str: ... + 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: ... + 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 translate(self, __table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ... def upper(self) -> str: ... - def zfill(self, width: int) -> 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]: ... + 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]]: ... + def maketrans(__x: str, __y: str, __z: Optional[str] = ...) -> Dict[int, Union[int, None]]: ... if sys.version_info >= (3,): def __add__(self, s: str) -> str: ... @@ -569,7 +569,7 @@ if sys.version_info >= (3,): @overload def __init__(self, o: SupportsBytes) -> None: ... def capitalize(self) -> bytes: ... - def center(self, width: int, fillchar: bytes = ...) -> 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: ... @@ -589,18 +589,18 @@ if sys.version_info >= (3,): 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 join(self, __iterable_of_bytes: 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 lstrip(self, __bytes: 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 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 rstrip(self, __bytes: Optional[bytes] = ...) -> bytes: ... def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ... def splitlines(self, keepends: bool = ...) -> List[bytes]: ... def startswith( @@ -609,12 +609,12 @@ if sys.version_info >= (3,): start: Optional[int] = ..., end: Optional[int] = ..., ) -> bool: ... - def strip(self, chars: Optional[bytes] = ...) -> bytes: ... + def strip(self, __bytes: Optional[bytes] = ...) -> bytes: ... def swapcase(self) -> bytes: ... def title(self) -> bytes: ... - def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytes: ... + def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytes: ... def upper(self) -> bytes: ... - def zfill(self, width: int) -> bytes: ... + def zfill(self, __width: int) -> bytes: ... @classmethod def fromhex(cls, s: str) -> bytes: ... @classmethod @@ -670,26 +670,26 @@ class bytearray(MutableSequence[int], ByteString): @overload def __init__(self, length: int) -> None: ... def capitalize(self) -> bytearray: ... - def center(self, width: int, fillchar: bytes = ...) -> 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 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 count(self, __sub: str) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ... - def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... + def endswith(self, __suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> bytearray: ... if sys.version_info < (3,): def extend(self, iterable: Union[str, Iterable[int]]) -> None: ... if sys.version_info >= (3,): - def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... + 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 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 find(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... + def index(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... + def insert(self, __index: int, __item: int) -> None: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... if sys.version_info >= (3, 7): @@ -700,47 +700,47 @@ class bytearray(MutableSequence[int], ByteString): 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: ... + def join(self, __iterable_of_bytes: 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 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: ... + def lstrip(self, __bytes: 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: ... + 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 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 rstrip(self, __bytes: 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] = ..., + __prefix: Union[bytes, Tuple[bytes, ...]], + __start: Optional[int] = ..., + __end: Optional[int] = ..., ) -> bool: ... - def strip(self, chars: Optional[bytes] = ...) -> bytearray: ... + def strip(self, __bytes: 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: ... + def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytearray: ... else: - def translate(self, table: str) -> bytearray: ... + def translate(self, __table: str) -> bytearray: ... def upper(self) -> bytearray: ... - def zfill(self, width: int) -> bytearray: ... + def zfill(self, __width: int) -> bytearray: ... @staticmethod - def fromhex(s: str) -> bytearray: ... + def fromhex(__string: str) -> bytearray: ... if sys.version_info >= (3,): @classmethod - def maketrans(cls, frm: bytes, to: bytes) -> bytes: ... + def maketrans(cls, __frm: bytes, __to: bytes) -> bytes: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... @@ -895,11 +895,11 @@ class tuple(Sequence[_T_co], Generic[_T_co]): def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ... def __mul__(self, n: int) -> Tuple[_T_co, ...]: ... def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ... - def count(self, x: Any) -> int: ... + def count(self, __value: Any) -> int: ... if sys.version_info >= (3, 5): - def index(self, x: Any, start: int = ..., end: int = ...) -> int: ... + def index(self, __value: Any, __start: int = ..., __stop: int = ...) -> int: ... else: - def index(self, x: Any) -> int: ... + def index(self, __value: Any) -> int: ... class function: # TODO not defined in builtins! @@ -918,13 +918,13 @@ class list(MutableSequence[_T], Generic[_T]): 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 append(self, __object: _T) -> None: ... + def extend(self, __iterable: Iterable[_T]) -> None: ... + def pop(self, __index: int = ...) -> _T: ... + def index(self, __value: _T, __start: int = ..., __stop: int = ...) -> int: ... + def count(self, __value: _T) -> int: ... + def insert(self, __index: int, __object: _T) -> None: ... + def remove(self, __value: _T) -> None: ... def reverse(self) -> None: ... if sys.version_info >= (3,): def sort(self, *, key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> None: ... @@ -978,7 +978,7 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): def clear(self) -> None: ... def copy(self) -> Dict[_KT, _VT]: ... def popitem(self) -> Tuple[_KT, _VT]: ... - def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ... + def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ... @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload @@ -998,10 +998,10 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _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) + def fromkeys(__iterable: 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 fromkeys(__iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... @@ -1131,20 +1131,20 @@ if sys.version_info < (3,): NotImplemented: Any -def abs(__n: SupportsAbs[_T]) -> _T: ... -def all(__i: Iterable[object]) -> bool: ... -def any(__i: Iterable[object]) -> bool: ... +def abs(__x: SupportsAbs[_T]) -> _T: ... +def all(__iterable: Iterable[object]) -> bool: ... +def any(__iterable: 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: ... + def ascii(__obj: object) -> str: ... 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: ... +def callable(__obj: object) -> bool: ... +def chr(__i: int) -> str: ... if sys.version_info < (3,): def cmp(__x: Any, __y: Any) -> int: ... _N1 = TypeVar('_N1', bool, int, float, complex) @@ -1163,13 +1163,13 @@ else: if sys.version_info >= (3,): def copyright() -> None: ... def credits() -> None: ... -def delattr(__o: Any, __name: Text) -> None: ... +def delattr(__obj: 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 divmod(__x: _N2, __y: _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: ... + def exec(__source: 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: ... @@ -1189,15 +1189,15 @@ else: 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 format(__value: 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: ... +def hasattr(__obj: Any, __name: Text) -> bool: ... +def hash(__obj: 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: ... +def hex(__number: Union[int, _SupportsIndex]) -> str: ... +def id(__obj: object) -> int: ... if sys.version_info >= (3,): def input(__prompt: Any = ...) -> str: ... else: @@ -1209,9 +1209,9 @@ def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ... def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ... -def isinstance(__o: object, __t: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... -def issubclass(__cls: type, __classinfo: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... -def len(__o: Sized) -> int: ... +def isinstance(__obj: object, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... +def issubclass(__cls: type, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... +def len(__obj: Sized) -> int: ... if sys.version_info >= (3,): def license() -> None: ... def locals() -> Dict[str, Any]: ... @@ -1343,7 +1343,7 @@ else: def next(__i: Iterator[_T]) -> _T: ... @overload def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ... -def oct(__i: Union[int, _SupportsIndex]) -> str: ... +def oct(__number: Union[int, _SupportsIndex]) -> str: ... if sys.version_info >= (3, 6): def open(file: Union[str, bytes, int, _PathLike[Any]], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., @@ -1391,7 +1391,7 @@ if sys.version_info < (3,): def reversed(__object: Sequence[_T]) -> Iterator[_T]: ... @overload def reversed(__object: Reversible[_T]) -> Iterator[_T]: ... -def repr(__o: object) -> str: ... +def repr(__obj: object) -> str: ... if sys.version_info >= (3,): @overload def round(number: float) -> int: ... @@ -1414,7 +1414,7 @@ else: def round(number: SupportsFloat) -> float: ... @overload def round(number: SupportsFloat, ndigits: int) -> float: ... -def setattr(__object: Any, __name: Text, __value: Any) -> None: ... +def setattr(__obj: Any, __name: Text, __value: Any) -> None: ... if sys.version_info >= (3,): def sorted(__iterable: Iterable[_T], *, key: Optional[Callable[[_T], Any]] = ...,