.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/stdlib/2/itertools.pyi

   1 # Stubs for itertools\r
   2 \r
   3 # Based on https://docs.python.org/2/library/itertools.html\r
   4 \r
   5 from typing import (Iterator, TypeVar, Iterable, overload, Any, Callable, Tuple,\r
   6                     Union, Sequence, Generic, Optional)\r
   7 \r
   8 _T = TypeVar('_T')\r
   9 _S = TypeVar('_S')\r
  10 \r
  11 def count(start: int = ...,\r
  12           step: int = ...) -> Iterator[int]: ...  # more general types?\r
  13 def cycle(iterable: Iterable[_T]) -> Iterator[_T]: ...\r
  14 \r
  15 def repeat(object: _T, times: int = ...) -> Iterator[_T]: ...\r
  16 \r
  17 def accumulate(iterable: Iterable[_T]) -> Iterator[_T]: ...\r
  18 \r
  19 class chain(Iterator[_T], Generic[_T]):\r
  20     def __init__(self, *iterables: Iterable[_T]) -> None: ...\r
  21     def next(self) -> _T: ...\r
  22     def __iter__(self) -> Iterator[_T]: ...\r
  23     @staticmethod\r
  24     def from_iterable(iterable: Iterable[Iterable[_S]]) -> Iterator[_S]: ...\r
  25 \r
  26 def compress(data: Iterable[_T], selectors: Iterable[Any]) -> Iterator[_T]: ...\r
  27 def dropwhile(predicate: Callable[[_T], Any],\r
  28               iterable: Iterable[_T]) -> Iterator[_T]: ...\r
  29 def ifilter(predicate: Optional[Callable[[_T], Any]],\r
  30             iterable: Iterable[_T]) -> Iterator[_T]: ...\r
  31 def ifilterfalse(predicate: Optional[Callable[[_T], Any]],\r
  32                  iterable: Iterable[_T]) -> Iterator[_T]: ...\r
  33 \r
  34 @overload\r
  35 def groupby(iterable: Iterable[_T]) -> Iterator[Tuple[_T, Iterator[_T]]]: ...\r
  36 @overload\r
  37 def groupby(iterable: Iterable[_T],\r
  38             key: Callable[[_T], _S]) -> Iterator[Tuple[_S, Iterator[_T]]]: ...\r
  39 \r
  40 @overload\r
  41 def islice(iterable: Iterable[_T], stop: Optional[int]) -> Iterator[_T]: ...\r
  42 @overload\r
  43 def islice(iterable: Iterable[_T], start: Optional[int], stop: Optional[int],\r
  44            step: Optional[int] = ...) -> Iterator[_T]: ...\r
  45 \r
  46 _T1 = TypeVar('_T1')\r
  47 _T2 = TypeVar('_T2')\r
  48 _T3 = TypeVar('_T3')\r
  49 _T4 = TypeVar('_T4')\r
  50 _T5 = TypeVar('_T5')\r
  51 _T6 = TypeVar('_T6')\r
  52 \r
  53 @overload\r
  54 def imap(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> Iterator[_S]: ...\r
  55 @overload\r
  56 def imap(func: Callable[[_T1, _T2], _S],\r
  57         iter1: Iterable[_T1],\r
  58         iter2: Iterable[_T2]) -> Iterator[_S]: ...\r
  59 @overload\r
  60 def imap(func: Callable[[_T1, _T2, _T3], _S],\r
  61          iter1: Iterable[_T1], iter2: Iterable[_T2],\r
  62          iter3: Iterable[_T3]) -> Iterator[_S]: ...\r
  63 \r
  64 @overload\r
  65 def imap(func: Callable[[_T1, _T2, _T3, _T4], _S],\r
  66          iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],\r
  67          iter4: Iterable[_T4]) -> Iterator[_S]: ...\r
  68 \r
  69 @overload\r
  70 def imap(func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],\r
  71          iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],\r
  72          iter4: Iterable[_T4], iter5: Iterable[_T5]) -> Iterator[_S]: ...\r
  73 \r
  74 @overload\r
  75 def imap(func: Callable[[_T1, _T2, _T3, _T4, _T5, _T6], _S],\r
  76          iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],\r
  77          iter4: Iterable[_T4], iter5: Iterable[_T5],\r
  78          iter6: Iterable[_T6]) -> Iterator[_S]: ...\r
  79 \r
  80 @overload\r
  81 def imap(func: Callable[..., _S],\r
  82          iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any],\r
  83          iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any],\r
  84          iter7: Iterable[Any], *iterables: Iterable[Any]) -> Iterator[_S]: ...\r
  85 \r
  86 def starmap(func: Any, iterable: Iterable[Any]) -> Iterator[Any]: ...\r
  87 def takewhile(predicate: Callable[[_T], Any],\r
  88               iterable: Iterable[_T]) -> Iterator[_T]: ...\r
  89 def tee(iterable: Iterable[_T], n: int = ...) -> Tuple[Iterator[_T], ...]: ...\r
  90 \r
  91 @overload\r
  92 def izip(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...\r
  93 @overload\r
  94 def izip(iter1: Iterable[_T1],\r
  95          iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...\r
  96 @overload\r
  97 def izip(iter1: Iterable[_T1], iter2: Iterable[_T2],\r
  98          iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...\r
  99 @overload\r
 100 def izip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],\r
 101          iter4: Iterable[_T4]) -> Iterator[Tuple[_T1, _T2,\r
 102                                            _T3, _T4]]: ...\r
 103 @overload\r
 104 def izip(iter1: Iterable[_T1], iter2: Iterable[_T2],\r
 105          iter3: Iterable[_T3], iter4: Iterable[_T4],\r
 106          iter5: Iterable[_T5]) -> Iterator[Tuple[_T1, _T2,\r
 107                                                  _T3, _T4, _T5]]: ...\r
 108 @overload\r
 109 def izip(iter1: Iterable[_T1], iter2: Iterable[_T2],\r
 110          iter3: Iterable[_T3], iter4: Iterable[_T4],\r
 111          iter5: Iterable[_T5], iter6: Iterable[_T6]) -> Iterator[Tuple[_T1, _T2, _T3,\r
 112                                                                  _T4, _T5, _T6]]: ...\r
 113 @overload\r
 114 def izip(iter1: Iterable[Any], iter2: Iterable[Any],\r
 115          iter3: Iterable[Any], iter4: Iterable[Any],\r
 116          iter5: Iterable[Any], iter6: Iterable[Any],\r
 117          iter7: Iterable[Any], *iterables: Iterable[Any]) -> Iterator[Tuple[Any, ...]]: ...\r
 118 \r
 119 def izip_longest(*p: Iterable[Any],\r
 120                  fillvalue: Any = ...) -> Iterator[Any]: ...\r
 121 \r
 122 @overload\r
 123 def product(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...\r
 124 @overload\r
 125 def product(iter1: Iterable[_T1],\r
 126             iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...\r
 127 @overload\r
 128 def product(iter1: Iterable[_T1],\r
 129             iter2: Iterable[_T2],\r
 130             iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...\r
 131 @overload\r
 132 def product(iter1: Iterable[_T1],\r
 133             iter2: Iterable[_T2],\r
 134             iter3: Iterable[_T3],\r
 135             iter4: Iterable[_T4]) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ...\r
 136 @overload\r
 137 def product(iter1: Iterable[_T1],\r
 138             iter2: Iterable[_T2],\r
 139             iter3: Iterable[_T3],\r
 140             iter4: Iterable[_T4],\r
 141             iter5: Iterable[_T5]) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...\r
 142 @overload\r
 143 def product(iter1: Iterable[_T1],\r
 144             iter2: Iterable[_T2],\r
 145             iter3: Iterable[_T3],\r
 146             iter4: Iterable[_T4],\r
 147             iter5: Iterable[_T5],\r
 148             iter6: Iterable[_T6]) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...\r
 149 @overload\r
 150 def product(iter1: Iterable[Any],\r
 151             iter2: Iterable[Any],\r
 152             iter3: Iterable[Any],\r
 153             iter4: Iterable[Any],\r
 154             iter5: Iterable[Any],\r
 155             iter6: Iterable[Any],\r
 156             iter7: Iterable[Any],\r
 157             *iterables: Iterable[Any]) -> Iterator[Tuple[Any, ...]]: ...\r
 158 @overload\r
 159 def product(*iterables: Iterable[Any], repeat: int) -> Iterator[Tuple[Any, ...]]: ...\r
 160 \r
 161 def permutations(iterable: Iterable[_T],\r
 162                  r: int = ...) -> Iterator[Sequence[_T]]: ...\r
 163 def combinations(iterable: Iterable[_T],\r
 164                  r: int) -> Iterator[Sequence[_T]]: ...\r
 165 def combinations_with_replacement(iterable: Iterable[_T],\r
 166                                   r: int) -> Iterator[Sequence[_T]]: ...\r