codekingpro/portable-devtools

1"""Stubs for more_itertools.more"""2 3from __future__ import annotations4 5import sys6import types7 8from collections.abc import (9    Container,10    Hashable,11    Iterable,12    Iterator,13    Mapping,14    Reversible,15    Sequence,16    Sized,17)18from contextlib import AbstractContextManager19from typing import (20    Any,21    Callable,22    Generic,23    TypeVar,24    overload,25    type_check_only,26)27from typing_extensions import Protocol28 29__all__ = [30    'AbortThread',31    'SequenceView',32    'UnequalIterablesError',33    'adjacent',34    'all_unique',35    'always_iterable',36    'always_reversible',37    'argmax',38    'argmin',39    'bucket',40    'callback_iter',41    'chunked',42    'chunked_even',43    'circular_shifts',44    'collapse',45    'combination_index',46    'combination_with_replacement_index',47    'consecutive_groups',48    'constrained_batches',49    'consumer',50    'count_cycle',51    'countable',52    'derangements',53    'dft',54    'difference',55    'distinct_combinations',56    'distinct_permutations',57    'distribute',58    'divide',59    'doublestarmap',60    'duplicates_everseen',61    'duplicates_justseen',62    'classify_unique',63    'exactly_n',64    'extract',65    'filter_except',66    'filter_map',67    'first',68    'gray_product',69    'groupby_transform',70    'ichunked',71    'iequals',72    'idft',73    'ilen',74    'interleave',75    'interleave_evenly',76    'interleave_longest',77    'interleave_randomly',78    'intersperse',79    'is_sorted',80    'islice_extended',81    'iterate',82    'iter_suppress',83    'join_mappings',84    'last',85    'locate',86    'longest_common_prefix',87    'lstrip',88    'make_decorator',89    'map_except',90    'map_if',91    'map_reduce',92    'mark_ends',93    'minmax',94    'nth_or_last',95    'nth_permutation',96    'nth_prime',97    'nth_product',98    'nth_combination_with_replacement',99    'numeric_range',100    'one',101    'only',102    'outer_product',103    'padded',104    'partial_product',105    'partitions',106    'peekable',107    'permutation_index',108    'powerset_of_sets',109    'product_index',110    'raise_',111    'repeat_each',112    'repeat_last',113    'replace',114    'rlocate',115    'rstrip',116    'run_length',117    'sample',118    'seekable',119    'set_partitions',120    'side_effect',121    'sliced',122    'sort_together',123    'split_after',124    'split_at',125    'split_before',126    'split_into',127    'split_when',128    'spy',129    'stagger',130    'strip',131    'strictly_n',132    'substrings',133    'substrings_indexes',134    'takewhile_inclusive',135    'time_limited',136    'unique_in_window',137    'unique_to_each',138    'unzip',139    'value_chain',140    'windowed',141    'windowed_complete',142    'with_iter',143    'zip_broadcast',144    'zip_equal',145    'zip_offset',146]147 148# Type and type variable definitions149_T = TypeVar('_T')150_T1 = TypeVar('_T1')151_T2 = TypeVar('_T2')152_T3 = TypeVar('_T3')153_T4 = TypeVar('_T4')154_T5 = TypeVar('_T5')155_U = TypeVar('_U')156_V = TypeVar('_V')157_W = TypeVar('_W')158_T_co = TypeVar('_T_co', covariant=True)159_GenFn = TypeVar('_GenFn', bound=Callable[..., Iterator[Any]])160_Raisable = BaseException | type[BaseException]161 162# The type of isinstance's second argument (from typeshed builtins)163if sys.version_info >= (3, 10):164    _ClassInfo = type | types.UnionType | tuple[_ClassInfo, ...]165else:166    _ClassInfo = type | tuple[_ClassInfo, ...]167 168@type_check_only169class _SizedIterable(Protocol[_T_co], Sized, Iterable[_T_co]): ...170 171@type_check_only172class _SizedReversible(Protocol[_T_co], Sized, Reversible[_T_co]): ...173 174@type_check_only175class _SupportsSlicing(Protocol[_T_co]):176    def __getitem__(self, __k: slice) -> _T_co: ...177 178def chunked(179    iterable: Iterable[_T], n: int | None, strict: bool = ...180) -> Iterator[list[_T]]: ...181@overload182def first(iterable: Iterable[_T]) -> _T: ...183@overload184def first(iterable: Iterable[_T], default: _U) -> _T | _U: ...185@overload186def last(iterable: Iterable[_T]) -> _T: ...187@overload188def last(iterable: Iterable[_T], default: _U) -> _T | _U: ...189@overload190def nth_or_last(iterable: Iterable[_T], n: int) -> _T: ...191@overload192def nth_or_last(iterable: Iterable[_T], n: int, default: _U) -> _T | _U: ...193 194class peekable(Generic[_T], Iterator[_T]):195    def __init__(self, iterable: Iterable[_T]) -> None: ...196    def __iter__(self) -> peekable[_T]: ...197    def __bool__(self) -> bool: ...198    @overload199    def peek(self) -> _T: ...200    @overload201    def peek(self, default: _U) -> _T | _U: ...202    def prepend(self, *items: _T) -> None: ...203    def __next__(self) -> _T: ...204    @overload205    def __getitem__(self, index: int) -> _T: ...206    @overload207    def __getitem__(self, index: slice) -> list[_T]: ...208 209def consumer(func: _GenFn) -> _GenFn: ...210def ilen(iterable: Iterable[_T]) -> int: ...211def iterate(func: Callable[[_T], _T], start: _T) -> Iterator[_T]: ...212def with_iter(213    context_manager: AbstractContextManager[Iterable[_T]],214) -> Iterator[_T]: ...215def one(216    iterable: Iterable[_T],217    too_short: _Raisable | None = ...,218    too_long: _Raisable | None = ...,219) -> _T: ...220def raise_(exception: _Raisable, *args: Any) -> None: ...221def strictly_n(222    iterable: Iterable[_T],223    n: int,224    too_short: _GenFn | None = ...,225    too_long: _GenFn | None = ...,226) -> list[_T]: ...227def distinct_permutations(228    iterable: Iterable[_T], r: int | None = ...229) -> Iterator[tuple[_T, ...]]: ...230def derangements(231    iterable: Iterable[_T], r: int | None = None232) -> Iterator[tuple[_T, ...]]: ...233def intersperse(234    e: _U, iterable: Iterable[_T], n: int = ...235) -> Iterator[_T | _U]: ...236def unique_to_each(*iterables: Iterable[_T]) -> list[list[_T]]: ...237@overload238def windowed(239    seq: Iterable[_T], n: int, *, step: int = ...240) -> Iterator[tuple[_T | None, ...]]: ...241@overload242def windowed(243    seq: Iterable[_T], n: int, fillvalue: _U, step: int = ...244) -> Iterator[tuple[_T | _U, ...]]: ...245def substrings(iterable: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...246def substrings_indexes(247    seq: Sequence[_T], reverse: bool = ...248) -> Iterator[tuple[Sequence[_T], int, int]]: ...249 250class bucket(Generic[_T, _U], Container[_U]):251    def __init__(252        self,253        iterable: Iterable[_T],254        key: Callable[[_T], _U],255        validator: Callable[[_U], object] | None = ...,256    ) -> None: ...257    def __contains__(self, value: object) -> bool: ...258    def __iter__(self) -> Iterator[_U]: ...259    def __getitem__(self, value: object) -> Iterator[_T]: ...260 261def spy(262    iterable: Iterable[_T], n: int = ...263) -> tuple[list[_T], Iterator[_T]]: ...264def interleave(*iterables: Iterable[_T]) -> Iterator[_T]: ...265def interleave_longest(*iterables: Iterable[_T]) -> Iterator[_T]: ...266def interleave_evenly(267    iterables: list[Iterable[_T]], lengths: list[int] | None = ...268) -> Iterator[_T]: ...269def interleave_randomly(*iterables: Iterable[_T]) -> Iterable[_T]: ...270def collapse(271    iterable: Iterable[Any],272    base_type: _ClassInfo | None = ...,273    levels: int | None = ...,274) -> Iterator[Any]: ...275@overload276def side_effect(277    func: Callable[[_T], object],278    iterable: Iterable[_T],279    chunk_size: None = ...,280    before: Callable[[], object] | None = ...,281    after: Callable[[], object] | None = ...,282) -> Iterator[_T]: ...283@overload284def side_effect(285    func: Callable[[list[_T]], object],286    iterable: Iterable[_T],287    chunk_size: int,288    before: Callable[[], object] | None = ...,289    after: Callable[[], object] | None = ...,290) -> Iterator[_T]: ...291def sliced(292    seq: _SupportsSlicing[_T], n: int, strict: bool = ...293) -> Iterator[_T]: ...294def split_at(295    iterable: Iterable[_T],296    pred: Callable[[_T], object],297    maxsplit: int = ...,298    keep_separator: bool = ...,299) -> Iterator[list[_T]]: ...300def split_before(301    iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ...302) -> Iterator[list[_T]]: ...303def split_after(304    iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ...305) -> Iterator[list[_T]]: ...306def split_when(307    iterable: Iterable[_T],308    pred: Callable[[_T, _T], object],309    maxsplit: int = ...,310) -> Iterator[list[_T]]: ...311def split_into(312    iterable: Iterable[_T], sizes: Iterable[int | None]313) -> Iterator[list[_T]]: ...314@overload315def padded(316    iterable: Iterable[_T],317    *,318    n: int | None = ...,319    next_multiple: bool = ...,320) -> Iterator[_T | None]: ...321@overload322def padded(323    iterable: Iterable[_T],324    fillvalue: _U,325    n: int | None = ...,326    next_multiple: bool = ...,327) -> Iterator[_T | _U]: ...328@overload329def repeat_last(iterable: Iterable[_T]) -> Iterator[_T]: ...330@overload331def repeat_last(iterable: Iterable[_T], default: _U) -> Iterator[_T | _U]: ...332def distribute(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ...333@overload334def stagger(335    iterable: Iterable[_T],336    offsets: _SizedIterable[int] = ...,337    longest: bool = ...,338) -> Iterator[tuple[_T | None, ...]]: ...339@overload340def stagger(341    iterable: Iterable[_T],342    offsets: _SizedIterable[int] = ...,343    longest: bool = ...,344    fillvalue: _U = ...,345) -> Iterator[tuple[_T | _U, ...]]: ...346 347class UnequalIterablesError(ValueError):348    def __init__(self, details: tuple[int, int, int] | None = ...) -> None: ...349 350# zip_equal351@overload352def zip_equal(__iter1: Iterable[_T1]) -> Iterator[tuple[_T1]]: ...353@overload354def zip_equal(355    __iter1: Iterable[_T1], __iter2: Iterable[_T2]356) -> Iterator[tuple[_T1, _T2]]: ...357@overload358def zip_equal(359    __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]360) -> Iterator[tuple[_T1, _T2, _T3]]: ...361@overload362def zip_equal(363    __iter1: Iterable[_T1],364    __iter2: Iterable[_T2],365    __iter3: Iterable[_T3],366    __iter4: Iterable[_T4],367) -> Iterator[tuple[_T1, _T2, _T3, _T4]]: ...368@overload369def zip_equal(370    __iter1: Iterable[_T1],371    __iter2: Iterable[_T2],372    __iter3: Iterable[_T3],373    __iter4: Iterable[_T4],374    __iter5: Iterable[_T5],375) -> Iterator[tuple[_T1, _T2, _T3, _T4, _T5]]: ...376@overload377def zip_equal(378    __iter1: Iterable[Any],379    __iter2: Iterable[Any],380    __iter3: Iterable[Any],381    __iter4: Iterable[Any],382    __iter5: Iterable[Any],383    __iter6: Iterable[Any],384    *iterables: Iterable[Any],385) -> Iterator[tuple[Any, ...]]: ...386 387# zip_offset388@overload389def zip_offset(390    __iter1: Iterable[_T1],391    *,392    offsets: _SizedIterable[int],393    longest: bool = ...,394    fillvalue: None = None,395) -> Iterator[tuple[_T1 | None]]: ...396@overload397def zip_offset(398    __iter1: Iterable[_T1],399    __iter2: Iterable[_T2],400    *,401    offsets: _SizedIterable[int],402    longest: bool = ...,403    fillvalue: None = None,404) -> Iterator[tuple[_T1 | None, _T2 | None]]: ...405@overload406def zip_offset(407    __iter1: Iterable[_T],408    __iter2: Iterable[_T],409    __iter3: Iterable[_T],410    *iterables: Iterable[_T],411    offsets: _SizedIterable[int],412    longest: bool = ...,413    fillvalue: None = None,414) -> Iterator[tuple[_T | None, ...]]: ...415@overload416def zip_offset(417    __iter1: Iterable[_T1],418    *,419    offsets: _SizedIterable[int],420    longest: bool = ...,421    fillvalue: _U,422) -> Iterator[tuple[_T1 | _U]]: ...423@overload424def zip_offset(425    __iter1: Iterable[_T1],426    __iter2: Iterable[_T2],427    *,428    offsets: _SizedIterable[int],429    longest: bool = ...,430    fillvalue: _U,431) -> Iterator[tuple[_T1 | _U, _T2 | _U]]: ...432@overload433def zip_offset(434    __iter1: Iterable[_T],435    __iter2: Iterable[_T],436    __iter3: Iterable[_T],437    *iterables: Iterable[_T],438    offsets: _SizedIterable[int],439    longest: bool = ...,440    fillvalue: _U,441) -> Iterator[tuple[_T | _U, ...]]: ...442def sort_together(443    iterables: Iterable[Iterable[_T]],444    key_list: Iterable[int] = ...,445    key: Callable[..., Any] | None = ...,446    reverse: bool = ...,447    strict: bool = ...,448) -> list[tuple[_T, ...]]: ...449def unzip(iterable: Iterable[Sequence[_T]]) -> tuple[Iterator[_T], ...]: ...450def divide(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ...451def always_iterable(452    obj: object,453    base_type: _ClassInfo | None = ...,454) -> Iterator[Any]: ...455def adjacent(456    predicate: Callable[[_T], bool],457    iterable: Iterable[_T],458    distance: int = ...,459) -> Iterator[tuple[bool, _T]]: ...460@overload461def groupby_transform(462    iterable: Iterable[_T],463    keyfunc: None = None,464    valuefunc: None = None,465    reducefunc: None = None,466) -> Iterator[tuple[_T, Iterator[_T]]]: ...467@overload468def groupby_transform(469    iterable: Iterable[_T],470    keyfunc: Callable[[_T], _U],471    valuefunc: None,472    reducefunc: None,473) -> Iterator[tuple[_U, Iterator[_T]]]: ...474@overload475def groupby_transform(476    iterable: Iterable[_T],477    keyfunc: None,478    valuefunc: Callable[[_T], _V],479    reducefunc: None,480) -> Iterator[tuple[_T, Iterator[_V]]]: ...481@overload482def groupby_transform(483    iterable: Iterable[_T],484    keyfunc: Callable[[_T], _U],485    valuefunc: Callable[[_T], _V],486    reducefunc: None,487) -> Iterator[tuple[_U, Iterator[_V]]]: ...488@overload489def groupby_transform(490    iterable: Iterable[_T],491    keyfunc: None,492    valuefunc: None,493    reducefunc: Callable[[Iterator[_T]], _W],494) -> Iterator[tuple[_T, _W]]: ...495@overload496def groupby_transform(497    iterable: Iterable[_T],498    keyfunc: Callable[[_T], _U],499    valuefunc: None,500    reducefunc: Callable[[Iterator[_T]], _W],501) -> Iterator[tuple[_U, _W]]: ...502@overload503def groupby_transform(504    iterable: Iterable[_T],505    keyfunc: None,506    valuefunc: Callable[[_T], _V],507    reducefunc: Callable[[Iterator[_V]], _W],508) -> Iterator[tuple[_T, _W]]: ...509@overload510def groupby_transform(511    iterable: Iterable[_T],512    keyfunc: Callable[[_T], _U],513    valuefunc: Callable[[_T], _V],514    reducefunc: Callable[[Iterator[_V]], _W],515) -> Iterator[tuple[_U, _W]]: ...516 517class numeric_range(Generic[_T, _U], Sequence[_T], Hashable, Reversible[_T]):518    @overload519    def __init__(self, __stop: _T) -> None: ...520    @overload521    def __init__(self, __start: _T, __stop: _T) -> None: ...522    @overload523    def __init__(self, __start: _T, __stop: _T, __step: _U) -> None: ...524    def __bool__(self) -> bool: ...525    def __contains__(self, elem: object) -> bool: ...526    def __eq__(self, other: object) -> bool: ...527    @overload528    def __getitem__(self, key: int) -> _T: ...529    @overload530    def __getitem__(self, key: slice) -> numeric_range[_T, _U]: ...531    def __hash__(self) -> int: ...532    def __iter__(self) -> Iterator[_T]: ...533    def __len__(self) -> int: ...534    def __reduce__(535        self,536    ) -> tuple[type[numeric_range[_T, _U]], tuple[_T, _T, _U]]: ...537    def __repr__(self) -> str: ...538    def __reversed__(self) -> Iterator[_T]: ...539    def count(self, value: _T) -> int: ...540    def index(self, value: _T) -> int: ...  # type: ignore541 542def count_cycle(543    iterable: Iterable[_T], n: int | None = ...544) -> Iterable[tuple[int, _T]]: ...545def mark_ends(546    iterable: Iterable[_T],547) -> Iterable[tuple[bool, bool, _T]]: ...548def locate(549    iterable: Iterable[_T],550    pred: Callable[..., Any] = ...,551    window_size: int | None = ...,552) -> Iterator[int]: ...553def lstrip(554    iterable: Iterable[_T], pred: Callable[[_T], object]555) -> Iterator[_T]: ...556def rstrip(557    iterable: Iterable[_T], pred: Callable[[_T], object]558) -> Iterator[_T]: ...559def strip(560    iterable: Iterable[_T], pred: Callable[[_T], object]561) -> Iterator[_T]: ...562 563class islice_extended(Generic[_T], Iterator[_T]):564    def __init__(self, iterable: Iterable[_T], *args: int | None) -> None: ...565    def __iter__(self) -> islice_extended[_T]: ...566    def __next__(self) -> _T: ...567    def __getitem__(self, index: slice) -> islice_extended[_T]: ...568 569def always_reversible(iterable: Iterable[_T]) -> Iterator[_T]: ...570def consecutive_groups(571    iterable: Iterable[_T], ordering: None | Callable[[_T], int] = ...572) -> Iterator[Iterator[_T]]: ...573@overload574def difference(575    iterable: Iterable[_T],576    func: Callable[[_T, _T], _U] = ...,577    *,578    initial: None = ...,579) -> Iterator[_T | _U]: ...580@overload581def difference(582    iterable: Iterable[_T], func: Callable[[_T, _T], _U] = ..., *, initial: _U583) -> Iterator[_U]: ...584 585class SequenceView(Generic[_T], Sequence[_T]):586    def __init__(self, target: Sequence[_T]) -> None: ...587    @overload588    def __getitem__(self, index: int) -> _T: ...589    @overload590    def __getitem__(self, index: slice) -> Sequence[_T]: ...591    def __len__(self) -> int: ...592 593class seekable(Generic[_T], Iterator[_T]):594    def __init__(595        self, iterable: Iterable[_T], maxlen: int | None = ...596    ) -> None: ...597    def __iter__(self) -> seekable[_T]: ...598    def __next__(self) -> _T: ...599    def __bool__(self) -> bool: ...600    @overload601    def peek(self) -> _T: ...602    @overload603    def peek(self, default: _U) -> _T | _U: ...604    def elements(self) -> SequenceView[_T]: ...605    def seek(self, index: int) -> None: ...606    def relative_seek(self, count: int) -> None: ...607 608class run_length:609    @staticmethod610    def encode(iterable: Iterable[_T]) -> Iterator[tuple[_T, int]]: ...611    @staticmethod612    def decode(iterable: Iterable[tuple[_T, int]]) -> Iterator[_T]: ...613 614def exactly_n(615    iterable: Iterable[_T], n: int, predicate: Callable[[_T], object] = ...616) -> bool: ...617def circular_shifts(618    iterable: Iterable[_T], steps: int = 1619) -> list[tuple[_T, ...]]: ...620def make_decorator(621    wrapping_func: Callable[..., _U], result_index: int = ...622) -> Callable[..., Callable[[Callable[..., Any]], Callable[..., _U]]]: ...623@overload624def map_reduce(625    iterable: Iterable[_T],626    keyfunc: Callable[[_T], _U],627    valuefunc: None = ...,628    reducefunc: None = ...,629) -> dict[_U, list[_T]]: ...630@overload631def map_reduce(632    iterable: Iterable[_T],633    keyfunc: Callable[[_T], _U],634    valuefunc: Callable[[_T], _V],635    reducefunc: None = ...,636) -> dict[_U, list[_V]]: ...637@overload638def map_reduce(639    iterable: Iterable[_T],640    keyfunc: Callable[[_T], _U],641    valuefunc: None = ...,642    reducefunc: Callable[[list[_T]], _W] = ...,643) -> dict[_U, _W]: ...644@overload645def map_reduce(646    iterable: Iterable[_T],647    keyfunc: Callable[[_T], _U],648    valuefunc: Callable[[_T], _V],649    reducefunc: Callable[[list[_V]], _W],650) -> dict[_U, _W]: ...651def rlocate(652    iterable: Iterable[_T],653    pred: Callable[..., object] = ...,654    window_size: int | None = ...,655) -> Iterator[int]: ...656def replace(657    iterable: Iterable[_T],658    pred: Callable[..., object],659    substitutes: Iterable[_U],660    count: int | None = ...,661    window_size: int = ...,662) -> Iterator[_T | _U]: ...663def partitions(iterable: Iterable[_T]) -> Iterator[list[list[_T]]]: ...664def set_partitions(665    iterable: Iterable[_T],666    k: int | None = ...,667    min_size: int | None = ...,668    max_size: int | None = ...,669) -> Iterator[list[list[_T]]]: ...670 671class time_limited(Generic[_T], Iterator[_T]):672    def __init__(673        self, limit_seconds: float, iterable: Iterable[_T]674    ) -> None: ...675    def __iter__(self) -> islice_extended[_T]: ...676    def __next__(self) -> _T: ...677 678@overload679def only(680    iterable: Iterable[_T], *, too_long: _Raisable | None = ...681) -> _T | None: ...682@overload683def only(684    iterable: Iterable[_T], default: _U, too_long: _Raisable | None = ...685) -> _T | _U: ...686def ichunked(iterable: Iterable[_T], n: int) -> Iterator[Iterator[_T]]: ...687def distinct_combinations(688    iterable: Iterable[_T], r: int689) -> Iterator[tuple[_T, ...]]: ...690def filter_except(691    validator: Callable[[Any], object],692    iterable: Iterable[_T],693    *exceptions: type[BaseException],694) -> Iterator[_T]: ...695def map_except(696    function: Callable[[Any], _U],697    iterable: Iterable[_T],698    *exceptions: type[BaseException],699) -> Iterator[_U]: ...700def map_if(701    iterable: Iterable[Any],702    pred: Callable[[Any], bool],703    func: Callable[[Any], Any],704    func_else: Callable[[Any], Any] | None = ...,705) -> Iterator[Any]: ...706def _sample_unweighted(707    iterator: Iterator[_T], k: int, strict: bool708) -> list[_T]: ...709def _sample_counted(710    population: Iterator[_T], k: int, counts: Iterable[int], strict: bool711) -> list[_T]: ...712def _sample_weighted(713    iterator: Iterator[_T], k: int, weights: Iterator[float], strict: bool714) -> list[_T]: ...715def sample(716    iterable: Iterable[_T],717    k: int,718    weights: Iterable[float] | None = ...,719    *,720    counts: Iterable[int] | None = ...,721    strict: bool = False,722) -> list[_T]: ...723def is_sorted(724    iterable: Iterable[_T],725    key: Callable[[_T], _U] | None = ...,726    reverse: bool = False,727    strict: bool = False,728) -> bool: ...729 730class AbortThread(BaseException):731    pass732 733class callback_iter(Generic[_T], Iterator[_T]):734    def __init__(735        self,736        func: Callable[..., Any],737        callback_kwd: str = ...,738        wait_seconds: float = ...,739    ) -> None: ...740    def __enter__(self) -> callback_iter[_T]: ...741    def __exit__(742        self,743        exc_type: type[BaseException] | None,744        exc_value: BaseException | None,745        traceback: types.TracebackType | None,746    ) -> bool | None: ...747    def __iter__(self) -> callback_iter[_T]: ...748    def __next__(self) -> _T: ...749    def _reader(self) -> Iterator[_T]: ...750    @property751    def done(self) -> bool: ...752    @property753    def result(self) -> Any: ...754 755def windowed_complete(756    iterable: Iterable[_T], n: int757) -> Iterator[tuple[tuple[_T, ...], tuple[_T, ...], tuple[_T, ...]]]: ...758def all_unique(759    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...760) -> bool: ...761def nth_product(index: int, *args: Iterable[_T]) -> tuple[_T, ...]: ...762def nth_combination_with_replacement(763    iterable: Iterable[_T], r: int, index: int764) -> tuple[_T, ...]: ...765def nth_permutation(766    iterable: Iterable[_T], r: int, index: int767) -> tuple[_T, ...]: ...768def value_chain(*args: _T | Iterable[_T]) -> Iterable[_T]: ...769def product_index(element: Iterable[_T], *args: Iterable[_T]) -> int: ...770def combination_index(771    element: Iterable[_T], iterable: Iterable[_T]772) -> int: ...773def combination_with_replacement_index(774    element: Iterable[_T], iterable: Iterable[_T]775) -> int: ...776def permutation_index(777    element: Iterable[_T], iterable: Iterable[_T]778) -> int: ...779def repeat_each(iterable: Iterable[_T], n: int = ...) -> Iterator[_T]: ...780 781class countable(Generic[_T], Iterator[_T]):782    def __init__(self, iterable: Iterable[_T]) -> None: ...783    def __iter__(self) -> countable[_T]: ...784    def __next__(self) -> _T: ...785    items_seen: int786 787def chunked_even(iterable: Iterable[_T], n: int) -> Iterator[list[_T]]: ...788@overload789def zip_broadcast(790    __obj1: _T | Iterable[_T],791    *,792    scalar_types: _ClassInfo | None = ...,793    strict: bool = ...,794) -> Iterable[tuple[_T, ...]]: ...795@overload796def zip_broadcast(797    __obj1: _T | Iterable[_T],798    __obj2: _T | Iterable[_T],799    *,800    scalar_types: _ClassInfo | None = ...,801    strict: bool = ...,802) -> Iterable[tuple[_T, ...]]: ...803@overload804def zip_broadcast(805    __obj1: _T | Iterable[_T],806    __obj2: _T | Iterable[_T],807    __obj3: _T | Iterable[_T],808    *,809    scalar_types: _ClassInfo | None = ...,810    strict: bool = ...,811) -> Iterable[tuple[_T, ...]]: ...812@overload813def zip_broadcast(814    __obj1: _T | Iterable[_T],815    __obj2: _T | Iterable[_T],816    __obj3: _T | Iterable[_T],817    __obj4: _T | Iterable[_T],818    *,819    scalar_types: _ClassInfo | None = ...,820    strict: bool = ...,821) -> Iterable[tuple[_T, ...]]: ...822@overload823def zip_broadcast(824    __obj1: _T | Iterable[_T],825    __obj2: _T | Iterable[_T],826    __obj3: _T | Iterable[_T],827    __obj4: _T | Iterable[_T],828    __obj5: _T | Iterable[_T],829    *,830    scalar_types: _ClassInfo | None = ...,831    strict: bool = ...,832) -> Iterable[tuple[_T, ...]]: ...833@overload834def zip_broadcast(835    __obj1: _T | Iterable[_T],836    __obj2: _T | Iterable[_T],837    __obj3: _T | Iterable[_T],838    __obj4: _T | Iterable[_T],839    __obj5: _T | Iterable[_T],840    __obj6: _T | Iterable[_T],841    *objects: _T | Iterable[_T],842    scalar_types: _ClassInfo | None = ...,843    strict: bool = ...,844) -> Iterable[tuple[_T, ...]]: ...845def unique_in_window(846    iterable: Iterable[_T], n: int, key: Callable[[_T], _U] | None = ...847) -> Iterator[_T]: ...848def duplicates_everseen(849    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...850) -> Iterator[_T]: ...851def duplicates_justseen(852    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...853) -> Iterator[_T]: ...854def classify_unique(855    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...856) -> Iterator[tuple[_T, bool, bool]]: ...857 858class _SupportsLessThan(Protocol):859    def __lt__(self, __other: Any) -> bool: ...860 861_SupportsLessThanT = TypeVar("_SupportsLessThanT", bound=_SupportsLessThan)862 863@overload864def minmax(865    iterable_or_value: Iterable[_SupportsLessThanT], *, key: None = None866) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ...867@overload868def minmax(869    iterable_or_value: Iterable[_T], *, key: Callable[[_T], _SupportsLessThan]870) -> tuple[_T, _T]: ...871@overload872def minmax(873    iterable_or_value: Iterable[_SupportsLessThanT],874    *,875    key: None = None,876    default: _U,877) -> _U | tuple[_SupportsLessThanT, _SupportsLessThanT]: ...878@overload879def minmax(880    iterable_or_value: Iterable[_T],881    *,882    key: Callable[[_T], _SupportsLessThan],883    default: _U,884) -> _U | tuple[_T, _T]: ...885@overload886def minmax(887    iterable_or_value: _SupportsLessThanT,888    __other: _SupportsLessThanT,889    *others: _SupportsLessThanT,890) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ...891@overload892def minmax(893    iterable_or_value: _T,894    __other: _T,895    *others: _T,896    key: Callable[[_T], _SupportsLessThan],897) -> tuple[_T, _T]: ...898def longest_common_prefix(899    iterables: Iterable[Iterable[_T]],900) -> Iterator[_T]: ...901def iequals(*iterables: Iterable[Any]) -> bool: ...902def constrained_batches(903    iterable: Iterable[_T],904    max_size: int,905    max_count: int | None = ...,906    get_len: Callable[[_T], object] = ...,907    strict: bool = ...,908) -> Iterator[tuple[_T]]: ...909def gray_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...910def partial_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...911def takewhile_inclusive(912    predicate: Callable[[_T], bool], iterable: Iterable[_T]913) -> Iterator[_T]: ...914def outer_product(915    func: Callable[[_T, _U], _V],916    xs: Iterable[_T],917    ys: Iterable[_U],918    *args: Any,919    **kwargs: Any,920) -> Iterator[tuple[_V, ...]]: ...921def iter_suppress(922    iterable: Iterable[_T],923    *exceptions: type[BaseException],924) -> Iterator[_T]: ...925def filter_map(926    func: Callable[[_T], _V | None],927    iterable: Iterable[_T],928) -> Iterator[_V]: ...929def powerset_of_sets(iterable: Iterable[_T]) -> Iterator[set[_T]]: ...930def join_mappings(931    **field_to_map: Mapping[_T, _V],932) -> dict[_T, dict[str, _V]]: ...933def doublestarmap(934    func: Callable[..., _T],935    iterable: Iterable[Mapping[str, Any]],936) -> Iterator[_T]: ...937def dft(xarr: Sequence[complex]) -> Iterator[complex]: ...938def idft(Xarr: Sequence[complex]) -> Iterator[complex]: ...939def _nth_prime_ub(n: int) -> float: ...940def nth_prime(n: int, *, approximate: bool = ...) -> int: ...941def argmin(942    iterable: Iterable[_T], *, key: Callable[[_T], _U] | None = ...943) -> int: ...944def argmax(945    iterable: Iterable[_T], *, key: Callable[[_T], _U] | None = ...946) -> int: ...947def extract(948    iterable: Iterable[_T], indices: Iterable[int]949) -> Iterator[_T]: ...950