Vi-*SSKrSSKrSSKJr SSKJr SSKJrJrJrJ r J r J r J r SSK JrJrJrJr \"S5r\ "SS \5r"S S \5r"S S \5r"SS\5r"SS\5rSr"SS\5rSrg!\a \rNSf=f)N)pprint) make_sentinel)Tglom GlomErrorformat_invocationbbreprUnregisteredTargetMODE)GROUP target_iterACC_TREECUR_AGG_MISSINGc\rSrSrSrSrg) FoldErrorzbError raised when Fold() is called on non-iterable targets, and possibly other uses in the future.N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__ra/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/glom/reduction.pyrrs 7rrcP\rSrSrSr\R 4SjrSrSr Sr Sr Sr g ) FoldaThe `Fold` specifier type is glom's building block for reducing iterables in data, implementing the classic `fold `_ from functional programming, similar to Python's built-in :func:`reduce`. Args: subspec: A spec representing the target to fold, which must be an iterable, or otherwise registered to 'iterate' (with :func:`~glom.register`). init (callable): A function or type which will be invoked to initialize the accumulator value. op (callable): A function to call on the accumulator value and every value, the result of which will become the new accumulator value. Defaults to :func:`operator.iadd`. Usage is as follows: >>> target = [set([1, 2]), set([3]), set([2, 4])] >>> result = glom(target, Fold(T, init=frozenset, op=frozenset.union)) >>> result == frozenset([1, 2, 3, 4]) True Note the required ``spec`` and ``init`` arguments. ``op`` is optional, but here must be used because the :class:`set` and :class:`frozenset` types do not work with addition. While :class:`~glom.Fold` is powerful, :class:`~glom.Flatten` and :class:`~glom.Sum` are subtypes with more convenient defaults for day-to-day use. cXlX lX0l[U5(d'[ SUR R <SU<35e[U5(d'[ SUR R <SU<35eg)Nzexpected callable for z op param, not: z init param, not: )subspecinitopcallable TypeError __class__r)selfr"r#r$s r__init__ Fold.__init__:sj  ||!^^44b:; ;~~!^^44d<= =rc SnU[[La UR[5c X['SnUR[ LaU[ "XRU5nU(aURX[5$UR[X55$![aDn[SURR<S[U5R<SU<S35eSnAff=f)NFTz can only z on iterable targets, not z type ())r r getrr"rr_aggr_foldrr rr'rtype)r(targetscopeis_agguts rglomit Fold.glomitEs ;% EIIg$6$>!'NF <*2 =T" Krrc:^\rSrSrSr\\4U4SjjrSrSr U=r $)SumlaThe `Sum` specifier type is used to aggregate integers and other numericals using addition, much like the :func:`sum()` builtin. >>> glom(range(5), Sum()) 10 Note that this specifier takes a callable *init* parameter like its friends, so to change the start value, be sure to wrap it in a callable:: >>> glom(range(5), Sum(init=lambda: 5.0)) 15.0 To "sum" lists and other iterables, see the :class:`Flatten` spec. For other objects, see the :class:`Fold` specifier type. cF>[[U] X[RS9 g)Nr"r#r$)superrLr)rErFr(r"r#r's rr) Sum.__init__~s c4!'!OrcURRnUR[LaSO UR4nUR[ LaSUR0O0n[ XU[S9$)Nrr#rC)r'rr"rr#intr r r(rGargsrHs rrI Sum.__repr__sS ^^ $ $\\Q&rT\\O(, (<&$))$" 6??rr) rrrrrrrTr)rIr __classcell__r's@rrLrLls!" !sP@@rrLc6^\rSrSrSrSrU4SjrSrSrU=r $)CountzK takes a count of how many values occurred >>> glom([1, 2, 3], Count()) 3 rc>>[[U] [[SS9 g)Nc US-$)Nrr)curvals r Count.__init__..sS1WrrO)rPr[r)rrT)r(r's rr)Count.__init__s eT#C$< $ >rc4SURR-$)Nz%s())r'r)r(s rrICount.__repr__s////r) rrrrr __slots__r)rIrrXrYs@rr[r[s I>00rr[cF^\rSrSrSr\\4U4SjjrU4SjrSr Sr U=r $)FlattenaThe `Flatten` specifier type is used to combine iterables. By default it flattens an iterable of iterables into a single list containing items from all iterables. >>> target = [[1], [2, 3]] >>> glom(target, Flatten()) [1, 2, 3] You can also set *init* to ``"lazy"``, which returns a generator instead of a list. Use this to avoid making extra lists and other collections during intermediate processing steps. c|>US:XaSUl[nOSUl[[U]X[ R S9 g)NlazyTFrO)rklistrPrhr)rErFrQs rr)Flatten.__init__s5 6>DIDDI gt%gX]]%Src>UR(a[RRU5$[[ U]U5$r8)rk itertoolschain from_iterablerPrhr/)r(r;r's rr/ Flatten._folds1 99??00: :Wd)(33rcURRnUR[LaSO UR4n0nUR(aSUS'O"UR [ LaUR US'[XU[S9$)Nrrkr#rC) r'rr"rrkr#rlr r rUs rrIFlatten.__repr__sf ^^ $ $\\Q&rT\\O 99#F6N YYd "!YYF6N 6??r)rk) rrrrrrrlr)r/rIrrXrYs@rrhrhs&  !tT4 @@rrhc jURS[5nURS[5nURSS5nU(a%[S[ UR 55-5eUS:XaU$US:a[ SU-5eU4nU[SS 94US- -- nU[US 94- n[X5$) aNAt its most basic, ``flatten()`` turns an iterable of iterables into a single list. But it has a few arguments which give it more power: Args: init (callable): A function or type which gives the initial value of the return. The value must support addition. Common values might be :class:`list` (the default), :class:`tuple`, or even :class:`int`. You can also pass ``init="lazy"`` to get a generator. levels (int): A positive integer representing the number of nested levels to flatten. Defaults to 1. spec: The glomspec to fetch before flattening. This defaults to the the root level of the object. Usage is straightforward. >>> target = [[1, 2], [3], [4]] >>> flatten(target) [1, 2, 3, 4] Because integers themselves support addition, we actually have two levels of flattening possible, to get back a single integer sum: >>> flatten(target, init=int, levels=2) 10 However, flattening a non-iterable like an integer will raise an exception: >>> target = 10 >>> flatten(target) Traceback (most recent call last): ... FoldError: can only Flatten on iterable targets, not int type (...) By default, ``flatten()`` will add a mix of iterables together, making it a more-robust alternative to the built-in ``sum(list_of_lists, list())`` trick most experienced Python programmers are familiar with using: >>> list_of_iterables = [range(2), [2, 3], (4, 5)] >>> sum(list_of_iterables, []) Traceback (most recent call last): ... TypeError: can only concatenate list (not "tuple") to list Whereas flatten() handles this just fine: >>> flatten(list_of_iterables) [0, 1, 2, 3, 4, 5] The ``flatten()`` function is a convenient wrapper around the :class:`Flatten` specifier type. For embedding in larger specs, and more involved flattening, see :class:`Flatten` and its base, :class:`Fold`. specr#levelsrunexpected keyword args: %rrzexpected levels >= 0, not %rrk)r#) poprrlr&sortedkeys ValueErrorrhr)r1rHr"r#rwrvs rflattenr}sxjj#G ::fd #D ZZ! $F 5v{{}8MMNN {  z7&@AA :DW& ! #vz 22DW$  !!D  rcB^\rSrSrSr\\S4U4SjjrSrSr Sr U=r $)Mergei a+By default, Merge turns an iterable of mappings into a single, merged :class:`dict`, leveraging the behavior of the :meth:`~dict.update` method. The start state can be customized with *init*, as well as the update operation, with *op*. Args: subspec: The location of the iterable of mappings. Defaults to ``T``. init (callable): A type or callable which returns a base instance into which all other values will be merged. op (callable): A callable, which takes two arguments, and performs a merge of the second into the first. Can also be the string name of a method to fetch on the instance created from *init*. Defaults to ``"update"``. .. note:: Besides the differing defaults, the primary difference between :class:`Merge` and other :class:`Fold` subtypes is that its *op* argument is assumed to be a two-argument function which has no return value and modifies the left parameter in-place. Because the initial state is a new object created with the *init* parameter, none of the target values are modified. Nc>UcSn[U[5(aU"5n[[U5US5n[ U5(d[ SU<SU<35e[ [U]#XUS9 g)NupdatezEexpected callable "op" arg or an "init" with an .update() method not z and rO) isinstance basestringgetattrr0r%r|rPrr))r(r"r#r$ test_initr's rr)Merge.__init__$sj :B b* % %Ii"d3B||8:DBC C eT#G2#Frc^UR5URp2UH nU"X$5 M U$r8r9r:s rr/ Merge._fold/s-))+twwRA sJ rcdX;aUR5=o2U'OX nURX15 U$r8r9)r(r1r@accs rr. Merge._agg:s2  #yy{ *Ct**C  rr) rrrrrrdictr)r/r.rrXrYs@rrr s&0 !t Grrc URS[5nURS[5nURSS5nU(a%[S[ UR 55-5e[ X#U5n[X5$)aaBy default, ``merge()`` turns an iterable of mappings into a single, merged :class:`dict`, leveraging the behavior of the :meth:`~dict.update` method. A new mapping is created and none of the passed mappings are modified. >>> target = [{'a': 'alpha'}, {'b': 'B'}, {'a': 'A'}] >>> res = merge(target) >>> pprint(res) {'a': 'A', 'b': 'B'} Args: target: The list of dicts, or some other iterable of mappings. The start state can be customized with the *init* keyword argument, as well as the update operation, with the *op* keyword argument. For more on those customizations, see the :class:`Merge` spec. rvr#r$Nrx)ryrrr&rzr{rr)r1rHr"r#r$rvs rmergerCsj(jj#G ::fd #D D$ B 5v{{}8MMNN  #D  r)rErorboltons.typeutilsrcorerrrr r r r groupingr rrrrr NameErrorstrrobjectrrLr[rhr}rrrrrrs+YYY;;  $   OK6OKd@$@80D0""@d"@JJZ5D5pg JsBBB