From e1d57a06faade59719b72b9aaf6db1fccc6f1347 Mon Sep 17 00:00:00 2001 From: Mikhail Ilchenko Date: Tue, 23 Aug 2022 14:56:48 +0400 Subject: [PATCH 1/5] Introduce `IterableOrSupportsIntGetItem` protocol Mostly, `iter` builtin, collections, for loop, accept not only Iterable but also instances with `__getitem__` implemented Therefore we need some type to replace `Iterable` with in stubs --- stdlib/_typeshed/__init__.pyi | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/stdlib/_typeshed/__init__.pyi b/stdlib/_typeshed/__init__.pyi index 89ca9d81619a..b4725b678149 100644 --- a/stdlib/_typeshed/__init__.pyi +++ b/stdlib/_typeshed/__init__.pyi @@ -99,10 +99,12 @@ class SupportsIter(Protocol[_T_co]): class SupportsAiter(Protocol[_T_co]): def __aiter__(self) -> _T_co: ... -class SupportsLenAndGetItem(Protocol[_T_co]): - def __len__(self) -> int: ... +class SupportsIntGetItem(Protocol[_T_co]): def __getitem__(self, __k: int) -> _T_co: ... +class SupportsLenAndGetItem(SupportsIntGetItem[_T_co]): + def __len__(self) -> int: ... + class SupportsTrunc(Protocol): def __trunc__(self) -> int: ... @@ -276,3 +278,5 @@ ProfileFunction: TypeAlias = Callable[[FrameType, str, Any], object] # Objects suitable to be passed to sys.settrace, threading.settrace, and similar # TODO: Ideally this would be a recursive type alias TraceFunction: TypeAlias = Callable[[FrameType, str, Any], Callable[[FrameType, str, Any], Any] | None] + +IterableOrSupportsIntGetItem: TypeAlias = Iterable[_T] | SupportsIntGetItem[_T] From 7b4b38cce315d32cd203740e16621b4d9da65685 Mon Sep 17 00:00:00 2001 From: Mikhail Ilchenko Date: Tue, 23 Aug 2022 15:01:57 +0400 Subject: [PATCH 2/5] Support `builtins` iteration with `__getitem__` - remove `_GetItemIterable` and use `SupportsIntGetItem` for `iter` - support `__getitem__` iteration for - collections - iterators - objects arguments --- stdlib/builtins.pyi | 276 ++++++++++++++++++++++++-------------------- 1 file changed, 154 insertions(+), 122 deletions(-) diff --git a/stdlib/builtins.pyi b/stdlib/builtins.pyi index ec6efd9efe32..d1639259db4a 100644 --- a/stdlib/builtins.pyi +++ b/stdlib/builtins.pyi @@ -4,6 +4,7 @@ from _ast import AST from _collections_abc import dict_items, dict_keys, dict_values from _typeshed import ( AnyStr_co, + IterableOrSupportsIntGetItem, OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, @@ -16,6 +17,7 @@ from _typeshed import ( SupportsAiter, SupportsAnext, SupportsDivMod, + SupportsIntGetItem, SupportsIter, SupportsKeysAndGetItem, SupportsLenAndGetItem, @@ -223,7 +225,7 @@ class int: @classmethod def from_bytes( cls: type[Self], - bytes: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer, + bytes: IterableOrSupportsIntGetItem[SupportsIndex] | SupportsBytes | ReadableBuffer, byteorder: Literal["little", "big"] = ..., *, signed: bool = ..., @@ -233,7 +235,7 @@ class int: @classmethod def from_bytes( cls: type[Self], - bytes: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer, + bytes: IterableOrSupportsIntGetItem[SupportsIndex] | SupportsBytes | ReadableBuffer, byteorder: Literal["little", "big"], *, signed: bool = ..., @@ -459,9 +461,9 @@ class str(Sequence[str]): def istitle(self) -> bool: ... def isupper(self) -> bool: ... @overload - def join(self: LiteralString, __iterable: Iterable[LiteralString]) -> LiteralString: ... + def join(self: LiteralString, __iterable: IterableOrSupportsIntGetItem[LiteralString]) -> LiteralString: ... @overload - def join(self, __iterable: Iterable[str]) -> str: ... # type: ignore[misc] + def join(self, __iterable: IterableOrSupportsIntGetItem[str]) -> str: ... # type: ignore[misc] @overload def ljust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = ...) -> LiteralString: ... @overload @@ -584,7 +586,7 @@ class str(Sequence[str]): class bytes(ByteString): @overload - def __new__(cls: type[Self], __ints: Iterable[SupportsIndex]) -> Self: ... + def __new__(cls: type[Self], __ints: IterableOrSupportsIntGetItem[SupportsIndex]) -> Self: ... @overload def __new__(cls: type[Self], __string: str, encoding: str, errors: str = ...) -> Self: ... @overload @@ -629,7 +631,7 @@ class bytes(ByteString): def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... - def join(self, __iterable_of_bytes: Iterable[ReadableBuffer]) -> bytes: ... + def join(self, __iterable_of_bytes: IterableOrSupportsIntGetItem[ReadableBuffer]) -> bytes: ... def ljust(self, __width: SupportsIndex, __fillchar: bytes | bytearray = ...) -> bytes: ... def lower(self) -> bytes: ... def lstrip(self, __bytes: ReadableBuffer | None = ...) -> bytes: ... @@ -693,7 +695,7 @@ class bytearray(MutableSequence[int], ByteString): @overload def __init__(self) -> None: ... @overload - def __init__(self, __ints: Iterable[SupportsIndex]) -> None: ... + def __init__(self, __ints: IterableOrSupportsIntGetItem[SupportsIndex]) -> None: ... @overload def __init__(self, __string: str, encoding: str, errors: str = ...) -> None: ... @overload @@ -717,7 +719,7 @@ class bytearray(MutableSequence[int], ByteString): else: def expandtabs(self, tabsize: int = ...) -> bytearray: ... - def extend(self, __iterable_of_ints: Iterable[SupportsIndex]) -> None: ... + def extend(self, __iterable_of_ints: IterableOrSupportsIntGetItem[SupportsIndex]) -> None: ... def find( self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ... ) -> int: ... @@ -738,7 +740,7 @@ class bytearray(MutableSequence[int], ByteString): def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... - def join(self, __iterable_of_bytes: Iterable[ReadableBuffer]) -> bytearray: ... + def join(self, __iterable_of_bytes: IterableOrSupportsIntGetItem[ReadableBuffer]) -> bytearray: ... def ljust(self, __width: SupportsIndex, __fillchar: bytes | bytearray = ...) -> bytearray: ... def lower(self) -> bytearray: ... def lstrip(self, __bytes: ReadableBuffer | None = ...) -> bytearray: ... @@ -788,10 +790,10 @@ class bytearray(MutableSequence[int], ByteString): @overload def __setitem__(self, __i: SupportsIndex, __x: SupportsIndex) -> None: ... @overload - def __setitem__(self, __s: slice, __x: Iterable[SupportsIndex] | bytes) -> None: ... + def __setitem__(self, __s: slice, __x: IterableOrSupportsIntGetItem[SupportsIndex] | bytes) -> None: ... def __delitem__(self, __i: SupportsIndex | slice) -> None: ... def __add__(self, __s: ReadableBuffer) -> bytearray: ... - # The superclass wants us to accept Iterable[int], but that fails at runtime. + # The superclass wants us to accept IterableOrSupportsIntGetItem[int], but that fails at runtime. def __iadd__(self: Self, __s: ReadableBuffer) -> Self: ... # type: ignore[override] def __mul__(self, __n: SupportsIndex) -> bytearray: ... def __rmul__(self, __n: SupportsIndex) -> bytearray: ... @@ -912,7 +914,7 @@ class slice: def indices(self, __len: SupportsIndex) -> tuple[int, int, int]: ... class tuple(Sequence[_T_co], Generic[_T_co]): - def __new__(cls: type[Self], __iterable: Iterable[_T_co] = ...) -> Self: ... + def __new__(cls: type[Self], __iterable: IterableOrSupportsIntGetItem[_T_co] = ...) -> Self: ... def __len__(self) -> int: ... def __contains__(self, __x: object) -> bool: ... @overload @@ -963,10 +965,10 @@ class list(MutableSequence[_T], Generic[_T]): @overload def __init__(self) -> None: ... @overload - def __init__(self, __iterable: Iterable[_T]) -> None: ... + def __init__(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def copy(self) -> list[_T]: ... def append(self, __object: _T) -> None: ... - def extend(self, __iterable: Iterable[_T]) -> None: ... + def extend(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def pop(self, __index: SupportsIndex = ...) -> _T: ... # Signature of `list.index` should be kept in line with `collections.UserList.index()` # and multiprocessing.managers.ListProxy.index() @@ -993,14 +995,14 @@ class list(MutableSequence[_T], Generic[_T]): @overload def __setitem__(self, __i: SupportsIndex, __o: _T) -> None: ... @overload - def __setitem__(self, __s: slice, __o: Iterable[_T]) -> None: ... + def __setitem__(self, __s: slice, __o: IterableOrSupportsIntGetItem[_T]) -> None: ... def __delitem__(self, __i: SupportsIndex | slice) -> None: ... # Overloading looks unnecessary, but is needed to work around complex mypy problems @overload def __add__(self, __x: list[_T]) -> list[_T]: ... @overload def __add__(self, __x: list[_S]) -> list[_S | _T]: ... - def __iadd__(self: Self, __x: Iterable[_T]) -> Self: ... # type: ignore[misc] + def __iadd__(self: Self, __x: IterableOrSupportsIntGetItem[_T]) -> Self: ... # type: ignore[misc] def __mul__(self, __n: SupportsIndex) -> list[_T]: ... def __rmul__(self, __n: SupportsIndex) -> list[_T]: ... def __imul__(self: Self, __n: SupportsIndex) -> Self: ... @@ -1025,13 +1027,13 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): @overload def __init__(self: dict[str, _VT], __map: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT) -> None: ... @overload - def __init__(self, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ... + def __init__(self, __iterable: IterableOrSupportsIntGetItem[tuple[_KT, _VT]]) -> None: ... @overload - def __init__(self: dict[str, _VT], __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT) -> None: ... + def __init__(self: dict[str, _VT], __iterable: IterableOrSupportsIntGetItem[tuple[str, _VT]], **kwargs: _VT) -> None: ... # Next overload is for dict(string.split(sep) for string in iterable) - # Cannot be Iterable[Sequence[_T]] or otherwise dict(["foo", "bar", "baz"]) is not an error + # Cannot be IterableOrSupportsIntGetItem[Sequence[_T]] or otherwise dict(["foo", "bar", "baz"]) is not an error @overload - def __init__(self: dict[str, str], __iterable: Iterable[list[str]]) -> None: ... + def __init__(self: dict[str, str], __iterable: IterableOrSupportsIntGetItem[list[str]]) -> None: ... def __new__(cls: type[Self], *args: Any, **kwargs: Any) -> Self: ... def copy(self) -> dict[_KT, _VT]: ... def keys(self) -> dict_keys[_KT, _VT]: ... @@ -1042,10 +1044,10 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): # See #3800 & https://github.com/python/typing/issues/548#issuecomment-683336963. @classmethod @overload - def fromkeys(cls, __iterable: Iterable[_T], __value: None = ...) -> dict[_T, Any | None]: ... + def fromkeys(cls, __iterable: IterableOrSupportsIntGetItem[_T], __value: None = ...) -> dict[_T, Any | None]: ... @classmethod @overload - def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> dict[_T, _S]: ... + def fromkeys(cls, __iterable: IterableOrSupportsIntGetItem[_T], __value: _S) -> dict[_T, _S]: ... # Positional-only in dict, but not in MutableMapping @overload def get(self, __key: _KT) -> _VT | None: ... @@ -1071,28 +1073,28 @@ class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): @overload # type: ignore[misc] def __ior__(self: Self, __value: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ... @overload - def __ior__(self: Self, __value: Iterable[tuple[_KT, _VT]]) -> Self: ... + def __ior__(self: Self, __value: IterableOrSupportsIntGetItem[tuple[_KT, _VT]]) -> Self: ... class set(MutableSet[_T], Generic[_T]): @overload def __init__(self) -> None: ... @overload - def __init__(self, __iterable: Iterable[_T]) -> None: ... + def __init__(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def add(self, __element: _T) -> None: ... def copy(self) -> set[_T]: ... - def difference(self, *s: Iterable[Any]) -> set[_T]: ... - def difference_update(self, *s: Iterable[Any]) -> None: ... + def difference(self, *s: IterableOrSupportsIntGetItem[Any]) -> set[_T]: ... + def difference_update(self, *s: IterableOrSupportsIntGetItem[Any]) -> None: ... def discard(self, __element: _T) -> None: ... - def intersection(self, *s: Iterable[Any]) -> set[_T]: ... - def intersection_update(self, *s: Iterable[Any]) -> None: ... - def isdisjoint(self, __s: Iterable[Any]) -> bool: ... - def issubset(self, __s: Iterable[Any]) -> bool: ... - def issuperset(self, __s: Iterable[Any]) -> bool: ... + def intersection(self, *s: IterableOrSupportsIntGetItem[Any]) -> set[_T]: ... + def intersection_update(self, *s: IterableOrSupportsIntGetItem[Any]) -> None: ... + def isdisjoint(self, __s: IterableOrSupportsIntGetItem[Any]) -> bool: ... + def issubset(self, __s: IterableOrSupportsIntGetItem[Any]) -> bool: ... + def issuperset(self, __s: IterableOrSupportsIntGetItem[Any]) -> bool: ... def remove(self, __element: _T) -> None: ... - def symmetric_difference(self, __s: Iterable[_T]) -> set[_T]: ... - def symmetric_difference_update(self, __s: Iterable[_T]) -> None: ... - def union(self, *s: Iterable[_S]) -> set[_T | _S]: ... - def update(self, *s: Iterable[_T]) -> None: ... + def symmetric_difference(self, __s: IterableOrSupportsIntGetItem[_T]) -> set[_T]: ... + def symmetric_difference_update(self, __s: IterableOrSupportsIntGetItem[_T]) -> None: ... + def union(self, *s: IterableOrSupportsIntGetItem[_S]) -> set[_T | _S]: ... + def update(self, *s: IterableOrSupportsIntGetItem[_T]) -> None: ... def __len__(self) -> int: ... def __contains__(self, __o: object) -> bool: ... def __iter__(self) -> Iterator[_T]: ... @@ -1116,15 +1118,15 @@ class frozenset(AbstractSet[_T_co], Generic[_T_co]): @overload def __new__(cls: type[Self]) -> Self: ... @overload - def __new__(cls: type[Self], __iterable: Iterable[_T_co]) -> Self: ... + def __new__(cls: type[Self], __iterable: IterableOrSupportsIntGetItem[_T_co]) -> Self: ... def copy(self) -> frozenset[_T_co]: ... - def difference(self, *s: Iterable[object]) -> frozenset[_T_co]: ... - def intersection(self, *s: Iterable[object]) -> frozenset[_T_co]: ... - def isdisjoint(self, __s: Iterable[_T_co]) -> bool: ... - def issubset(self, __s: Iterable[object]) -> bool: ... - def issuperset(self, __s: Iterable[object]) -> bool: ... - def symmetric_difference(self, __s: Iterable[_T_co]) -> frozenset[_T_co]: ... - def union(self, *s: Iterable[_S]) -> frozenset[_T_co | _S]: ... + def difference(self, *s: IterableOrSupportsIntGetItem[object]) -> frozenset[_T_co]: ... + def intersection(self, *s: IterableOrSupportsIntGetItem[object]) -> frozenset[_T_co]: ... + def isdisjoint(self, __s: IterableOrSupportsIntGetItem[_T_co]) -> bool: ... + def issubset(self, __s: IterableOrSupportsIntGetItem[object]) -> bool: ... + def issuperset(self, __s: IterableOrSupportsIntGetItem[object]) -> bool: ... + def symmetric_difference(self, __s: IterableOrSupportsIntGetItem[_T_co]) -> frozenset[_T_co]: ... + def union(self, *s: IterableOrSupportsIntGetItem[_S]) -> frozenset[_T_co | _S]: ... def __len__(self) -> int: ... def __contains__(self, __o: object) -> bool: ... def __iter__(self) -> Iterator[_T_co]: ... @@ -1140,7 +1142,7 @@ class frozenset(AbstractSet[_T_co], Generic[_T_co]): def __class_getitem__(cls, __item: Any) -> GenericAlias: ... class enumerate(Iterator[tuple[int, _T]], Generic[_T]): - def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ... + def __init__(self, iterable: IterableOrSupportsIntGetItem[_T], start: int = ...) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> tuple[int, _T]: ... if sys.version_info >= (3, 9): @@ -1197,8 +1199,8 @@ class _NotImplementedType(Any): # type: ignore[misc] NotImplemented: _NotImplementedType def abs(__x: SupportsAbs[_T]) -> _T: ... -def all(__iterable: Iterable[object]) -> bool: ... -def any(__iterable: Iterable[object]) -> bool: ... +def all(__iterable: IterableOrSupportsIntGetItem[object]) -> bool: ... +def any(__iterable: IterableOrSupportsIntGetItem[object]) -> bool: ... def ascii(__obj: object) -> str: ... def bin(__number: int | SupportsIndex) -> str: ... def breakpoint(*args: Any, **kws: Any) -> None: ... @@ -1283,11 +1285,11 @@ def exit(code: sys._ExitCode = ...) -> NoReturn: ... class filter(Iterator[_T], Generic[_T]): @overload - def __init__(self, __function: None, __iterable: Iterable[_T | None]) -> None: ... + def __init__(self, __function: None, __iterable: IterableOrSupportsIntGetItem[_T | None]) -> None: ... @overload - def __init__(self, __function: Callable[[_S], TypeGuard[_T]], __iterable: Iterable[_S]) -> None: ... + def __init__(self, __function: Callable[[_S], TypeGuard[_T]], __iterable: IterableOrSupportsIntGetItem[_S]) -> None: ... @overload - def __init__(self, __function: Callable[[_T], Any], __iterable: Iterable[_T]) -> None: ... + def __init__(self, __function: Callable[[_T], Any], __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... @@ -1316,13 +1318,10 @@ def hex(__number: int | SupportsIndex) -> str: ... def id(__obj: object) -> int: ... def input(__prompt: object = ...) -> str: ... -class _GetItemIterable(Protocol[_T_co]): - def __getitem__(self, __i: int) -> _T_co: ... - @overload def iter(__iterable: SupportsIter[_SupportsNextT]) -> _SupportsNextT: ... @overload -def iter(__iterable: _GetItemIterable[_T]) -> Iterator[_T]: ... +def iter(__iterable: SupportsIntGetItem[_T]) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], _T | None], __sentinel: None) -> Iterator[_T]: ... @overload @@ -1347,43 +1346,52 @@ def locals() -> dict[str, Any]: ... class map(Iterator[_S], Generic[_S]): @overload - def __init__(self, __func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> None: ... + def __init__(self, __func: Callable[[_T1], _S], __iter1: IterableOrSupportsIntGetItem[_T1]) -> None: ... @overload - def __init__(self, __func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> None: ... + def __init__( + self, + __func: Callable[[_T1, _T2], _S], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + ) -> None: ... @overload def __init__( - self, __func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] + self, + __func: Callable[[_T1, _T2, _T3], _S], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], ) -> None: ... @overload def __init__( self, __func: Callable[[_T1, _T2, _T3, _T4], _S], - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], ) -> None: ... @overload def __init__( self, __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S], - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], - __iter5: Iterable[_T5], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + __iter5: IterableOrSupportsIntGetItem[_T5], ) -> None: ... @overload def __init__( self, __func: Callable[..., _S], - __iter1: Iterable[Any], - __iter2: Iterable[Any], - __iter3: Iterable[Any], - __iter4: Iterable[Any], - __iter5: Iterable[Any], - __iter6: Iterable[Any], - *iterables: Iterable[Any], + __iter1: IterableOrSupportsIntGetItem[Any], + __iter2: IterableOrSupportsIntGetItem[Any], + __iter3: IterableOrSupportsIntGetItem[Any], + __iter4: IterableOrSupportsIntGetItem[Any], + __iter5: IterableOrSupportsIntGetItem[Any], + __iter6: IterableOrSupportsIntGetItem[Any], + *iterables: IterableOrSupportsIntGetItem[Any], ) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _S: ... @@ -1395,13 +1403,13 @@ def max( @overload def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsRichComparison]) -> _T: ... @overload -def max(__iterable: Iterable[SupportsRichComparisonT], *, key: None = ...) -> SupportsRichComparisonT: ... +def max(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ...) -> SupportsRichComparisonT: ... @overload -def max(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ... +def max(__iterable: IterableOrSupportsIntGetItem[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ... @overload -def max(__iterable: Iterable[SupportsRichComparisonT], *, key: None = ..., default: _T) -> SupportsRichComparisonT | _T: ... +def max(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., default: _T) -> SupportsRichComparisonT | _T: ... @overload -def max(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ... +def max(__iterable: IterableOrSupportsIntGetItem[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ... @overload def min( __arg1: SupportsRichComparisonT, __arg2: SupportsRichComparisonT, *_args: SupportsRichComparisonT, key: None = ... @@ -1409,13 +1417,13 @@ def min( @overload def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsRichComparison]) -> _T: ... @overload -def min(__iterable: Iterable[SupportsRichComparisonT], *, key: None = ...) -> SupportsRichComparisonT: ... +def min(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ...) -> SupportsRichComparisonT: ... @overload -def min(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ... +def min(__iterable: IterableOrSupportsIntGetItem[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ... @overload -def min(__iterable: Iterable[SupportsRichComparisonT], *, key: None = ..., default: _T) -> SupportsRichComparisonT | _T: ... +def min(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., default: _T) -> SupportsRichComparisonT | _T: ... @overload -def min(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ... +def min(__iterable: IterableOrSupportsIntGetItem[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ... @overload def next(__i: SupportsNext[_T]) -> _T: ... @overload @@ -1640,10 +1648,10 @@ def round(number: SupportsRound[_T], ndigits: SupportsIndex) -> _T: ... def setattr(__obj: object, __name: str, __value: Any) -> None: ... @overload def sorted( - __iterable: Iterable[SupportsRichComparisonT], *, key: None = ..., reverse: bool = ... + __iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., reverse: bool = ... ) -> list[SupportsRichComparisonT]: ... @overload -def sorted(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsRichComparison], reverse: bool = ...) -> list[_T]: ... +def sorted(__iterable: IterableOrSupportsIntGetItem[_T], *, key: Callable[[_T], SupportsRichComparison], reverse: bool = ...) -> list[_T]: ... _AddableT1 = TypeVar("_AddableT1", bound=SupportsAdd[Any, Any]) _AddableT2 = TypeVar("_AddableT2", bound=SupportsAdd[Any, Any]) @@ -1658,22 +1666,22 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit # Instead, we special-case the most common examples of this: bool and literal integers. if sys.version_info >= (3, 8): @overload - def sum(__iterable: Iterable[bool | _LiteralInteger], start: int = ...) -> int: ... # type: ignore[misc] + def sum(__iterable: IterableOrSupportsIntGetItem[bool | _LiteralInteger], start: int = ...) -> int: ... # type: ignore[misc] else: @overload - def sum(__iterable: Iterable[bool | _LiteralInteger], __start: int = ...) -> int: ... # type: ignore[misc] + def sum(__iterable: IterableOrSupportsIntGetItem[bool | _LiteralInteger], __start: int = ...) -> int: ... # type: ignore[misc] @overload -def sum(__iterable: Iterable[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ... +def sum(__iterable: IterableOrSupportsIntGetItem[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ... if sys.version_info >= (3, 8): @overload - def sum(__iterable: Iterable[_AddableT1], start: _AddableT2) -> _AddableT1 | _AddableT2: ... + def sum(__iterable: IterableOrSupportsIntGetItem[_AddableT1], start: _AddableT2) -> _AddableT1 | _AddableT2: ... else: @overload - def sum(__iterable: Iterable[_AddableT1], __start: _AddableT2) -> _AddableT1 | _AddableT2: ... + def sum(__iterable: IterableOrSupportsIntGetItem[_AddableT1], __start: _AddableT2) -> _AddableT1 | _AddableT2: ... # The argument to `vars()` has to have a `__dict__` attribute, so can't be annotated with `object` # (A "SupportsDunderDict" protocol doesn't work) @@ -1682,76 +1690,100 @@ def vars(__object: Any = ...) -> dict[str, Any]: ... class zip(Iterator[_T_co], Generic[_T_co]): if sys.version_info >= (3, 10): @overload - def __new__(cls, __iter1: Iterable[_T1], *, strict: bool = ...) -> zip[tuple[_T1]]: ... + def __new__(cls, __iter1: IterableOrSupportsIntGetItem[_T1], *, strict: bool = ...) -> zip[tuple[_T1]]: ... @overload - def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], *, strict: bool = ...) -> zip[tuple[_T1, _T2]]: ... + def __new__( + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + *, + strict: bool = ..., + ) -> zip[tuple[_T1, _T2]]: ... @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], *, strict: bool = ... + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + *, + strict: bool = ..., ) -> zip[tuple[_T1, _T2, _T3]]: ... @overload def __new__( cls, - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], *, strict: bool = ..., ) -> zip[tuple[_T1, _T2, _T3, _T4]]: ... @overload def __new__( cls, - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], - __iter5: Iterable[_T5], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + __iter5: IterableOrSupportsIntGetItem[_T5], *, strict: bool = ..., ) -> zip[tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def __new__( cls, - __iter1: Iterable[Any], - __iter2: Iterable[Any], - __iter3: Iterable[Any], - __iter4: Iterable[Any], - __iter5: Iterable[Any], - __iter6: Iterable[Any], - *iterables: Iterable[Any], + __iter1: IterableOrSupportsIntGetItem[Any], + __iter2: IterableOrSupportsIntGetItem[Any], + __iter3: IterableOrSupportsIntGetItem[Any], + __iter4: IterableOrSupportsIntGetItem[Any], + __iter5: IterableOrSupportsIntGetItem[Any], + __iter6: IterableOrSupportsIntGetItem[Any], + *iterables: IterableOrSupportsIntGetItem[Any], strict: bool = ..., ) -> zip[tuple[Any, ...]]: ... else: @overload - def __new__(cls, __iter1: Iterable[_T1]) -> zip[tuple[_T1]]: ... + def __new__(cls, __iter1: IterableOrSupportsIntGetItem[_T1]) -> zip[tuple[_T1]]: ... @overload - def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> zip[tuple[_T1, _T2]]: ... + def __new__( + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + ) -> zip[tuple[_T1, _T2]]: ... @overload - def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> zip[tuple[_T1, _T2, _T3]]: ... + def __new__( + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + ) -> zip[tuple[_T1, _T2, _T3]]: ... @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], ) -> zip[tuple[_T1, _T2, _T3, _T4]]: ... @overload def __new__( cls, - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], - __iter5: Iterable[_T5], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + __iter5: IterableOrSupportsIntGetItem[_T5], ) -> zip[tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def __new__( cls, - __iter1: Iterable[Any], - __iter2: Iterable[Any], - __iter3: Iterable[Any], - __iter4: Iterable[Any], - __iter5: Iterable[Any], - __iter6: Iterable[Any], - *iterables: Iterable[Any], + __iter1: IterableOrSupportsIntGetItem[Any], + __iter2: IterableOrSupportsIntGetItem[Any], + __iter3: IterableOrSupportsIntGetItem[Any], + __iter4: IterableOrSupportsIntGetItem[Any], + __iter5: IterableOrSupportsIntGetItem[Any], + __iter6: IterableOrSupportsIntGetItem[Any], + *iterables: IterableOrSupportsIntGetItem[Any], ) -> zip[tuple[Any, ...]]: ... def __iter__(self: Self) -> Self: ... From 37dc02480fe0a9f2facfbf85813bc124635f4bd5 Mon Sep 17 00:00:00 2001 From: Mikhail Ilchenko Date: Tue, 23 Aug 2022 15:02:38 +0400 Subject: [PATCH 3/5] Support `itertools` iteration with `__getitem__` --- stdlib/itertools.pyi | 236 ++++++++++++++++++++++++++++--------------- 1 file changed, 154 insertions(+), 82 deletions(-) diff --git a/stdlib/itertools.pyi b/stdlib/itertools.pyi index 7299ee8200db..74b3b81f163f 100644 --- a/stdlib/itertools.pyi +++ b/stdlib/itertools.pyi @@ -1,6 +1,6 @@ import sys -from _typeshed import Self -from collections.abc import Callable, Iterable, Iterator +from _typeshed import IterableOrSupportsIntGetItem, Self +from collections.abc import Callable, Iterator from typing import Any, Generic, SupportsComplex, SupportsFloat, SupportsInt, TypeVar, overload from typing_extensions import Literal, SupportsIndex, TypeAlias @@ -35,7 +35,7 @@ class count(Iterator[_N], Generic[_N]): def __iter__(self: Self) -> Self: ... class cycle(Iterator[_T], Generic[_T]): - def __init__(self, __iterable: Iterable[_T]) -> None: ... + def __init__(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def __next__(self) -> _T: ... def __iter__(self: Self) -> Self: ... @@ -51,118 +51,177 @@ class repeat(Iterator[_T], Generic[_T]): class accumulate(Iterator[_T], Generic[_T]): if sys.version_info >= (3, 8): @overload - def __init__(self, iterable: Iterable[_T], func: None = ..., *, initial: _T | None = ...) -> None: ... + def __init__( + self, + iterable: IterableOrSupportsIntGetItem[_T], + func: None = ..., + *, + initial: _T | None = ..., + ) -> None: ... @overload - def __init__(self, iterable: Iterable[_S], func: Callable[[_T, _S], _T], *, initial: _T | None = ...) -> None: ... + def __init__( + self, + iterable: IterableOrSupportsIntGetItem[_S], + func: Callable[[_T, _S], _T], + *, + initial: _T | None = ..., + ) -> None: ... else: - def __init__(self, iterable: Iterable[_T], func: Callable[[_T, _T], _T] | None = ...) -> None: ... + def __init__( + self, + iterable: IterableOrSupportsIntGetItem[_T], + func: Callable[[_T, _T], _T] | None = ..., + ) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... class chain(Iterator[_T], Generic[_T]): - def __init__(self, *iterables: Iterable[_T]) -> None: ... + def __init__(self, *iterables: IterableOrSupportsIntGetItem[_T]) -> None: ... def __next__(self) -> _T: ... def __iter__(self: Self) -> Self: ... @classmethod # We use type[Any] and not type[_S] to not lose the type inference from __iterable - def from_iterable(cls: type[Any], __iterable: Iterable[Iterable[_S]]) -> chain[_S]: ... + def from_iterable( + cls: type[Any], + __iterable: IterableOrSupportsIntGetItem[IterableOrSupportsIntGetItem[_S]], + ) -> chain[_S]: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, __item: Any) -> GenericAlias: ... class compress(Iterator[_T], Generic[_T]): - def __init__(self, data: Iterable[_T], selectors: Iterable[Any]) -> None: ... + def __init__( + self, + data: IterableOrSupportsIntGetItem[_T], + selectors: IterableOrSupportsIntGetItem[Any], + ) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... class dropwhile(Iterator[_T], Generic[_T]): - def __init__(self, __predicate: _Predicate[_T], __iterable: Iterable[_T]) -> None: ... + def __init__(self, __predicate: _Predicate[_T], __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... class filterfalse(Iterator[_T], Generic[_T]): - def __init__(self, __predicate: _Predicate[_T] | None, __iterable: Iterable[_T]) -> None: ... + def __init__(self, __predicate: _Predicate[_T] | None, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... class groupby(Iterator[tuple[_T, Iterator[_S]]], Generic[_T, _S]): @overload - def __new__(cls, iterable: Iterable[_T1], key: None = ...) -> groupby[_T1, _T1]: ... + def __new__(cls, iterable: IterableOrSupportsIntGetItem[_T1], key: None = ...) -> groupby[_T1, _T1]: ... @overload - def __new__(cls, iterable: Iterable[_T1], key: Callable[[_T1], _T2]) -> groupby[_T2, _T1]: ... + def __new__(cls, iterable: IterableOrSupportsIntGetItem[_T1], key: Callable[[_T1], _T2]) -> groupby[_T2, _T1]: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> tuple[_T, Iterator[_S]]: ... class islice(Iterator[_T], Generic[_T]): @overload - def __init__(self, __iterable: Iterable[_T], __stop: int | None) -> None: ... + def __init__(self, __iterable: IterableOrSupportsIntGetItem[_T], __stop: int | None) -> None: ... @overload - def __init__(self, __iterable: Iterable[_T], __start: int | None, __stop: int | None, __step: int | None = ...) -> None: ... + def __init__( + self, + __iterable: IterableOrSupportsIntGetItem[_T], + __start: int | None, + __stop: int | None, + __step: int | None = ..., + ) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... class starmap(Iterator[_T], Generic[_T]): - def __init__(self, __function: Callable[..., _T], __iterable: Iterable[Iterable[Any]]) -> None: ... + def __init__( + self, + __function: Callable[..., _T], + __iterable: IterableOrSupportsIntGetItem[IterableOrSupportsIntGetItem[Any]], + ) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... class takewhile(Iterator[_T], Generic[_T]): - def __init__(self, __predicate: _Predicate[_T], __iterable: Iterable[_T]) -> None: ... + def __init__(self, __predicate: _Predicate[_T], __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... -def tee(__iterable: Iterable[_T], __n: int = ...) -> tuple[Iterator[_T], ...]: ... +def tee(__iterable: IterableOrSupportsIntGetItem[_T], __n: int = ...) -> tuple[Iterator[_T], ...]: ... class zip_longest(Iterator[_T_co], Generic[_T_co]): # one iterable (fillvalue doesn't matter) @overload - def __new__(cls, __iter1: Iterable[_T1], *, fillvalue: object = ...) -> zip_longest[tuple[_T1]]: ... + def __new__(cls, __iter1: IterableOrSupportsIntGetItem[_T1], *, fillvalue: object = ...) -> zip_longest[tuple[_T1]]: ... # two iterables @overload # In the overloads without fillvalue, all of the tuple members could theoretically be None, # but we return Any instead to avoid false positives for code where we know one of the iterables # is longer. - def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> zip_longest[tuple[_T1 | Any, _T2 | Any]]: ... + def __new__( + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + ) -> zip_longest[tuple[_T1 | Any, _T2 | Any]]: ... @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], *, fillvalue: _T + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + *, + fillvalue: _T, ) -> zip_longest[tuple[_T1 | _T, _T2 | _T]]: ... # three iterables @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any]]: ... @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], *, fillvalue: _T + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + *, + fillvalue: _T, ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T]]: ... # four iterables @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any]]: ... @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], *, fillvalue: _T + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + *, + fillvalue: _T, ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T]]: ... # five iterables @overload def __new__( cls, - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], - __iter5: Iterable[_T5], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + __iter5: IterableOrSupportsIntGetItem[_T5], ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any, _T5 | Any]]: ... @overload def __new__( cls, - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], - __iter5: Iterable[_T5], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + __iter5: IterableOrSupportsIntGetItem[_T5], *, fillvalue: _T, ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T, _T5 | _T]]: ... @@ -170,24 +229,24 @@ class zip_longest(Iterator[_T_co], Generic[_T_co]): @overload def __new__( cls, - __iter1: Iterable[_T], - __iter2: Iterable[_T], - __iter3: Iterable[_T], - __iter4: Iterable[_T], - __iter5: Iterable[_T], - __iter6: Iterable[_T], - *iterables: Iterable[_T], + __iter1: IterableOrSupportsIntGetItem[_T], + __iter2: IterableOrSupportsIntGetItem[_T], + __iter3: IterableOrSupportsIntGetItem[_T], + __iter4: IterableOrSupportsIntGetItem[_T], + __iter5: IterableOrSupportsIntGetItem[_T], + __iter6: IterableOrSupportsIntGetItem[_T], + *iterables: IterableOrSupportsIntGetItem[_T], ) -> zip_longest[tuple[_T | Any, ...]]: ... @overload def __new__( cls, - __iter1: Iterable[_T], - __iter2: Iterable[_T], - __iter3: Iterable[_T], - __iter4: Iterable[_T], - __iter5: Iterable[_T], - __iter6: Iterable[_T], - *iterables: Iterable[_T], + __iter1: IterableOrSupportsIntGetItem[_T], + __iter2: IterableOrSupportsIntGetItem[_T], + __iter3: IterableOrSupportsIntGetItem[_T], + __iter4: IterableOrSupportsIntGetItem[_T], + __iter5: IterableOrSupportsIntGetItem[_T], + __iter6: IterableOrSupportsIntGetItem[_T], + *iterables: IterableOrSupportsIntGetItem[_T], fillvalue: _T, ) -> zip_longest[tuple[_T, ...]]: ... def __iter__(self: Self) -> Self: ... @@ -195,79 +254,92 @@ class zip_longest(Iterator[_T_co], Generic[_T_co]): class product(Iterator[_T_co], Generic[_T_co]): @overload - def __new__(cls, __iter1: Iterable[_T1]) -> product[tuple[_T1]]: ... + def __new__(cls, __iter1: IterableOrSupportsIntGetItem[_T1]) -> product[tuple[_T1]]: ... @overload - def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> product[tuple[_T1, _T2]]: ... + def __new__( + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + ) -> product[tuple[_T1, _T2]]: ... @overload - def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> product[tuple[_T1, _T2, _T3]]: ... + def __new__( + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + ) -> product[tuple[_T1, _T2, _T3]]: ... @overload def __new__( - cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] + cls, + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], ) -> product[tuple[_T1, _T2, _T3, _T4]]: ... @overload def __new__( cls, - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], - __iter5: Iterable[_T5], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + __iter5: IterableOrSupportsIntGetItem[_T5], ) -> product[tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def __new__( cls, - __iter1: Iterable[_T1], - __iter2: Iterable[_T2], - __iter3: Iterable[_T3], - __iter4: Iterable[_T4], - __iter5: Iterable[_T5], - __iter6: Iterable[_T6], + __iter1: IterableOrSupportsIntGetItem[_T1], + __iter2: IterableOrSupportsIntGetItem[_T2], + __iter3: IterableOrSupportsIntGetItem[_T3], + __iter4: IterableOrSupportsIntGetItem[_T4], + __iter5: IterableOrSupportsIntGetItem[_T5], + __iter6: IterableOrSupportsIntGetItem[_T6], ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ... @overload def __new__( cls, - __iter1: Iterable[Any], - __iter2: Iterable[Any], - __iter3: Iterable[Any], - __iter4: Iterable[Any], - __iter5: Iterable[Any], - __iter6: Iterable[Any], - __iter7: Iterable[Any], - *iterables: Iterable[Any], + __iter1: IterableOrSupportsIntGetItem[Any], + __iter2: IterableOrSupportsIntGetItem[Any], + __iter3: IterableOrSupportsIntGetItem[Any], + __iter4: IterableOrSupportsIntGetItem[Any], + __iter5: IterableOrSupportsIntGetItem[Any], + __iter6: IterableOrSupportsIntGetItem[Any], + __iter7: IterableOrSupportsIntGetItem[Any], + *iterables: IterableOrSupportsIntGetItem[Any], ) -> product[tuple[Any, ...]]: ... @overload - def __new__(cls, *iterables: Iterable[_T1], repeat: int) -> product[tuple[_T1, ...]]: ... + def __new__(cls, *iterables: IterableOrSupportsIntGetItem[_T1], repeat: int) -> product[tuple[_T1, ...]]: ... @overload - def __new__(cls, *iterables: Iterable[Any], repeat: int = ...) -> product[tuple[Any, ...]]: ... + def __new__(cls, *iterables: IterableOrSupportsIntGetItem[Any], repeat: int = ...) -> product[tuple[Any, ...]]: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T_co: ... class permutations(Iterator[tuple[_T, ...]], Generic[_T]): - def __init__(self, iterable: Iterable[_T], r: int | None = ...) -> None: ... + def __init__(self, iterable: IterableOrSupportsIntGetItem[_T], r: int | None = ...) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> tuple[_T, ...]: ... class combinations(Iterator[_T_co], Generic[_T_co]): @overload - def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ... + def __new__(cls, iterable: IterableOrSupportsIntGetItem[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ... @overload - def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> combinations[tuple[_T, _T, _T]]: ... + def __new__(cls, iterable: IterableOrSupportsIntGetItem[_T], r: Literal[3]) -> combinations[tuple[_T, _T, _T]]: ... @overload - def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> combinations[tuple[_T, _T, _T, _T]]: ... + def __new__(cls, iterable: IterableOrSupportsIntGetItem[_T], r: Literal[4]) -> combinations[tuple[_T, _T, _T, _T]]: ... @overload - def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> combinations[tuple[_T, _T, _T, _T, _T]]: ... + def __new__(cls, iterable: IterableOrSupportsIntGetItem[_T], r: Literal[5]) -> combinations[tuple[_T, _T, _T, _T, _T]]: ... @overload - def __new__(cls, iterable: Iterable[_T], r: int) -> combinations[tuple[_T, ...]]: ... + def __new__(cls, iterable: IterableOrSupportsIntGetItem[_T], r: int) -> combinations[tuple[_T, ...]]: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T_co: ... class combinations_with_replacement(Iterator[tuple[_T, ...]], Generic[_T]): - def __init__(self, iterable: Iterable[_T], r: int) -> None: ... + def __init__(self, iterable: IterableOrSupportsIntGetItem[_T], r: int) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> tuple[_T, ...]: ... if sys.version_info >= (3, 10): class pairwise(Iterator[_T_co], Generic[_T_co]): - def __new__(cls, __iterable: Iterable[_T]) -> pairwise[tuple[_T, _T]]: ... + def __new__(cls, __iterable: IterableOrSupportsIntGetItem[_T]) -> pairwise[tuple[_T, _T]]: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T_co: ... From f923643395916c732cf481ef14770f8733d5a193 Mon Sep 17 00:00:00 2001 From: Mikhail Ilchenko Date: Tue, 23 Aug 2022 15:02:47 +0400 Subject: [PATCH 4/5] Support `collections` iteration with `__getitem__` --- stdlib/collections/__init__.pyi | 63 ++++++++++++++++----------------- 1 file changed, 31 insertions(+), 32 deletions(-) diff --git a/stdlib/collections/__init__.pyi b/stdlib/collections/__init__.pyi index 37505c256d9c..5aa671bc83bd 100644 --- a/stdlib/collections/__init__.pyi +++ b/stdlib/collections/__init__.pyi @@ -1,6 +1,6 @@ import sys from _collections_abc import dict_items, dict_keys, dict_values -from _typeshed import Self, SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT +from _typeshed import IterableOrSupportsIntGetItem, Self, SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT from typing import Any, Generic, NoReturn, TypeVar, overload from typing_extensions import SupportsIndex, final @@ -11,7 +11,6 @@ if sys.version_info >= (3, 10): from collections.abc import ( Callable, ItemsView, - Iterable, Iterator, KeysView, Mapping, @@ -38,11 +37,11 @@ _VT_co = TypeVar("_VT_co", covariant=True) # namedtuple is special-cased in the type checker; the initializer is ignored. def namedtuple( typename: str, - field_names: str | Iterable[str], + field_names: str | IterableOrSupportsIntGetItem[str], *, rename: bool = ..., module: str | None = ..., - defaults: Iterable[Any] | None = ..., + defaults: IterableOrSupportsIntGetItem[Any] | None = ..., ) -> type[tuple[Any, ...]]: ... class UserDict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): @@ -57,11 +56,11 @@ class UserDict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): @overload def __init__(self: UserDict[str, _VT], __dict: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT) -> None: ... @overload - def __init__(self, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ... + def __init__(self, __iterable: IterableOrSupportsIntGetItem[tuple[_KT, _VT]]) -> None: ... @overload - def __init__(self: UserDict[str, _VT], __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT) -> None: ... + def __init__(self: UserDict[str, _VT], __iterable: IterableOrSupportsIntGetItem[tuple[str, _VT]], **kwargs: _VT) -> None: ... @overload - def __init__(self: UserDict[str, str], __iterable: Iterable[list[str]]) -> None: ... + def __init__(self: UserDict[str, str], __iterable: IterableOrSupportsIntGetItem[list[str]]) -> None: ... def __len__(self) -> int: ... def __getitem__(self, key: _KT) -> _VT: ... def __setitem__(self, key: _KT, item: _VT) -> None: ... @@ -76,10 +75,10 @@ class UserDict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): # See #3800 & https://github.com/python/typing/issues/548#issuecomment-683336963. @classmethod @overload - def fromkeys(cls, iterable: Iterable[_T], value: None = ...) -> UserDict[_T, Any | None]: ... + def fromkeys(cls, iterable: IterableOrSupportsIntGetItem[_T], value: None = ...) -> UserDict[_T, Any | None]: ... @classmethod @overload - def fromkeys(cls, iterable: Iterable[_T], value: _S) -> UserDict[_T, _S]: ... + def fromkeys(cls, iterable: IterableOrSupportsIntGetItem[_T], value: _S) -> UserDict[_T, _S]: ... if sys.version_info >= (3, 9): def __or__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ... def __ror__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ... # type: ignore[misc] @@ -87,14 +86,14 @@ class UserDict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): @overload # type: ignore[misc] def __ior__(self: Self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ... @overload - def __ior__(self: Self, other: Iterable[tuple[_KT, _VT]]) -> Self: ... + def __ior__(self: Self, other: IterableOrSupportsIntGetItem[tuple[_KT, _VT]]) -> Self: ... class UserList(MutableSequence[_T]): data: list[_T] @overload def __init__(self, initlist: None = ...) -> None: ... @overload - def __init__(self, initlist: Iterable[_T]) -> None: ... + def __init__(self, initlist: IterableOrSupportsIntGetItem[_T]) -> None: ... def __lt__(self, other: list[_T] | UserList[_T]) -> bool: ... def __le__(self, other: list[_T] | UserList[_T]) -> bool: ... def __gt__(self, other: list[_T] | UserList[_T]) -> bool: ... @@ -109,11 +108,11 @@ class UserList(MutableSequence[_T]): @overload def __setitem__(self, i: SupportsIndex, item: _T) -> None: ... @overload - def __setitem__(self, i: slice, item: Iterable[_T]) -> None: ... + def __setitem__(self, i: slice, item: IterableOrSupportsIntGetItem[_T]) -> None: ... def __delitem__(self, i: SupportsIndex | slice) -> None: ... - def __add__(self: Self, other: Iterable[_T]) -> Self: ... - def __radd__(self: Self, other: Iterable[_T]) -> Self: ... - def __iadd__(self: Self, other: Iterable[_T]) -> Self: ... + def __add__(self: Self, other: IterableOrSupportsIntGetItem[_T]) -> Self: ... + def __radd__(self: Self, other: IterableOrSupportsIntGetItem[_T]) -> Self: ... + def __iadd__(self: Self, other: IterableOrSupportsIntGetItem[_T]) -> Self: ... def __mul__(self: Self, n: int) -> Self: ... def __rmul__(self: Self, n: int) -> Self: ... def __imul__(self: Self, n: int) -> Self: ... @@ -131,7 +130,7 @@ class UserList(MutableSequence[_T]): def sort(self: UserList[SupportsRichComparisonT], *, key: None = ..., reverse: bool = ...) -> None: ... @overload def sort(self, *, key: Callable[[_T], SupportsRichComparison], reverse: bool = ...) -> None: ... - def extend(self, other: Iterable[_T]) -> None: ... + def extend(self, other: IterableOrSupportsIntGetItem[_T]) -> None: ... class UserString(Sequence[UserString]): data: str @@ -187,7 +186,7 @@ class UserString(Sequence[UserString]): def istitle(self) -> bool: ... def isupper(self) -> bool: ... def isascii(self) -> bool: ... - def join(self, seq: Iterable[str]) -> str: ... + def join(self, seq: IterableOrSupportsIntGetItem[str]) -> str: ... def ljust(self: Self, width: int, *args: Any) -> Self: ... def lower(self: Self) -> Self: ... def lstrip(self: Self, chars: str | None = ...) -> Self: ... @@ -225,13 +224,13 @@ class deque(MutableSequence[_T], Generic[_T]): @overload def __init__(self, *, maxlen: int | None = ...) -> None: ... @overload - def __init__(self, iterable: Iterable[_T], maxlen: int | None = ...) -> None: ... + def __init__(self, iterable: IterableOrSupportsIntGetItem[_T], maxlen: int | None = ...) -> None: ... def append(self, __x: _T) -> None: ... def appendleft(self, __x: _T) -> None: ... def copy(self: Self) -> Self: ... def count(self, __x: _T) -> int: ... - def extend(self, __iterable: Iterable[_T]) -> None: ... - def extendleft(self, __iterable: Iterable[_T]) -> None: ... + def extend(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... + def extendleft(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def insert(self, __i: int, __x: _T) -> None: ... def index(self, __x: _T, __start: int = ..., __stop: int = ...) -> int: ... def pop(self) -> _T: ... # type: ignore[override] @@ -246,7 +245,7 @@ class deque(MutableSequence[_T], Generic[_T]): def __delitem__(self, __i: SupportsIndex) -> None: ... # type: ignore[override] def __contains__(self, __o: object) -> bool: ... def __reduce__(self: Self) -> tuple[type[Self], tuple[()], None, Iterator[_T]]: ... - def __iadd__(self: Self, __iterable: Iterable[_T]) -> Self: ... + def __iadd__(self: Self, __iterable: IterableOrSupportsIntGetItem[_T]) -> Self: ... def __add__(self: Self, __other: Self) -> Self: ... def __mul__(self: Self, __other: int) -> Self: ... def __imul__(self: Self, __other: int) -> Self: ... @@ -265,7 +264,7 @@ class Counter(dict[_T, int], Generic[_T]): @overload def __init__(self, __mapping: SupportsKeysAndGetItem[_T, int]) -> None: ... @overload - def __init__(self, __iterable: Iterable[_T]) -> None: ... + def __init__(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... def copy(self: Self) -> Self: ... def elements(self) -> Iterator[_T]: ... def most_common(self, n: int | None = ...) -> list[tuple[_T, int]]: ... @@ -276,17 +275,17 @@ class Counter(dict[_T, int], Generic[_T]): @overload def subtract(self, __mapping: Mapping[_T, int]) -> None: ... @overload - def subtract(self, __iterable: Iterable[_T]) -> None: ... + def subtract(self, __iterable: IterableOrSupportsIntGetItem[_T]) -> None: ... # Unlike dict.update(), use Mapping instead of SupportsKeysAndGetItem for the first overload # (source code does an `isinstance(other, Mapping)` check) # # The second overload is also deliberately different to dict.update() - # (if it were `Iterable[_T] | Iterable[tuple[_T, int]]`, + # (if it were `IterableOrSupportsIntGetItem[_T] | IterableOrSupportsIntGetItem[tuple[_T, int]]`, # the tuples would be added as keys, breaking type safety) @overload # type: ignore[override] def update(self, __m: Mapping[_T, int], **kwargs: int) -> None: ... @overload - def update(self, __m: Iterable[_T], **kwargs: int) -> None: ... + def update(self, __m: IterableOrSupportsIntGetItem[_T], **kwargs: int) -> None: ... @overload def update(self, __m: None = ..., **kwargs: int) -> None: ... def __missing__(self, key: _T) -> int: ... @@ -352,10 +351,10 @@ class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]): # See #3800 & https://github.com/python/typing/issues/548#issuecomment-683336963. @classmethod @overload - def fromkeys(cls, iterable: Iterable[_T], value: None = ...) -> OrderedDict[_T, Any | None]: ... + def fromkeys(cls, iterable: IterableOrSupportsIntGetItem[_T], value: None = ...) -> OrderedDict[_T, Any | None]: ... @classmethod @overload - def fromkeys(cls, iterable: Iterable[_T], value: _S) -> OrderedDict[_T, _S]: ... + def fromkeys(cls, iterable: IterableOrSupportsIntGetItem[_T], value: _S) -> OrderedDict[_T, _S]: ... # Keep OrderedDict.setdefault in line with MutableMapping.setdefault, modulo positional-only differences. @overload def setdefault(self: OrderedDict[_KT, _T | None], key: _KT) -> _T | None: ... @@ -382,12 +381,12 @@ class defaultdict(dict[_KT, _VT], Generic[_KT, _VT]): **kwargs: _VT, ) -> None: ... @overload - def __init__(self, __default_factory: Callable[[], _VT] | None, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ... + def __init__(self, __default_factory: Callable[[], _VT] | None, __iterable: IterableOrSupportsIntGetItem[tuple[_KT, _VT]]) -> None: ... @overload def __init__( self: defaultdict[str, _VT], __default_factory: Callable[[], _VT] | None, - __iterable: Iterable[tuple[str, _VT]], + __iterable: IterableOrSupportsIntGetItem[tuple[str, _VT]], **kwargs: _VT, ) -> None: ... def __missing__(self, __key: _KT) -> _VT: ... @@ -418,10 +417,10 @@ class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]): # All arguments to `fromkeys` are passed to `dict.fromkeys` at runtime, so the signature should be kept in line with `dict.fromkeys`. @classmethod @overload - def fromkeys(cls, iterable: Iterable[_T], __value: None = ...) -> ChainMap[_T, Any | None]: ... + def fromkeys(cls, iterable: IterableOrSupportsIntGetItem[_T], __value: None = ...) -> ChainMap[_T, Any | None]: ... @classmethod @overload - def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> ChainMap[_T, _S]: ... + def fromkeys(cls, __iterable: IterableOrSupportsIntGetItem[_T], __value: _S) -> ChainMap[_T, _S]: ... if sys.version_info >= (3, 9): def __or__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ... def __ror__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ... @@ -429,4 +428,4 @@ class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]): @overload # type: ignore[misc] def __ior__(self: Self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ... @overload - def __ior__(self: Self, other: Iterable[tuple[_KT, _VT]]) -> Self: ... + def __ior__(self: Self, other: IterableOrSupportsIntGetItem[tuple[_KT, _VT]]) -> Self: ... From 0e5af3f0852dfdb4d5fbb17bee677f01e476bd7d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 23 Aug 2022 11:14:15 +0000 Subject: [PATCH 5/5] [pre-commit.ci] auto fixes from pre-commit.com hooks --- stdlib/builtins.pyi | 31 ++++++++++--------- stdlib/collections/__init__.pyi | 4 ++- stdlib/itertools.pyi | 53 +++++++-------------------------- 3 files changed, 30 insertions(+), 58 deletions(-) diff --git a/stdlib/builtins.pyi b/stdlib/builtins.pyi index d1639259db4a..3e52557b4a46 100644 --- a/stdlib/builtins.pyi +++ b/stdlib/builtins.pyi @@ -1317,7 +1317,6 @@ def help(request: object = ...) -> None: ... def hex(__number: int | SupportsIndex) -> str: ... def id(__obj: object) -> int: ... def input(__prompt: object = ...) -> str: ... - @overload def iter(__iterable: SupportsIter[_SupportsNextT]) -> _SupportsNextT: ... @overload @@ -1407,9 +1406,13 @@ def max(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, ke @overload def max(__iterable: IterableOrSupportsIntGetItem[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ... @overload -def max(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., default: _T) -> SupportsRichComparisonT | _T: ... +def max( + __iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., default: _T +) -> SupportsRichComparisonT | _T: ... @overload -def max(__iterable: IterableOrSupportsIntGetItem[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ... +def max( + __iterable: IterableOrSupportsIntGetItem[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2 +) -> _T1 | _T2: ... @overload def min( __arg1: SupportsRichComparisonT, __arg2: SupportsRichComparisonT, *_args: SupportsRichComparisonT, key: None = ... @@ -1421,9 +1424,13 @@ def min(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, ke @overload def min(__iterable: IterableOrSupportsIntGetItem[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ... @overload -def min(__iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., default: _T) -> SupportsRichComparisonT | _T: ... +def min( + __iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., default: _T +) -> SupportsRichComparisonT | _T: ... @overload -def min(__iterable: IterableOrSupportsIntGetItem[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ... +def min( + __iterable: IterableOrSupportsIntGetItem[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2 +) -> _T1 | _T2: ... @overload def next(__i: SupportsNext[_T]) -> _T: ... @overload @@ -1651,7 +1658,9 @@ def sorted( __iterable: IterableOrSupportsIntGetItem[SupportsRichComparisonT], *, key: None = ..., reverse: bool = ... ) -> list[SupportsRichComparisonT]: ... @overload -def sorted(__iterable: IterableOrSupportsIntGetItem[_T], *, key: Callable[[_T], SupportsRichComparison], reverse: bool = ...) -> list[_T]: ... +def sorted( + __iterable: IterableOrSupportsIntGetItem[_T], *, key: Callable[[_T], SupportsRichComparison], reverse: bool = ... +) -> list[_T]: ... _AddableT1 = TypeVar("_AddableT1", bound=SupportsAdd[Any, Any]) _AddableT2 = TypeVar("_AddableT2", bound=SupportsAdd[Any, Any]) @@ -1693,11 +1702,7 @@ class zip(Iterator[_T_co], Generic[_T_co]): def __new__(cls, __iter1: IterableOrSupportsIntGetItem[_T1], *, strict: bool = ...) -> zip[tuple[_T1]]: ... @overload def __new__( - cls, - __iter1: IterableOrSupportsIntGetItem[_T1], - __iter2: IterableOrSupportsIntGetItem[_T2], - *, - strict: bool = ..., + cls, __iter1: IterableOrSupportsIntGetItem[_T1], __iter2: IterableOrSupportsIntGetItem[_T2], *, strict: bool = ... ) -> zip[tuple[_T1, _T2]]: ... @overload def __new__( @@ -1746,9 +1751,7 @@ class zip(Iterator[_T_co], Generic[_T_co]): def __new__(cls, __iter1: IterableOrSupportsIntGetItem[_T1]) -> zip[tuple[_T1]]: ... @overload def __new__( - cls, - __iter1: IterableOrSupportsIntGetItem[_T1], - __iter2: IterableOrSupportsIntGetItem[_T2], + cls, __iter1: IterableOrSupportsIntGetItem[_T1], __iter2: IterableOrSupportsIntGetItem[_T2] ) -> zip[tuple[_T1, _T2]]: ... @overload def __new__( diff --git a/stdlib/collections/__init__.pyi b/stdlib/collections/__init__.pyi index 5aa671bc83bd..73bc32f4dd7a 100644 --- a/stdlib/collections/__init__.pyi +++ b/stdlib/collections/__init__.pyi @@ -381,7 +381,9 @@ class defaultdict(dict[_KT, _VT], Generic[_KT, _VT]): **kwargs: _VT, ) -> None: ... @overload - def __init__(self, __default_factory: Callable[[], _VT] | None, __iterable: IterableOrSupportsIntGetItem[tuple[_KT, _VT]]) -> None: ... + def __init__( + self, __default_factory: Callable[[], _VT] | None, __iterable: IterableOrSupportsIntGetItem[tuple[_KT, _VT]] + ) -> None: ... @overload def __init__( self: defaultdict[str, _VT], diff --git a/stdlib/itertools.pyi b/stdlib/itertools.pyi index 74b3b81f163f..b58dcf2bff45 100644 --- a/stdlib/itertools.pyi +++ b/stdlib/itertools.pyi @@ -51,27 +51,13 @@ class repeat(Iterator[_T], Generic[_T]): class accumulate(Iterator[_T], Generic[_T]): if sys.version_info >= (3, 8): @overload - def __init__( - self, - iterable: IterableOrSupportsIntGetItem[_T], - func: None = ..., - *, - initial: _T | None = ..., - ) -> None: ... + def __init__(self, iterable: IterableOrSupportsIntGetItem[_T], func: None = ..., *, initial: _T | None = ...) -> None: ... @overload def __init__( - self, - iterable: IterableOrSupportsIntGetItem[_S], - func: Callable[[_T, _S], _T], - *, - initial: _T | None = ..., + self, iterable: IterableOrSupportsIntGetItem[_S], func: Callable[[_T, _S], _T], *, initial: _T | None = ... ) -> None: ... else: - def __init__( - self, - iterable: IterableOrSupportsIntGetItem[_T], - func: Callable[[_T, _T], _T] | None = ..., - ) -> None: ... + def __init__(self, iterable: IterableOrSupportsIntGetItem[_T], func: Callable[[_T, _T], _T] | None = ...) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... @@ -83,18 +69,13 @@ class chain(Iterator[_T], Generic[_T]): @classmethod # We use type[Any] and not type[_S] to not lose the type inference from __iterable def from_iterable( - cls: type[Any], - __iterable: IterableOrSupportsIntGetItem[IterableOrSupportsIntGetItem[_S]], + cls: type[Any], __iterable: IterableOrSupportsIntGetItem[IterableOrSupportsIntGetItem[_S]] ) -> chain[_S]: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, __item: Any) -> GenericAlias: ... class compress(Iterator[_T], Generic[_T]): - def __init__( - self, - data: IterableOrSupportsIntGetItem[_T], - selectors: IterableOrSupportsIntGetItem[Any], - ) -> None: ... + def __init__(self, data: IterableOrSupportsIntGetItem[_T], selectors: IterableOrSupportsIntGetItem[Any]) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... @@ -121,20 +102,14 @@ class islice(Iterator[_T], Generic[_T]): def __init__(self, __iterable: IterableOrSupportsIntGetItem[_T], __stop: int | None) -> None: ... @overload def __init__( - self, - __iterable: IterableOrSupportsIntGetItem[_T], - __start: int | None, - __stop: int | None, - __step: int | None = ..., + self, __iterable: IterableOrSupportsIntGetItem[_T], __start: int | None, __stop: int | None, __step: int | None = ... ) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... class starmap(Iterator[_T], Generic[_T]): def __init__( - self, - __function: Callable[..., _T], - __iterable: IterableOrSupportsIntGetItem[IterableOrSupportsIntGetItem[Any]], + self, __function: Callable[..., _T], __iterable: IterableOrSupportsIntGetItem[IterableOrSupportsIntGetItem[Any]] ) -> None: ... def __iter__(self: Self) -> Self: ... def __next__(self) -> _T: ... @@ -156,17 +131,11 @@ class zip_longest(Iterator[_T_co], Generic[_T_co]): # but we return Any instead to avoid false positives for code where we know one of the iterables # is longer. def __new__( - cls, - __iter1: IterableOrSupportsIntGetItem[_T1], - __iter2: IterableOrSupportsIntGetItem[_T2], + cls, __iter1: IterableOrSupportsIntGetItem[_T1], __iter2: IterableOrSupportsIntGetItem[_T2] ) -> zip_longest[tuple[_T1 | Any, _T2 | Any]]: ... @overload def __new__( - cls, - __iter1: IterableOrSupportsIntGetItem[_T1], - __iter2: IterableOrSupportsIntGetItem[_T2], - *, - fillvalue: _T, + cls, __iter1: IterableOrSupportsIntGetItem[_T1], __iter2: IterableOrSupportsIntGetItem[_T2], *, fillvalue: _T ) -> zip_longest[tuple[_T1 | _T, _T2 | _T]]: ... # three iterables @overload @@ -257,9 +226,7 @@ class product(Iterator[_T_co], Generic[_T_co]): def __new__(cls, __iter1: IterableOrSupportsIntGetItem[_T1]) -> product[tuple[_T1]]: ... @overload def __new__( - cls, - __iter1: IterableOrSupportsIntGetItem[_T1], - __iter2: IterableOrSupportsIntGetItem[_T2], + cls, __iter1: IterableOrSupportsIntGetItem[_T1], __iter2: IterableOrSupportsIntGetItem[_T2] ) -> product[tuple[_T1, _T2]]: ... @overload def __new__(