Vi*7SrSSKJrJrJrJr SSKJr SSKJrJ r SSK JrJrJrJrJr SSKJr SSKJrJrJrJrJrJrJrJrJrJrJ r J!r! SS K"J#r# "S S \$5r%"S S \$5r&g!\ a \ r\ r NYf=f)aglom's helpers for streaming use cases. Specifier types which yield their results incrementally so that they can be applied to targets which are themselves streaming (e.g. chunks of rows from a database, lines from a file) without excessive memory usage. glom's streaming functionality revolves around a single :class:`Iter` Specifier type, which has methods to transform the target stream. )islice dropwhile takewhilechain)partial)imapifilter) split_iter chunked_iter windowed_iter unique_iterfirst)FunctionBuilder) glomTSTOPSKIP_MISSINGPathTargetRegistryCallSpecSbbreprformat_invocation)Checkc\rSrSrSr\4SjrSrSrSr Sr Sr \4S jr \ 4S jrS rSS jrSr\4SjrSrSr\4Sjr\4SjrSr\S 4SjrSrg )Itera``Iter()`` is glom's counterpart to Python's built-in :func:`iter()` function. Given an iterable target, ``Iter()`` yields the result of applying the passed spec to each element of the target, similar to the built-in ``[]`` spec, but streaming. The following turns a list of strings into integers using Iter(), before deduplicating and converting it to a tuple: >>> glom(['1', '2', '1', '3'], (Iter(int), set, tuple)) (1, 2, 3) ``Iter()`` also has many useful methods which can be chained to compose a stream processing pipeline. The above can also be written as: >>> glom(['1', '2', '1', '3'], (Iter().map(int).unique(), tuple)) (1, 2, 3) ``Iter()`` also respects glom's :data:`~glom.SKIP` and :data:`~glom.STOP` singletons for filtering and breaking iteration. Args: subspec: A subspec to be applied on each element from the iterable. sentinel: Keyword-only argument, which, when found in the iterable stream, causes the iteration to stop. Same as with the built-in :func:`iter`. c XlURS/5UlURS[5UlU(a[ S[ U5-5eg)N _iter_stacksentinelz unexpected keyword arguments: %r)subspecpopr"rr# TypeErrorsorted)selfr$kwargss a/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/glom/streaming.py__init__ Iter.__init__:sG !::mR8 :t4 >OP Pc SnUR[:wa UR4n[URRU[ S9nU/n[ UR5HupEn[X5n[R"U5nURSSUl UR5n /n [U5S:aU (a S[X5pURS[XEU [ S9-5 M SR!U5$)N)reprr.)r$rr __class____name__rreversedr"getattrr from_funcargs get_arg_nameslenzipappendjoin) r( base_argsbasechunksfnamer8_methfb arg_namesr)s r*__repr__ Iter.__repr__Cs <<1 I !8!8)&Q&t'7'78NE4'D **40BggabkBG((*IF4y1}!3y#7f MM# 1%vF SS T9wwvr-cURX5n[UR5Hu pEU"X25nM [U5$N)_iterater5r"iter)r(targetscopeiteratorrBcallbacks r*glomit Iter.glomitUs?==/&t'7'78NAq0H9H~r-c ## U[RSX[S9nU"U5nU[n[U5HhupxXg/-U['UR[LaUOU["XRU5n U [LaMKXRLd U [La gU v Mj g![a>n[ SUR R <S[U[6<SU<S35eSnAff=f7f)Niterate)pathz&failed to iterate on instance of type z at z (got ))r get_handlerr Exceptionr&r3r4 enumerater$rrrr#r) r(rLrMrSrNe base_pathitylds r*rJ Iter._iterate]s'33IvRVK3X RvH $K h'DA#c/E$K )1uT{1llE/RCd{ %I( ! R%//88$d :LaQR R Rs(C6B+BC6+ C359C..C33C6cV[U5"URXU4/UR-S9$)N)r$r")typer$r")r(opnamer8rOs r*_add_op Iter._add_opss+Dz$,,fH=U>> glom(range(5), Iter().map(lambda x: x * 2).all()) [0, 2, 4, 6, 8] Because a spec can be a callable, :meth:`Iter.map()` does everything the built-in :func:`map` does, but with the full power of glom specs. >>> glom(['a', 'B', 'C'], Iter().map(T.islower()).all()) [True, False, False] mapc(>^[UU4SjU5$)Nc&>T["UTT5$rIr)r\rMr$s r*,Iter.map....s%+a%8r-)r)iterablerMr$s `r*riIter.map..sD8(%Dr-rb)r(r$s `r*reIter.mapvs& ||  J DE Er-c~^[U[5(aUO [U[S9mURSU4U4Sj5$)aHReturn a new :class:`Iter()` spec which will include only elements matching the given *key*. >>> glom(range(6), Iter().filter(lambda x: x % 2).all()) [1, 3, 5] Because a spec can be a callable, :meth:`Iter.filter()` does everything the built-in :func:`filter` does, but with the full power of glom specs. For even more power, combine, :meth:`Iter.filter()` with :class:`Check()`. >>> # PROTIP: Python's ints know how many binary digits they require, using the bit_length method >>> glom(range(9), Iter().filter(Check(T.bit_length(), one_of=(2, 4), default=SKIP)).all()) [2, 3, 8] )defaultfilterc(>^[UU4SjU5$)Nc2>T["UTT5[L$rI)rr)r\ check_specrMs r*ri/Iter.filter....s%+aU;4Gr-)r )rkrMrts `r*riIter.filter..sGG%Sr-) isinstancerrrb)r(keyrts @r*rq Iter.filters@('sE22Sc48P ||  F ST Tr-cf^SU0mU4nU[La UTS'X24- nURSUU4Sj5$)aReturn a new :class:`Iter()` spec which groups elements in the iterable into lists of length *size*. If the optional *fill* argument is provided, iterables not evenly divisible by *size* will be padded out by the *fill* constant. Otherwise, the final chunk will be shorter than *size*. >>> list(glom(range(10), Iter().chunked(3))) [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] >>> list(glom(range(10), Iter().chunked(3, fill=None))) [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, None, None]] sizefillchunkedc>[U40TD6$rI)r )itrMkws r*riIter.chunked..s|B/E"/Er-)rrb)r(r{r|r8rs @r*r} Iter.chunkedsJd^u x BvJ GOD|| tEG Gr-c4^URST4U4Sj5$)aReturn a new :class:`Iter()` spec which will yield a sliding window of adjacent elements in the iterable. Each tuple yielded will be of length *size*. Useful for getting adjacent pairs and triples. >>> list(glom(range(4), Iter().windowed(2))) [(0, 1), (1, 2), (2, 3)] windowedc>[UT5$rI)r )rrMr{s r*riIter.windowed..s =T3Jr-rm)r(r{s `r*r Iter.windoweds"|| !JL Lr-Nc:^^URSTT4UU4Sj5$)aReturn a new :class:`Iter()` spec which will lazily split an iterable based on a separator (or list of separators), *sep*. Like :meth:`str.split()`, but for all iterables. ``split_iter()`` yields lists of non-separator values. A separator will never appear in the output. >>> target = [1, 2, None, None, 3, None, 4, None] >>> list(glom(target, Iter().split())) [[1, 2], [3], [4]] Note that ``split_iter`` is based on :func:`str.split`, so if *sep* is ``None``, ``split()`` **groups** separators. If empty lists are desired between two contiguous ``None`` values, simply use ``sep=[None]``: >>> list(glom(target, Iter().split(sep=[None]))) [[1, 2], [], [3], [4], []] A max number of splits may also be set: >>> list(glom(target, Iter().split(maxsplit=2))) [[1, 2], [3], [4, None]] splitc>[UTTS9$)N)sepmaxsplit)r )rrMrrs r*riIter.split..sjxHr-rm)r(rrs ``r*r Iter.splits%4||  (O HJ Jr-c*URSSS5$)zReturns a new :class:`Iter()` instance which combines iterables into a single iterable. >>> target = [[1, 2], [3, 4], [5]] >>> list(glom(target, Iter().flatten())) [1, 2, 3, 4, 5] flattenr/c.[R"U5$rI)r from_iterable)rrMs r*riIter.flatten..se11"5r-rmr(s r*r Iter.flattens||   57 7r-c4^URST4U4Sj5$)aReturn a new :class:`Iter()` spec which lazily filters out duplicate values, i.e., only the first appearance of a value in a stream will be yielded. >>> target = list('gloMolIcious') >>> out = list(glom(target, Iter().unique(T.lower()))) >>> print(''.join(out)) gloMIcus uniquec$>^[UUU4SjS9$)Nc&>T["UTT5$rIrhr\rxrMs r*ri/Iter.unique....sE$K3PU.s k"2VWr-rmr(rxs `r*r Iter.uniques#||  F WY Yr-c^[//TQ76 URSTU4Sj5$![a [ST<35ef=f)aReturns a new :class:`Iter()` spec which trims iterables in the same manner as :func:`itertools.islice`. >>> target = [0, 1, 2, 3, 4, 5] >>> glom(target, Iter().slice(3).all()) [0, 1, 2] >>> glom(target, Iter().slice(2, 4).all()) [2, 3] This method accepts only positional arguments. zinvalid slice arguments: slicec>[U/TQ76$rIr)rrMr8s r*riIter.slice..sVB=N=Nr-)rr&rb)r(r8s `r*r Iter.slicesM E 2  ||GT+NOO ETCD D Es &Ac4^URST4U4Sj5$)zvA convenient alias for :meth:`~Iter.slice`, which takes a single argument, *count*, the max number of items to yield. limitc>[UT5$rIr)rrMcounts r*riIter.limit..s EARr-rm)r(rs `r*r Iter.limits||GeX/RSSr-c4^URST4U4Sj5$)zReturns a new :class:`Iter()` spec which stops the stream once *key* becomes falsy. >>> glom([3, 2, 0, 1], Iter().takewhile().all()) [3, 2] :func:`itertools.takewhile` for more details. rc(>^[UU4SjU5$)Nc&>T["UTT5$rIrhrs r*ri2Iter.takewhile....,%+ae4r-)rrs `r*ri Iter.takewhile..+i4b:r-rmrs `r*rIter.takewhiles#||  F :; ;r-c4^URST4U4Sj5$)aReturns a new :class:`Iter()` spec which drops stream items until *key* becomes falsy. >>> glom([0, 0, 3, 2, 0], Iter().dropwhile(lambda t: t < 1).all()) [3, 2, 0] Note that while similar to :meth:`Iter.filter()`, the filter only applies to the beginning of the stream. In a way, :meth:`Iter.dropwhile` can be thought of as :meth:`~str.lstrip()` for streams. See :func:`itertools.dropwhile` for more details. rc(>^[UU4SjU5$)Nc&>T["UTT5$rIrhrs r*ri2Iter.dropwhile....Arr-)rrs `r*ri Iter.dropwhile..@rr-rmrs `r*rIter.dropwhile.s#||  F :; ;r-cU[4$)aA convenience method which returns a new spec which turns an iterable into a list. >>> glom(range(5), Iter(lambda t: t * 2).all()) [0, 2, 4, 6, 8] Note that this spec will always consume the whole iterable, and as such, the spec returned is *not* an :class:`Iter()` instance. )listrs r*allIter.allEsd|r-cU[XS94$)aA convenience method for lazily yielding a single truthy item from an iterable. >>> target = [False, 1, 2, 3] >>> glom(target, Iter().first()) 1 This method takes a condition, *key*, which can also be a glomspec, as well as a *default*, in case nothing matches the condition. As this spec yields at most one item, and not an iterable, the spec returned from this method is not an :class:`Iter()` instance. )rxrp)First)r(rxrps r*r Iter.firstQse566r-)r"r#r$)NN)r4 __module__ __qualname____firstlineno____doc__rr+rFrPrJrbrerqrr}rrrrrrrrrr__static_attributes__r/r-r*rrs< !$,kE,T6"*G* LJ> 7 Y P(T  ;;. 47r-rc6\rSrSrSrSr\S4SjrSrSr Sr g) riczGet the first element of an iterable which matches *key*, if there is one, otherwise return *default* (``None`` if unset). >>> is_odd = lambda x: x % 2 >>> glom([0, 1, 2, 3], First(is_odd)) 1 >>> glom([0, 2, 4], First(is_odd, default=False)) False )_spec_default_firstNcXlX l[[[[UR5R 4S[ 0S95n[[[4X#S.S9Ul g)NrM)r8r))rprx) rrrrrrrrrr)r(rxrp spec_gloms r*r+First.__init__ssK  gT$**-=-B-B,DgWX\Z[ 5t4Z[ r-c8URRX5$rI)rrP)r(rLrMs r*rP First.glomitzs{{!!&00r-cURRnURcU<S[UR5<S3$U<S[UR5<S[UR5<S3$)N(rUz , default=)r3r4rrr)r(cns r*rFFirst.__repr__}sN ^^ $ $ == !6$**#56 6')6$**+=vdmm?TUUr-)rrr) r4rrrr __slots__rr+rPrFrr/r-r*rrcs$0Id\1Vr-rN)'r itertoolsrrrr functoolsrrr ImportErrorrerqboltons.iterutilsr r r r rboltons.funcutilsrcorerrrrrrrrrrrrmatchingrobjectrrr/r-r*rsq :9' ZY-ooooE76E7P VFVg  DGsA++ A87A8