mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-06 12:14:27 +08:00
Positional-only arguments for built-in functions. (#2921)
This commit is contained in:
Brandt Bucher
committed by
Sebastian Rittau
Sebastian Rittau
parent
67b42aff6b
commit
1fddec3f90
@@ -1094,22 +1094,22 @@ 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(__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: ...
|
||||
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 bin(number: int) -> str: ...
|
||||
def ascii(__o: object) -> str: ...
|
||||
def bin(__number: int) -> 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(__o: object) -> bool: ...
|
||||
def chr(__code: int) -> str: ...
|
||||
if sys.version_info < (3,):
|
||||
def cmp(x: Any, y: Any) -> int: ...
|
||||
def cmp(__x: Any, __y: Any) -> int: ...
|
||||
_N1 = TypeVar('_N1', bool, int, float, complex)
|
||||
def coerce(x: _N1, y: _N1) -> Tuple[_N1, _N1]: ...
|
||||
def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ...
|
||||
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.
|
||||
@@ -1124,15 +1124,15 @@ else:
|
||||
if sys.version_info >= (3,):
|
||||
def copyright() -> None: ...
|
||||
def credits() -> None: ...
|
||||
def delattr(o: Any, name: Text) -> None: ...
|
||||
def dir(o: object = ...) -> List[str]: ...
|
||||
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: ...
|
||||
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: ...
|
||||
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 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
|
||||
@@ -1155,159 +1155,159 @@ else:
|
||||
@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 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: ...
|
||||
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: int) -> str: ... # TODO __index__
|
||||
def id(o: object) -> int: ...
|
||||
def hex(__i: int) -> str: ... # TODO __index__
|
||||
def id(__o: object) -> int: ...
|
||||
if sys.version_info >= (3,):
|
||||
def input(prompt: Any = ...) -> str: ...
|
||||
def input(__prompt: Any = ...) -> str: ...
|
||||
else:
|
||||
def input(prompt: Any = ...) -> Any: ...
|
||||
def intern(string: str) -> str: ...
|
||||
def input(__prompt: Any = ...) -> Any: ...
|
||||
def intern(__string: str) -> str: ...
|
||||
@overload
|
||||
def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
|
||||
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: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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],
|
||||
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]: ...
|
||||
def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ...
|
||||
@overload
|
||||
def map(func: None,
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
def map(__func: None,
|
||||
__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
@overload
|
||||
def map(func: None,
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
def map(__func: None,
|
||||
__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2],
|
||||
__iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
@overload
|
||||
def map(func: None,
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3],
|
||||
iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
|
||||
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]]: ...
|
||||
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],
|
||||
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]: ...
|
||||
def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> List[_S]: ...
|
||||
@overload
|
||||
def map(func: Callable[[_T1, _T2], _S],
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2]) -> List[_S]: ...
|
||||
def map(__func: Callable[[_T1, _T2], _S],
|
||||
__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2]) -> List[_S]: ...
|
||||
@overload
|
||||
def map(func: Callable[[_T1, _T2, _T3], _S],
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3]) -> List[_S]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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],
|
||||
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: ...
|
||||
def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def max(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
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]: ...
|
||||
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: ...
|
||||
def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def max(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
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: ...
|
||||
def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def min(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
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]: ...
|
||||
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: ...
|
||||
def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def min(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def next(i: Iterator[_T]) -> _T: ...
|
||||
def next(__i: Iterator[_T]) -> _T: ...
|
||||
@overload
|
||||
def next(i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
|
||||
def oct(i: int) -> str: ... # TODO __index__
|
||||
def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
|
||||
def oct(__i: int) -> str: ... # TODO __index__
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
def open(file: Union[str, bytes, int, _PathLike], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ...,
|
||||
@@ -1316,9 +1316,9 @@ 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 = ...) -> IO[Any]: ...
|
||||
else:
|
||||
def open(file: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...
|
||||
def open(name: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...
|
||||
|
||||
def ord(c: Union[Text, bytes]) -> int: ...
|
||||
def ord(__c: Union[Text, bytes]) -> int: ...
|
||||
if sys.version_info >= (3,):
|
||||
class _Writer(Protocol):
|
||||
def write(self, s: str) -> Any: ...
|
||||
@@ -1329,27 +1329,27 @@ else:
|
||||
# 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
|
||||
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: ...
|
||||
def pow(__x: int, __y: int, __z: int) -> Any: ...
|
||||
@overload
|
||||
def pow(x: float, y: float) -> float: ...
|
||||
def pow(__x: float, __y: float) -> float: ...
|
||||
@overload
|
||||
def pow(x: float, y: float, z: float) -> float: ...
|
||||
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: ...
|
||||
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: ...
|
||||
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: ...
|
||||
def reduce(__function: Callable[[_T, _T], _T], __iterable: Iterable[_T]) -> _T: ...
|
||||
def reload(__module: Any) -> Any: ...
|
||||
@overload
|
||||
def reversed(object: Sequence[_T]) -> Iterator[_T]: ...
|
||||
def reversed(__object: Sequence[_T]) -> Iterator[_T]: ...
|
||||
@overload
|
||||
def reversed(object: Reversible[_T]) -> Iterator[_T]: ...
|
||||
def repr(o: object) -> str: ...
|
||||
def reversed(__object: Reversible[_T]) -> Iterator[_T]: ...
|
||||
def repr(__o: object) -> str: ...
|
||||
if sys.version_info >= (3,):
|
||||
@overload
|
||||
def round(number: float) -> int: ...
|
||||
@@ -1372,59 +1372,59 @@ 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(__object: Any, __name: Text, __value: Any) -> None: ...
|
||||
if sys.version_info >= (3,):
|
||||
def sorted(iterable: Iterable[_T], *,
|
||||
def sorted(__iterable: Iterable[_T], *,
|
||||
key: Optional[Callable[[_T], Any]] = ...,
|
||||
reverse: bool = ...) -> List[_T]: ...
|
||||
else:
|
||||
def sorted(iterable: Iterable[_T], *,
|
||||
def sorted(__iterable: Iterable[_T], *,
|
||||
cmp: Callable[[_T, _T], int] = ...,
|
||||
key: Callable[[_T], Any] = ...,
|
||||
reverse: bool = ...) -> List[_T]: ...
|
||||
@overload
|
||||
def sum(iterable: Iterable[_T]) -> Union[_T, int]: ...
|
||||
def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ...
|
||||
@overload
|
||||
def sum(iterable: Iterable[_T], start: _S) -> Union[_T, _S]: ...
|
||||
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]: ...
|
||||
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]]: ...
|
||||
def zip(__iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
|
||||
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]]: ...
|
||||
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]]: ...
|
||||
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]]: ...
|
||||
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],
|
||||
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]]: ...
|
||||
def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
def zip(__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2],
|
||||
__iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
|
||||
iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
|
||||
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]]: ...
|
||||
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],
|
||||
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: Dict[str, Any] = ..., locals: Dict[str, Any] = ...,
|
||||
fromlist: List[str] = ..., level: int = ...) -> Any: ...
|
||||
|
||||
@@ -1094,22 +1094,22 @@ 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(__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: ...
|
||||
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 bin(number: int) -> str: ...
|
||||
def ascii(__o: object) -> str: ...
|
||||
def bin(__number: int) -> 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(__o: object) -> bool: ...
|
||||
def chr(__code: int) -> str: ...
|
||||
if sys.version_info < (3,):
|
||||
def cmp(x: Any, y: Any) -> int: ...
|
||||
def cmp(__x: Any, __y: Any) -> int: ...
|
||||
_N1 = TypeVar('_N1', bool, int, float, complex)
|
||||
def coerce(x: _N1, y: _N1) -> Tuple[_N1, _N1]: ...
|
||||
def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ...
|
||||
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.
|
||||
@@ -1124,15 +1124,15 @@ else:
|
||||
if sys.version_info >= (3,):
|
||||
def copyright() -> None: ...
|
||||
def credits() -> None: ...
|
||||
def delattr(o: Any, name: Text) -> None: ...
|
||||
def dir(o: object = ...) -> List[str]: ...
|
||||
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: ...
|
||||
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: ...
|
||||
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 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
|
||||
@@ -1155,159 +1155,159 @@ else:
|
||||
@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 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: ...
|
||||
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: int) -> str: ... # TODO __index__
|
||||
def id(o: object) -> int: ...
|
||||
def hex(__i: int) -> str: ... # TODO __index__
|
||||
def id(__o: object) -> int: ...
|
||||
if sys.version_info >= (3,):
|
||||
def input(prompt: Any = ...) -> str: ...
|
||||
def input(__prompt: Any = ...) -> str: ...
|
||||
else:
|
||||
def input(prompt: Any = ...) -> Any: ...
|
||||
def intern(string: str) -> str: ...
|
||||
def input(__prompt: Any = ...) -> Any: ...
|
||||
def intern(__string: str) -> str: ...
|
||||
@overload
|
||||
def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
|
||||
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: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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],
|
||||
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]: ...
|
||||
def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ...
|
||||
@overload
|
||||
def map(func: None,
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
def map(__func: None,
|
||||
__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
@overload
|
||||
def map(func: None,
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
def map(__func: None,
|
||||
__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2],
|
||||
__iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
@overload
|
||||
def map(func: None,
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3],
|
||||
iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
|
||||
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]]: ...
|
||||
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],
|
||||
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]: ...
|
||||
def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> List[_S]: ...
|
||||
@overload
|
||||
def map(func: Callable[[_T1, _T2], _S],
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2]) -> List[_S]: ...
|
||||
def map(__func: Callable[[_T1, _T2], _S],
|
||||
__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2]) -> List[_S]: ...
|
||||
@overload
|
||||
def map(func: Callable[[_T1, _T2, _T3], _S],
|
||||
iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3]) -> List[_S]: ...
|
||||
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]: ...
|
||||
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]: ...
|
||||
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],
|
||||
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: ...
|
||||
def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def max(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
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]: ...
|
||||
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: ...
|
||||
def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def max(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
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: ...
|
||||
def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def min(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
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]: ...
|
||||
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: ...
|
||||
def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def min(_iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
|
||||
@overload
|
||||
def next(i: Iterator[_T]) -> _T: ...
|
||||
def next(__i: Iterator[_T]) -> _T: ...
|
||||
@overload
|
||||
def next(i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
|
||||
def oct(i: int) -> str: ... # TODO __index__
|
||||
def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
|
||||
def oct(__i: int) -> str: ... # TODO __index__
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
def open(file: Union[str, bytes, int, _PathLike], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ...,
|
||||
@@ -1316,9 +1316,9 @@ 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 = ...) -> IO[Any]: ...
|
||||
else:
|
||||
def open(file: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...
|
||||
def open(name: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...
|
||||
|
||||
def ord(c: Union[Text, bytes]) -> int: ...
|
||||
def ord(__c: Union[Text, bytes]) -> int: ...
|
||||
if sys.version_info >= (3,):
|
||||
class _Writer(Protocol):
|
||||
def write(self, s: str) -> Any: ...
|
||||
@@ -1329,27 +1329,27 @@ else:
|
||||
# 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
|
||||
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: ...
|
||||
def pow(__x: int, __y: int, __z: int) -> Any: ...
|
||||
@overload
|
||||
def pow(x: float, y: float) -> float: ...
|
||||
def pow(__x: float, __y: float) -> float: ...
|
||||
@overload
|
||||
def pow(x: float, y: float, z: float) -> float: ...
|
||||
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: ...
|
||||
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: ...
|
||||
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: ...
|
||||
def reduce(__function: Callable[[_T, _T], _T], __iterable: Iterable[_T]) -> _T: ...
|
||||
def reload(__module: Any) -> Any: ...
|
||||
@overload
|
||||
def reversed(object: Sequence[_T]) -> Iterator[_T]: ...
|
||||
def reversed(__object: Sequence[_T]) -> Iterator[_T]: ...
|
||||
@overload
|
||||
def reversed(object: Reversible[_T]) -> Iterator[_T]: ...
|
||||
def repr(o: object) -> str: ...
|
||||
def reversed(__object: Reversible[_T]) -> Iterator[_T]: ...
|
||||
def repr(__o: object) -> str: ...
|
||||
if sys.version_info >= (3,):
|
||||
@overload
|
||||
def round(number: float) -> int: ...
|
||||
@@ -1372,59 +1372,59 @@ 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(__object: Any, __name: Text, __value: Any) -> None: ...
|
||||
if sys.version_info >= (3,):
|
||||
def sorted(iterable: Iterable[_T], *,
|
||||
def sorted(__iterable: Iterable[_T], *,
|
||||
key: Optional[Callable[[_T], Any]] = ...,
|
||||
reverse: bool = ...) -> List[_T]: ...
|
||||
else:
|
||||
def sorted(iterable: Iterable[_T], *,
|
||||
def sorted(__iterable: Iterable[_T], *,
|
||||
cmp: Callable[[_T, _T], int] = ...,
|
||||
key: Callable[[_T], Any] = ...,
|
||||
reverse: bool = ...) -> List[_T]: ...
|
||||
@overload
|
||||
def sum(iterable: Iterable[_T]) -> Union[_T, int]: ...
|
||||
def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ...
|
||||
@overload
|
||||
def sum(iterable: Iterable[_T], start: _S) -> Union[_T, _S]: ...
|
||||
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]: ...
|
||||
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]]: ...
|
||||
def zip(__iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
|
||||
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]]: ...
|
||||
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]]: ...
|
||||
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]]: ...
|
||||
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],
|
||||
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]]: ...
|
||||
def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1],
|
||||
iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
def zip(__iter1: Iterable[_T1],
|
||||
__iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],
|
||||
iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2],
|
||||
__iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
|
||||
@overload
|
||||
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
|
||||
iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
|
||||
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]]: ...
|
||||
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],
|
||||
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: Dict[str, Any] = ..., locals: Dict[str, Any] = ...,
|
||||
fromlist: List[str] = ..., level: int = ...) -> Any: ...
|
||||
|
||||
Reference in New Issue
Block a user