.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stdlib/itertools.pyi

   1 import sys
   2 from _typeshed import _T_co
   3 from typing import (
   4     Any,
   5     Callable,
   6     Generic,
   7     Iterable,
   8     Iterator,
   9     SupportsComplex,
  10     SupportsFloat,
  11     SupportsInt,
  12     Tuple,
  13     Type,
  14     TypeVar,
  15     Union,
  16     overload,
  17 )
  18 from typing_extensions import Literal, SupportsIndex
  19
  20 _T = TypeVar("_T")
  21 _S = TypeVar("_S")
  22 _N = TypeVar("_N", int, float, SupportsFloat, SupportsInt, SupportsIndex, SupportsComplex)
  23 _Step = Union[int, float, SupportsFloat, SupportsInt, SupportsIndex, SupportsComplex]
  24
  25 Predicate = Callable[[_T], object]
  26
  27 # Technically count can take anything that implements a number protocol and has an add method
  28 # but we can't enforce the add method
  29 class count(Iterator[_N], Generic[_N]):
  30     @overload
  31     def __new__(cls) -> count[int]: ...
  32     @overload
  33     def __new__(cls, start: _N, step: _Step = ...) -> count[_N]: ...
  34     @overload
  35     def __new__(cls, *, step: _N) -> count[_N]: ...
  36     def __next__(self) -> _N: ...
  37     def __iter__(self) -> Iterator[_N]: ...
  38
  39 class cycle(Iterator[_T], Generic[_T]):
  40     def __init__(self, __iterable: Iterable[_T]) -> None: ...
  41     def __next__(self) -> _T: ...
  42     def __iter__(self) -> Iterator[_T]: ...
  43
  44 class repeat(Iterator[_T], Generic[_T]):
  45     @overload
  46     def __init__(self, object: _T) -> None: ...
  47     @overload
  48     def __init__(self, object: _T, times: int) -> None: ...
  49     def __next__(self) -> _T: ...
  50     def __iter__(self) -> Iterator[_T]: ...
  51
  52 class accumulate(Iterator[_T], Generic[_T]):
  53     if sys.version_info >= (3, 8):
  54         @overload
  55         def __init__(self, iterable: Iterable[_T], func: None = ..., *, initial: _T | None = ...) -> None: ...
  56         @overload
  57         def __init__(self, iterable: Iterable[_S], func: Callable[[_T, _S], _T], *, initial: _T | None = ...) -> None: ...
  58     else:
  59         def __init__(self, iterable: Iterable[_T], func: Callable[[_T, _T], _T] | None = ...) -> None: ...
  60     def __iter__(self) -> Iterator[_T]: ...
  61     def __next__(self) -> _T: ...
  62
  63 class chain(Iterator[_T], Generic[_T]):
  64     def __init__(self, *iterables: Iterable[_T]) -> None: ...
  65     def __next__(self) -> _T: ...
  66     def __iter__(self) -> Iterator[_T]: ...
  67     @classmethod
  68     # We use Type and not Type[_S] to not lose the type inference from __iterable
  69     def from_iterable(cls: Type[Any], __iterable: Iterable[Iterable[_S]]) -> Iterator[_S]: ...
  70
  71 class compress(Iterator[_T], Generic[_T]):
  72     def __init__(self, data: Iterable[_T], selectors: Iterable[Any]) -> None: ...
  73     def __iter__(self) -> Iterator[_T]: ...
  74     def __next__(self) -> _T: ...
  75
  76 class dropwhile(Iterator[_T], Generic[_T]):
  77     def __init__(self, __predicate: Predicate[_T], __iterable: Iterable[_T]) -> None: ...
  78     def __iter__(self) -> Iterator[_T]: ...
  79     def __next__(self) -> _T: ...
  80
  81 class filterfalse(Iterator[_T], Generic[_T]):
  82     def __init__(self, __predicate: Predicate[_T] | None, __iterable: Iterable[_T]) -> None: ...
  83     def __iter__(self) -> Iterator[_T]: ...
  84     def __next__(self) -> _T: ...
  85
  86 _T1 = TypeVar("_T1")
  87 _T2 = TypeVar("_T2")
  88
  89 class groupby(Iterator[Tuple[_T, Iterator[_S]]], Generic[_T, _S]):
  90     @overload
  91     def __new__(cls, iterable: Iterable[_T1], key: None = ...) -> groupby[_T1, _T1]: ...
  92     @overload
  93     def __new__(cls, iterable: Iterable[_T1], key: Callable[[_T1], _T2]) -> groupby[_T2, _T1]: ...
  94     def __iter__(self) -> Iterator[tuple[_T, Iterator[_S]]]: ...
  95     def __next__(self) -> tuple[_T, Iterator[_S]]: ...
  96
  97 class islice(Iterator[_T], Generic[_T]):
  98     @overload
  99     def __init__(self, __iterable: Iterable[_T], __stop: int | None) -> None: ...
 100     @overload
 101     def __init__(self, __iterable: Iterable[_T], __start: int | None, __stop: int | None, __step: int | None = ...) -> None: ...
 102     def __iter__(self) -> Iterator[_T]: ...
 103     def __next__(self) -> _T: ...
 104
 105 class starmap(Iterator[_T], Generic[_T]):
 106     def __init__(self, __function: Callable[..., _T], __iterable: Iterable[Iterable[Any]]) -> None: ...
 107     def __iter__(self) -> Iterator[_T]: ...
 108     def __next__(self) -> _T: ...
 109
 110 class takewhile(Iterator[_T], Generic[_T]):
 111     def __init__(self, __predicate: Predicate[_T], __iterable: Iterable[_T]) -> None: ...
 112     def __iter__(self) -> Iterator[_T]: ...
 113     def __next__(self) -> _T: ...
 114
 115 def tee(__iterable: Iterable[_T], __n: int = ...) -> Tuple[Iterator[_T], ...]: ...
 116
 117 class zip_longest(Iterator[Any]):
 118     def __init__(self, *p: Iterable[Any], fillvalue: Any = ...) -> None: ...
 119     def __iter__(self) -> Iterator[Any]: ...
 120     def __next__(self) -> Any: ...
 121
 122 _T3 = TypeVar("_T3")
 123 _T4 = TypeVar("_T4")
 124 _T5 = TypeVar("_T5")
 125 _T6 = TypeVar("_T6")
 126
 127 class product(Iterator[_T_co], Generic[_T_co]):
 128     @overload
 129     def __new__(cls, __iter1: Iterable[_T1]) -> product[tuple[_T1]]: ...
 130     @overload
 131     def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> product[tuple[_T1, _T2]]: ...
 132     @overload
 133     def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> product[tuple[_T1, _T2, _T3]]: ...
 134     @overload
 135     def __new__(
 136         cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4]
 137     ) -> product[tuple[_T1, _T2, _T3, _T4]]: ...
 138     @overload
 139     def __new__(
 140         cls,
 141         __iter1: Iterable[_T1],
 142         __iter2: Iterable[_T2],
 143         __iter3: Iterable[_T3],
 144         __iter4: Iterable[_T4],
 145         __iter5: Iterable[_T5],
 146     ) -> product[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
 147     @overload
 148     def __new__(
 149         cls,
 150         __iter1: Iterable[_T1],
 151         __iter2: Iterable[_T2],
 152         __iter3: Iterable[_T3],
 153         __iter4: Iterable[_T4],
 154         __iter5: Iterable[_T5],
 155         __iter6: Iterable[_T6],
 156     ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
 157     @overload
 158     def __new__(
 159         cls,
 160         __iter1: Iterable[Any],
 161         __iter2: Iterable[Any],
 162         __iter3: Iterable[Any],
 163         __iter4: Iterable[Any],
 164         __iter5: Iterable[Any],
 165         __iter6: Iterable[Any],
 166         __iter7: Iterable[Any],
 167         *iterables: Iterable[Any],
 168     ) -> product[Tuple[Any, ...]]: ...
 169     @overload
 170     def __new__(cls, *iterables: Iterable[_T1], repeat: int) -> product[Tuple[_T1, ...]]: ...
 171     @overload
 172     def __new__(cls, *iterables: Iterable[Any], repeat: int = ...) -> product[Tuple[Any, ...]]: ...
 173     def __iter__(self) -> Iterator[_T_co]: ...
 174     def __next__(self) -> _T_co: ...
 175
 176 class permutations(Iterator[Tuple[_T, ...]], Generic[_T]):
 177     def __init__(self, iterable: Iterable[_T], r: int | None = ...) -> None: ...
 178     def __iter__(self) -> Iterator[Tuple[_T, ...]]: ...
 179     def __next__(self) -> Tuple[_T, ...]: ...
 180
 181 class combinations(Iterator[_T_co], Generic[_T_co]):
 182     @overload
 183     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ...
 184     @overload
 185     def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> combinations[tuple[_T, _T, _T]]: ...
 186     @overload
 187     def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> combinations[tuple[_T, _T, _T, _T]]: ...
 188     @overload
 189     def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> combinations[tuple[_T, _T, _T, _T, _T]]: ...
 190     @overload
 191     def __new__(cls, iterable: Iterable[_T], r: int) -> combinations[Tuple[_T, ...]]: ...
 192     def __iter__(self) -> Iterator[_T_co]: ...
 193     def __next__(self) -> _T_co: ...
 194
 195 class combinations_with_replacement(Iterator[Tuple[_T, ...]], Generic[_T]):
 196     def __init__(self, iterable: Iterable[_T], r: int) -> None: ...
 197     def __iter__(self) -> Iterator[Tuple[_T, ...]]: ...
 198     def __next__(self) -> Tuple[_T, ...]: ...
 199
 200 if sys.version_info >= (3, 10):
 201     class pairwise(Iterator[_T_co], Generic[_T_co]):
 202         def __new__(cls, __iterable: Iterable[_T]) -> pairwise[tuple[_T, _T]]: ...
 203         def __iter__(self) -> Iterator[_T_co]: ...
 204         def __next__(self) -> _T_co: ...