codekingpro/portable-devtools

1"""Stubs for more_itertools.more"""2from __future__ import annotations3 4from types import TracebackType5from typing import (6    Any,7    Callable,8    Container,9    ContextManager,10    Generic,11    Hashable,12    Iterable,13    Iterator,14    overload,15    Reversible,16    Sequence,17    Sized,18    Type,19    TypeVar,20    type_check_only,21)22from typing_extensions import Protocol23 24# Type and type variable definitions25_T = TypeVar('_T')26_T1 = TypeVar('_T1')27_T2 = TypeVar('_T2')28_U = TypeVar('_U')29_V = TypeVar('_V')30_W = TypeVar('_W')31_T_co = TypeVar('_T_co', covariant=True)32_GenFn = TypeVar('_GenFn', bound=Callable[..., Iterator[Any]])33_Raisable = BaseException | Type[BaseException]34 35@type_check_only36class _SizedIterable(Protocol[_T_co], Sized, Iterable[_T_co]): ...37 38@type_check_only39class _SizedReversible(Protocol[_T_co], Sized, Reversible[_T_co]): ...40 41@type_check_only42class _SupportsSlicing(Protocol[_T_co]):43    def __getitem__(self, __k: slice) -> _T_co: ...44 45def chunked(46    iterable: Iterable[_T], n: int | None, strict: bool = ...47) -> Iterator[list[_T]]: ...48@overload49def first(iterable: Iterable[_T]) -> _T: ...50@overload51def first(iterable: Iterable[_T], default: _U) -> _T | _U: ...52@overload53def last(iterable: Iterable[_T]) -> _T: ...54@overload55def last(iterable: Iterable[_T], default: _U) -> _T | _U: ...56@overload57def nth_or_last(iterable: Iterable[_T], n: int) -> _T: ...58@overload59def nth_or_last(iterable: Iterable[_T], n: int, default: _U) -> _T | _U: ...60 61class peekable(Generic[_T], Iterator[_T]):62    def __init__(self, iterable: Iterable[_T]) -> None: ...63    def __iter__(self) -> peekable[_T]: ...64    def __bool__(self) -> bool: ...65    @overload66    def peek(self) -> _T: ...67    @overload68    def peek(self, default: _U) -> _T | _U: ...69    def prepend(self, *items: _T) -> None: ...70    def __next__(self) -> _T: ...71    @overload72    def __getitem__(self, index: int) -> _T: ...73    @overload74    def __getitem__(self, index: slice) -> list[_T]: ...75 76def consumer(func: _GenFn) -> _GenFn: ...77def ilen(iterable: Iterable[_T]) -> int: ...78def iterate(func: Callable[[_T], _T], start: _T) -> Iterator[_T]: ...79def with_iter(80    context_manager: ContextManager[Iterable[_T]],81) -> Iterator[_T]: ...82def one(83    iterable: Iterable[_T],84    too_short: _Raisable | None = ...,85    too_long: _Raisable | None = ...,86) -> _T: ...87def raise_(exception: _Raisable, *args: Any) -> None: ...88def strictly_n(89    iterable: Iterable[_T],90    n: int,91    too_short: _GenFn | None = ...,92    too_long: _GenFn | None = ...,93) -> list[_T]: ...94def distinct_permutations(95    iterable: Iterable[_T], r: int | None = ...96) -> Iterator[tuple[_T, ...]]: ...97def intersperse(98    e: _U, iterable: Iterable[_T], n: int = ...99) -> Iterator[_T | _U]: ...100def unique_to_each(*iterables: Iterable[_T]) -> list[list[_T]]: ...101@overload102def windowed(103    seq: Iterable[_T], n: int, *, step: int = ...104) -> Iterator[tuple[_T | None, ...]]: ...105@overload106def windowed(107    seq: Iterable[_T], n: int, fillvalue: _U, step: int = ...108) -> Iterator[tuple[_T | _U, ...]]: ...109def substrings(iterable: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...110def substrings_indexes(111    seq: Sequence[_T], reverse: bool = ...112) -> Iterator[tuple[Sequence[_T], int, int]]: ...113 114class bucket(Generic[_T, _U], Container[_U]):115    def __init__(116        self,117        iterable: Iterable[_T],118        key: Callable[[_T], _U],119        validator: Callable[[_U], object] | None = ...,120    ) -> None: ...121    def __contains__(self, value: object) -> bool: ...122    def __iter__(self) -> Iterator[_U]: ...123    def __getitem__(self, value: object) -> Iterator[_T]: ...124 125def spy(126    iterable: Iterable[_T], n: int = ...127) -> tuple[list[_T], Iterator[_T]]: ...128def interleave(*iterables: Iterable[_T]) -> Iterator[_T]: ...129def interleave_longest(*iterables: Iterable[_T]) -> Iterator[_T]: ...130def interleave_evenly(131    iterables: list[Iterable[_T]], lengths: list[int] | None = ...132) -> Iterator[_T]: ...133def collapse(134    iterable: Iterable[Any],135    base_type: type | None = ...,136    levels: int | None = ...,137) -> Iterator[Any]: ...138@overload139def side_effect(140    func: Callable[[_T], object],141    iterable: Iterable[_T],142    chunk_size: None = ...,143    before: Callable[[], object] | None = ...,144    after: Callable[[], object] | None = ...,145) -> Iterator[_T]: ...146@overload147def side_effect(148    func: Callable[[list[_T]], object],149    iterable: Iterable[_T],150    chunk_size: int,151    before: Callable[[], object] | None = ...,152    after: Callable[[], object] | None = ...,153) -> Iterator[_T]: ...154def sliced(155    seq: _SupportsSlicing[_T], n: int, strict: bool = ...156) -> Iterator[_T]: ...157def split_at(158    iterable: Iterable[_T],159    pred: Callable[[_T], object],160    maxsplit: int = ...,161    keep_separator: bool = ...,162) -> Iterator[list[_T]]: ...163def split_before(164    iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ...165) -> Iterator[list[_T]]: ...166def split_after(167    iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ...168) -> Iterator[list[_T]]: ...169def split_when(170    iterable: Iterable[_T],171    pred: Callable[[_T, _T], object],172    maxsplit: int = ...,173) -> Iterator[list[_T]]: ...174def split_into(175    iterable: Iterable[_T], sizes: Iterable[int | None]176) -> Iterator[list[_T]]: ...177@overload178def padded(179    iterable: Iterable[_T],180    *,181    n: int | None = ...,182    next_multiple: bool = ...,183) -> Iterator[_T | None]: ...184@overload185def padded(186    iterable: Iterable[_T],187    fillvalue: _U,188    n: int | None = ...,189    next_multiple: bool = ...,190) -> Iterator[_T | _U]: ...191@overload192def repeat_last(iterable: Iterable[_T]) -> Iterator[_T]: ...193@overload194def repeat_last(iterable: Iterable[_T], default: _U) -> Iterator[_T | _U]: ...195def distribute(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ...196@overload197def stagger(198    iterable: Iterable[_T],199    offsets: _SizedIterable[int] = ...,200    longest: bool = ...,201) -> Iterator[tuple[_T | None, ...]]: ...202@overload203def stagger(204    iterable: Iterable[_T],205    offsets: _SizedIterable[int] = ...,206    longest: bool = ...,207    fillvalue: _U = ...,208) -> Iterator[tuple[_T | _U, ...]]: ...209 210class UnequalIterablesError(ValueError):211    def __init__(self, details: tuple[int, int, int] | None = ...) -> None: ...212 213@overload214def zip_equal(__iter1: Iterable[_T1]) -> Iterator[tuple[_T1]]: ...215@overload216def zip_equal(217    __iter1: Iterable[_T1], __iter2: Iterable[_T2]218) -> Iterator[tuple[_T1, _T2]]: ...219@overload220def zip_equal(221    __iter1: Iterable[_T],222    __iter2: Iterable[_T],223    __iter3: Iterable[_T],224    *iterables: Iterable[_T],225) -> Iterator[tuple[_T, ...]]: ...226@overload227def zip_offset(228    __iter1: Iterable[_T1],229    *,230    offsets: _SizedIterable[int],231    longest: bool = ...,232    fillvalue: None = None,233) -> Iterator[tuple[_T1 | None]]: ...234@overload235def zip_offset(236    __iter1: Iterable[_T1],237    __iter2: Iterable[_T2],238    *,239    offsets: _SizedIterable[int],240    longest: bool = ...,241    fillvalue: None = None,242) -> Iterator[tuple[_T1 | None, _T2 | None]]: ...243@overload244def zip_offset(245    __iter1: Iterable[_T],246    __iter2: Iterable[_T],247    __iter3: Iterable[_T],248    *iterables: Iterable[_T],249    offsets: _SizedIterable[int],250    longest: bool = ...,251    fillvalue: None = None,252) -> Iterator[tuple[_T | None, ...]]: ...253@overload254def zip_offset(255    __iter1: Iterable[_T1],256    *,257    offsets: _SizedIterable[int],258    longest: bool = ...,259    fillvalue: _U,260) -> Iterator[tuple[_T1 | _U]]: ...261@overload262def zip_offset(263    __iter1: Iterable[_T1],264    __iter2: Iterable[_T2],265    *,266    offsets: _SizedIterable[int],267    longest: bool = ...,268    fillvalue: _U,269) -> Iterator[tuple[_T1 | _U, _T2 | _U]]: ...270@overload271def zip_offset(272    __iter1: Iterable[_T],273    __iter2: Iterable[_T],274    __iter3: Iterable[_T],275    *iterables: Iterable[_T],276    offsets: _SizedIterable[int],277    longest: bool = ...,278    fillvalue: _U,279) -> Iterator[tuple[_T | _U, ...]]: ...280def sort_together(281    iterables: Iterable[Iterable[_T]],282    key_list: Iterable[int] = ...,283    key: Callable[..., Any] | None = ...,284    reverse: bool = ...,285) -> list[tuple[_T, ...]]: ...286def unzip(iterable: Iterable[Sequence[_T]]) -> tuple[Iterator[_T], ...]: ...287def divide(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ...288def always_iterable(289    obj: object,290    base_type: type | tuple[type | tuple[Any, ...], ...] | None = ...,291) -> Iterator[Any]: ...292def adjacent(293    predicate: Callable[[_T], bool],294    iterable: Iterable[_T],295    distance: int = ...,296) -> Iterator[tuple[bool, _T]]: ...297@overload298def groupby_transform(299    iterable: Iterable[_T],300    keyfunc: None = None,301    valuefunc: None = None,302    reducefunc: None = None,303) -> Iterator[tuple[_T, Iterator[_T]]]: ...304@overload305def groupby_transform(306    iterable: Iterable[_T],307    keyfunc: Callable[[_T], _U],308    valuefunc: None,309    reducefunc: None,310) -> Iterator[tuple[_U, Iterator[_T]]]: ...311@overload312def groupby_transform(313    iterable: Iterable[_T],314    keyfunc: None,315    valuefunc: Callable[[_T], _V],316    reducefunc: None,317) -> Iterable[tuple[_T, Iterable[_V]]]: ...318@overload319def groupby_transform(320    iterable: Iterable[_T],321    keyfunc: Callable[[_T], _U],322    valuefunc: Callable[[_T], _V],323    reducefunc: None,324) -> Iterable[tuple[_U, Iterator[_V]]]: ...325@overload326def groupby_transform(327    iterable: Iterable[_T],328    keyfunc: None,329    valuefunc: None,330    reducefunc: Callable[[Iterator[_T]], _W],331) -> Iterable[tuple[_T, _W]]: ...332@overload333def groupby_transform(334    iterable: Iterable[_T],335    keyfunc: Callable[[_T], _U],336    valuefunc: None,337    reducefunc: Callable[[Iterator[_T]], _W],338) -> Iterable[tuple[_U, _W]]: ...339@overload340def groupby_transform(341    iterable: Iterable[_T],342    keyfunc: None,343    valuefunc: Callable[[_T], _V],344    reducefunc: Callable[[Iterable[_V]], _W],345) -> Iterable[tuple[_T, _W]]: ...346@overload347def groupby_transform(348    iterable: Iterable[_T],349    keyfunc: Callable[[_T], _U],350    valuefunc: Callable[[_T], _V],351    reducefunc: Callable[[Iterable[_V]], _W],352) -> Iterable[tuple[_U, _W]]: ...353 354class numeric_range(Generic[_T, _U], Sequence[_T], Hashable, Reversible[_T]):355    @overload356    def __init__(self, __stop: _T) -> None: ...357    @overload358    def __init__(self, __start: _T, __stop: _T) -> None: ...359    @overload360    def __init__(self, __start: _T, __stop: _T, __step: _U) -> None: ...361    def __bool__(self) -> bool: ...362    def __contains__(self, elem: object) -> bool: ...363    def __eq__(self, other: object) -> bool: ...364    @overload365    def __getitem__(self, key: int) -> _T: ...366    @overload367    def __getitem__(self, key: slice) -> numeric_range[_T, _U]: ...368    def __hash__(self) -> int: ...369    def __iter__(self) -> Iterator[_T]: ...370    def __len__(self) -> int: ...371    def __reduce__(372        self,373    ) -> tuple[Type[numeric_range[_T, _U]], tuple[_T, _T, _U]]: ...374    def __repr__(self) -> str: ...375    def __reversed__(self) -> Iterator[_T]: ...376    def count(self, value: _T) -> int: ...377    def index(self, value: _T) -> int: ...  # type: ignore378 379def count_cycle(380    iterable: Iterable[_T], n: int | None = ...381) -> Iterable[tuple[int, _T]]: ...382def mark_ends(383    iterable: Iterable[_T],384) -> Iterable[tuple[bool, bool, _T]]: ...385def locate(386    iterable: Iterable[_T],387    pred: Callable[..., Any] = ...,388    window_size: int | None = ...,389) -> Iterator[int]: ...390def lstrip(391    iterable: Iterable[_T], pred: Callable[[_T], object]392) -> Iterator[_T]: ...393def rstrip(394    iterable: Iterable[_T], pred: Callable[[_T], object]395) -> Iterator[_T]: ...396def strip(397    iterable: Iterable[_T], pred: Callable[[_T], object]398) -> Iterator[_T]: ...399 400class islice_extended(Generic[_T], Iterator[_T]):401    def __init__(self, iterable: Iterable[_T], *args: int | None) -> None: ...402    def __iter__(self) -> islice_extended[_T]: ...403    def __next__(self) -> _T: ...404    def __getitem__(self, index: slice) -> islice_extended[_T]: ...405 406def always_reversible(iterable: Iterable[_T]) -> Iterator[_T]: ...407def consecutive_groups(408    iterable: Iterable[_T], ordering: Callable[[_T], int] = ...409) -> Iterator[Iterator[_T]]: ...410@overload411def difference(412    iterable: Iterable[_T],413    func: Callable[[_T, _T], _U] = ...,414    *,415    initial: None = ...,416) -> Iterator[_T | _U]: ...417@overload418def difference(419    iterable: Iterable[_T], func: Callable[[_T, _T], _U] = ..., *, initial: _U420) -> Iterator[_U]: ...421 422class SequenceView(Generic[_T], Sequence[_T]):423    def __init__(self, target: Sequence[_T]) -> None: ...424    @overload425    def __getitem__(self, index: int) -> _T: ...426    @overload427    def __getitem__(self, index: slice) -> Sequence[_T]: ...428    def __len__(self) -> int: ...429 430class seekable(Generic[_T], Iterator[_T]):431    def __init__(432        self, iterable: Iterable[_T], maxlen: int | None = ...433    ) -> None: ...434    def __iter__(self) -> seekable[_T]: ...435    def __next__(self) -> _T: ...436    def __bool__(self) -> bool: ...437    @overload438    def peek(self) -> _T: ...439    @overload440    def peek(self, default: _U) -> _T | _U: ...441    def elements(self) -> SequenceView[_T]: ...442    def seek(self, index: int) -> None: ...443    def relative_seek(self, count: int) -> None: ...444 445class run_length:446    @staticmethod447    def encode(iterable: Iterable[_T]) -> Iterator[tuple[_T, int]]: ...448    @staticmethod449    def decode(iterable: Iterable[tuple[_T, int]]) -> Iterator[_T]: ...450 451def exactly_n(452    iterable: Iterable[_T], n: int, predicate: Callable[[_T], object] = ...453) -> bool: ...454def circular_shifts(iterable: Iterable[_T]) -> list[tuple[_T, ...]]: ...455def make_decorator(456    wrapping_func: Callable[..., _U], result_index: int = ...457) -> Callable[..., Callable[[Callable[..., Any]], Callable[..., _U]]]: ...458@overload459def map_reduce(460    iterable: Iterable[_T],461    keyfunc: Callable[[_T], _U],462    valuefunc: None = ...,463    reducefunc: None = ...,464) -> dict[_U, list[_T]]: ...465@overload466def map_reduce(467    iterable: Iterable[_T],468    keyfunc: Callable[[_T], _U],469    valuefunc: Callable[[_T], _V],470    reducefunc: None = ...,471) -> dict[_U, list[_V]]: ...472@overload473def map_reduce(474    iterable: Iterable[_T],475    keyfunc: Callable[[_T], _U],476    valuefunc: None = ...,477    reducefunc: Callable[[list[_T]], _W] = ...,478) -> dict[_U, _W]: ...479@overload480def map_reduce(481    iterable: Iterable[_T],482    keyfunc: Callable[[_T], _U],483    valuefunc: Callable[[_T], _V],484    reducefunc: Callable[[list[_V]], _W],485) -> dict[_U, _W]: ...486def rlocate(487    iterable: Iterable[_T],488    pred: Callable[..., object] = ...,489    window_size: int | None = ...,490) -> Iterator[int]: ...491def replace(492    iterable: Iterable[_T],493    pred: Callable[..., object],494    substitutes: Iterable[_U],495    count: int | None = ...,496    window_size: int = ...,497) -> Iterator[_T | _U]: ...498def partitions(iterable: Iterable[_T]) -> Iterator[list[list[_T]]]: ...499def set_partitions(500    iterable: Iterable[_T], k: int | None = ...501) -> Iterator[list[list[_T]]]: ...502 503class time_limited(Generic[_T], Iterator[_T]):504    def __init__(505        self, limit_seconds: float, iterable: Iterable[_T]506    ) -> None: ...507    def __iter__(self) -> islice_extended[_T]: ...508    def __next__(self) -> _T: ...509 510@overload511def only(512    iterable: Iterable[_T], *, too_long: _Raisable | None = ...513) -> _T | None: ...514@overload515def only(516    iterable: Iterable[_T], default: _U, too_long: _Raisable | None = ...517) -> _T | _U: ...518def ichunked(iterable: Iterable[_T], n: int) -> Iterator[Iterator[_T]]: ...519def distinct_combinations(520    iterable: Iterable[_T], r: int521) -> Iterator[tuple[_T, ...]]: ...522def filter_except(523    validator: Callable[[Any], object],524    iterable: Iterable[_T],525    *exceptions: Type[BaseException],526) -> Iterator[_T]: ...527def map_except(528    function: Callable[[Any], _U],529    iterable: Iterable[_T],530    *exceptions: Type[BaseException],531) -> Iterator[_U]: ...532def map_if(533    iterable: Iterable[Any],534    pred: Callable[[Any], bool],535    func: Callable[[Any], Any],536    func_else: Callable[[Any], Any] | None = ...,537) -> Iterator[Any]: ...538def sample(539    iterable: Iterable[_T],540    k: int,541    weights: Iterable[float] | None = ...,542) -> list[_T]: ...543def is_sorted(544    iterable: Iterable[_T],545    key: Callable[[_T], _U] | None = ...,546    reverse: bool = False,547    strict: bool = False,548) -> bool: ...549 550class AbortThread(BaseException):551    pass552 553class callback_iter(Generic[_T], Iterator[_T]):554    def __init__(555        self,556        func: Callable[..., Any],557        callback_kwd: str = ...,558        wait_seconds: float = ...,559    ) -> None: ...560    def __enter__(self) -> callback_iter[_T]: ...561    def __exit__(562        self,563        exc_type: Type[BaseException] | None,564        exc_value: BaseException | None,565        traceback: TracebackType | None,566    ) -> bool | None: ...567    def __iter__(self) -> callback_iter[_T]: ...568    def __next__(self) -> _T: ...569    def _reader(self) -> Iterator[_T]: ...570    @property571    def done(self) -> bool: ...572    @property573    def result(self) -> Any: ...574 575def windowed_complete(576    iterable: Iterable[_T], n: int577) -> Iterator[tuple[_T, ...]]: ...578def all_unique(579    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...580) -> bool: ...581def nth_product(index: int, *args: Iterable[_T]) -> tuple[_T, ...]: ...582def nth_combination_with_replacement(583    iterable: Iterable[_T], r: int, index: int584) -> tuple[_T, ...]: ...585def nth_permutation(586    iterable: Iterable[_T], r: int, index: int587) -> tuple[_T, ...]: ...588def value_chain(*args: _T | Iterable[_T]) -> Iterable[_T]: ...589def product_index(element: Iterable[_T], *args: Iterable[_T]) -> int: ...590def combination_index(591    element: Iterable[_T], iterable: Iterable[_T]592) -> int: ...593def combination_with_replacement_index(594    element: Iterable[_T], iterable: Iterable[_T]595) -> int: ...596def permutation_index(597    element: Iterable[_T], iterable: Iterable[_T]598) -> int: ...599def repeat_each(iterable: Iterable[_T], n: int = ...) -> Iterator[_T]: ...600 601class countable(Generic[_T], Iterator[_T]):602    def __init__(self, iterable: Iterable[_T]) -> None: ...603    def __iter__(self) -> countable[_T]: ...604    def __next__(self) -> _T: ...605 606def chunked_even(iterable: Iterable[_T], n: int) -> Iterator[list[_T]]: ...607def zip_broadcast(608    *objects: _T | Iterable[_T],609    scalar_types: type | tuple[type | tuple[Any, ...], ...] | None = ...,610    strict: bool = ...,611) -> Iterable[tuple[_T, ...]]: ...612def unique_in_window(613    iterable: Iterable[_T], n: int, key: Callable[[_T], _U] | None = ...614) -> Iterator[_T]: ...615def duplicates_everseen(616    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...617) -> Iterator[_T]: ...618def duplicates_justseen(619    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...620) -> Iterator[_T]: ...621def classify_unique(622    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...623) -> Iterator[tuple[_T, bool, bool]]: ...624 625class _SupportsLessThan(Protocol):626    def __lt__(self, __other: Any) -> bool: ...627 628_SupportsLessThanT = TypeVar("_SupportsLessThanT", bound=_SupportsLessThan)629 630@overload631def minmax(632    iterable_or_value: Iterable[_SupportsLessThanT], *, key: None = None633) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ...634@overload635def minmax(636    iterable_or_value: Iterable[_T], *, key: Callable[[_T], _SupportsLessThan]637) -> tuple[_T, _T]: ...638@overload639def minmax(640    iterable_or_value: Iterable[_SupportsLessThanT],641    *,642    key: None = None,643    default: _U,644) -> _U | tuple[_SupportsLessThanT, _SupportsLessThanT]: ...645@overload646def minmax(647    iterable_or_value: Iterable[_T],648    *,649    key: Callable[[_T], _SupportsLessThan],650    default: _U,651) -> _U | tuple[_T, _T]: ...652@overload653def minmax(654    iterable_or_value: _SupportsLessThanT,655    __other: _SupportsLessThanT,656    *others: _SupportsLessThanT,657) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ...658@overload659def minmax(660    iterable_or_value: _T,661    __other: _T,662    *others: _T,663    key: Callable[[_T], _SupportsLessThan],664) -> tuple[_T, _T]: ...665def longest_common_prefix(666    iterables: Iterable[Iterable[_T]],667) -> Iterator[_T]: ...668def iequals(*iterables: Iterable[Any]) -> bool: ...669def constrained_batches(670    iterable: Iterable[_T],671    max_size: int,672    max_count: int | None = ...,673    get_len: Callable[[_T], object] = ...,674    strict: bool = ...,675) -> Iterator[tuple[_T]]: ...676def gray_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...677def partial_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...678def takewhile_inclusive(679    predicate: Callable[[_T], bool], iterable: Iterable[_T]680) -> Iterator[_T]: ...681def outer_product(682    func: Callable[[_T, _U], _V],683    xs: Iterable[_T],684    ys: Iterable[_U],685    *args: Any,686    **kwargs: Any,687) -> Iterator[tuple[_V, ...]]: ...688def iter_suppress(689    iterable: Iterable[_T],690    *exceptions: Type[BaseException],691) -> Iterator[_T]: ...692def filter_map(693    func: Callable[[_T], _V | None],694    iterable: Iterable[_T],695) -> Iterator[_V]: ...696