i!"dZddlmZddlmZddlZddlZddlZ ddl m Z m Z m Z mZmZddlmZmZdZej(d Zej(d Zej(d Zej(d Zej2dd Zej2ddZej2ddZej2ddZdZej2dddZej2 ddZej2 ddZej2 ddZej2dddZej2 ddZej2ddZej2ddZddZ d ddZej2 d ddZej2 d ddZej2 d ddZej2 d ddZej2 d dd Zej2 d dd!Zdd"Zej2 d dd#Zej2 d dd$Zej2 d dd%Zej2 d dd&Zej2 d dd'Zej2 d dd(Zdd)Zej2 d dd*Zej2 d dd+Zej2 d dd,Zej2 d dd-Zej2 d dd.Zej2 d dd/Zdd0Zej2 dd1Z ej2 dd2Z ej2 dd3Z ej2 dd4Z ej2dd5Z ej2dd6Z ej2ddd7Z ej2ddd8Z ej2 dd9Z ej2 dd:Z ej2 dd;Z ej2 dd<Z ej2dd=Z ej2dd>Z ej2ddd?Z ej2ddd@Z ddAZ ej2 d ddBZ!ej2 d ddCZ!ej2 d ddDZ!ej2 d ddEZ!ej2 d ddFZ!ej2 d ddGZ!ddHZ!ej2 d ddIZ"ej2 d ddJZ"ej2 d ddKZ"ej2 d ddLZ"ej2 d ddMZ"ej2 d ddNZ"ddOZ"ej2 d ddPZ#ej2 d ddQZ#ej2 d ddRZ#ej2 d ddSZ#ej2 d ddTZ#ej2 d ddUZ#ddVZ#ej2 ddWZ$ej2 ddXZ$ej2 ddYZ$ej2 d dZZ$ej2 d d[Z$ej2 d d\Z$d]Z$ej2d d^Z%ej2 d d d_Z%dd`Z% d ddaZ& ddbZ'ej2ddcZ(ej2 d dddZ(ddeZ(ej2ddfZ)ej2ddgZ)ej2 ddhZ)ej2ddiZ)ej2ddjZ)ej2 ddkZ)ej2 d ddlZ)ddmZ)ddnZ*ej2 d ddoZ+ej2 d ddpZ+ej2 d ddqZ+ej2 d ddrZ+ddsZ+ej2 ddtZ,ej2 dduZ,ej2 ddvZ,ej2 d ddwZ,ej2 ddxZ,ej2 d dyZ,ej2 d!dzZ,ej2 d d"d{Z,dd|Z,d#d}Z-ej2 d$d~Z.ej2 d%dZ.ej2 d&dZ.ej2 d d'dZ.ej2 d d(dZ.ej2 d d)dZ.ej2 d*dZ.ej2 d+dZ.ej2 d,dZ.ej2 d d-dZ.ej2 d d.dZ.ej2 d d/dZ.ej2 d0 d1dZ.d0dZ.ej2 d$dZ/ej2 d%dZ/ej2 d&dZ/ej2 d d'dZ/ej2 d d(dZ/ej2 d d)dZ/ej2 d*dZ/ej2 d+dZ/ej2 d,dZ/ej2 d d-dZ/ej2 d d.dZ/ej2 d d/dZ/ej2 d0 d1dZ/d0dZ/ej2 d d2dZ0ej2 d d3dZ0ej2 d d4dZ0ej2 d d5dZ0ej2 d d6dZ0ej2 d d7dZ0ej2 d d8dZ0ej2 d d9dZ0ej2 d d:dZ0ej2 d d;dZ0ej2 d d d?dZ0d>dZ0ej2 d@dZ1ej2 dAdZ1ej2 dBdZ1ej2 d dCdZ1ej2 d dDdZ1ej2 d dEdZ1ej2 dFdZ1ej2 dGdZ1ej2 dHdZ1ej2 d dIdZ1ej2 d dJdZ1ej2 d dKdZ1ej2 d0 dLdZ1d0dZ1ej2 d ddZ2ej2 d ddZ2ej2 d ddZ2ej2 d ddZ2ej2 d ddZ2ej2 d ddZ2ddZ2dMdZ3d̐dNdZ4ej2dOdZ5ej2dPdZ5dZ5dQd„Z6 d dRdÄZ7ej2 d dSdĄZ8ej2 d dTdńZ8ddƄZ8 d dUdDŽZ9y(VzE Functions that operate on lists and dicts. .. versionadded:: 1.0.0 ) annotations) cmp_to_keyN)callitcmp getargcountiterator iteriteratee) IterateeObjTPathT)atcount_byeveryfilter_find find_lastflat_map flat_map_deepflat_map_depthfor_eachfor_each_rightgroup_byincludes invoke_mapkey_bymap_nestorder_by partitionpluckreduce_ reduce_right reductionsreductions_rightrejectsample sample_sizeshufflesizesomesort_byTT2T3T4cyN collectionpathss J/home/Script/Script_env/lib/python3.12/site-packages/pydash/collections.pyr r ;sNQcyr1r2r3s r6r r ?]`r7cyr1r2r3s r6r r CsLOr7cyr1r2r3s r6r r Gs_br7c2tj||S)a Creates a list of elements from the specified indexes, or keys, of the collection. Indexes may be specified as individual arguments or as arrays of indexes. Args: collection: Collection to iterate over. *paths: The indexes of `collection` to retrieve, specified as individual indexes or arrays of indexes. Returns: filtered list Example: >>> at([1, 2, 3, 4], 0, 2) [1, 3] >>> at({"a": 1, "b": 2, "c": 3, "d": 4}, "a", "c") [1, 3] >>> at({"a": 1, "b": 2, "c": {"d": {"e": 3}}}, "a", ["c", "d", "e"]) [1, 3] .. versionadded:: 1.0.0 .. versionchanged:: 4.1.0 Support deep path access. )pyd propertiesr3s r6r r Ks6 "3>>5 !* --r7cyr1r2r4iteratees r6rriZ]r7cyr1r2r@s r6rrmr7cyr1r2r@s r6rrsrDr7cyr1r2r@s r6rryrDr7cyr1r2r@s r6rrRUr7cyr1r2r@s r6rrrDr7cyr1r2r@s r6rrs`cr7cyr1r2r@s r6rr[^r7cvi}t||D]'}|j|dd||dxxdz cc<)|S)a Creates an object composed of keys generated from the results of running each element of `collection` through the iteratee. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: Dict containing counts by key. Example: >>> results = count_by([1, 2, 1, 2, 3, 4]) >>> assert results == {1: 2, 2: 2, 3: 1, 4: 1} >>> results = count_by(["a", "A", "B", "b"], lambda x: x.lower()) >>> assert results == {"a": 2, "b": 2} >>> results = count_by({"a": 1, "b": 1, "c": 3, "d": 3}) >>> assert results == {1: 2, 3: 2} .. versionadded:: 1.0.0 rr)r setdefault)r4rAretresults r6rrsJ. Cz84 vay!$ F1I! Jr7c^|r tj|fd|D}t|S)a Checks if the predicate returns a truthy value for all elements of a collection. The predicate is invoked with three arguments: ``(value, index|key, collection)``. If a property name is passed for predicate, the created :func:`pluck` style predicate will return the property value of the given element. If an object is passed for predicate, the created :func:`.matches` style predicate will return ``True`` for elements that have the properties of the given object, else ``False``. Args: collection: Collection to iterate over. predicate: Predicate applied per iteration. Returns: Whether all elements are truthy. Example: >>> every([1, True, "hello"]) True >>> every([1, False, "hello"]) False >>> every([{"a": 1}, {"a": True}, {"a": "hello"}], "a") True >>> every([{"a": 1}, {"a": False}, {"a": "hello"}], "a") False >>> every([{"a": 1}, {"a": 1}], {"a": 1}) True >>> every([{"a": 1}, {"a": 2}], {"a": 1}) False .. versionadded:: 1.0.0 .. versionchanged: 4.0.0 Removed alias ``all_``. c3.K|] }|ywr1r2.0itemcbks r6 zevery..7Dc$i7)r=rAallr4 predicaterVs @r6rrs+Lll9%7J7 z?r7cyr1r2r4r\s r6rrr7cyr1r2r^s r6rrr_r7cyr1r2r^s r6rrr_r7cyr1r2r^s r6rrr7cyr1r2r^s r6rrrcr7cyr1r2r^s r6rrrcr7c \t||Dcgc] \}}}}|s |c}}}Scc}}}w)aG Iterates over elements of a collection, returning a list of all elements the predicate returns truthy for. Args: collection: Collection to iterate over. predicate: Predicate applied per iteration. Returns: Filtered list. Example: >>> results = filter_([{"a": 1}, {"b": 2}, {"a": 1, "b": 3}], {"a": 1}) >>> assert results == [{"a": 1}, {"a": 1, "b": 3}] >>> filter_([1, 2, 3, 4], lambda x: x >= 3) [3, 4] .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed alias ``select``. r r4r\is_truevalue_s r6rrs.0/;:y.Q ] ]*guaU\E ]] ] ''cyr1r2r^s r6rr#r7cyr1r2r^s r6rr*rnr7cyr1r2r^s r6rr1rnr7cyr1r2r^s r6rr8r7cyr1r2r^s r6rr?rrr7cyr1r2r^s r6rrFrrr7c@dt||D}t|dS)a/ Iterates over elements of a collection, returning the first element that the predicate returns truthy for. Args: collection: Collection to iterate over. predicate: Predicate applied per iteration. Returns: First element found or ``None``. Example: >>> find([1, 2, 3, 4], lambda x: x >= 3) 3 >>> find([{"a": 1}, {"b": 2}, {"a": 1, "b": 2}], {"a": 1}) {'a': 1} .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed aliases ``detect`` and ``find_where``. c30K|]\}}}}|s |ywr1r2rTrirjrks r6rWzfind..es _,1W^e _s Nr nextr4r\searchs r6rrMs#0` Z0S _F  r7cyr1r2r^s r6rrirnr7cyr1r2r^s r6rrprnr7cyr1r2r^s r6rrwrnr7cyr1r2r^s r6rr~rrr7cyr1r2r^s r6rrrrr7cyr1r2r^s r6rrrrr7cDdt||dD}t|dS)a, This method is like :func:`find` except that it iterates over elements of a `collection` from right to left. Args: collection: Collection to iterate over. predicate: Predicate applied per iteration. Returns: Last element found or ``None``. Example: >>> find_last([1, 2, 3, 4], lambda x: x >= 3) 4 >>> results = find_last([{'a': 1}, {'b': 2}, {'a': 1, 'b': 2}], {'a': 1}) >>> assert results == {'a': 1, 'b': 2} .. versionadded:: 1.0.0 c3.K|] \}}}}|r|ywr1r2rws r6rWzfind_last..s# GUAq  sTreverseNrxrzs r6rrs*,$0YPT$UF  r7cyr1r2r@s r6rrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrr9r7cyr1r2r@s r6rrs^ar7cyr1r2r@s r6rradr7cyr1r2r@s r6rrsUXr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrLr7cyr1r2r@s r6rrsVYr7cyr1r2r@s r6rrY\r7cyr1r2r@s r6rrsMPr7cBtjt||S)a Creates a flattened list of values by running each element in collection through `iteratee` and flattening the mapped results. The `iteratee` is invoked with three arguments: ``(value, index|key, collection)``. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: Flattened mapped list. Example: >>> duplicate = lambda n: [[n, n]] >>> flat_map([1, 2], duplicate) [[1, 1], [2, 2]] .. versionadded:: 4.0.0 rA)r=flattenitermapr@s r6rrs* ;;wzH= >>r7cyr1r2r@s r6rrr7cyr1r2r@s r6rr r7cyr1r2r@s r6rr&rr7cyr1r2r@s r6rr,rr7cyr1r2r@s r6rr3rr7cyr1r2r@s r6rr9rr7cBtjt||S)a This method is like :func:`flat_map` except that it recursively flattens the mapped results. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: Flattened mapped list. Example: >>> duplicate = lambda n: [[n, n]] >>> flat_map_deep([1, 2], duplicate) [1, 1, 2, 2] .. versionadded:: 4.0.0 r)r= flatten_deeprr@s r6rr?s&   GJB CCr7cyr1r2r4rAdepths r6rrU r7cyr1r2rs r6rr]rr7cyr1r2rs r6rrerr7cyr1r2rs r6rrmrr7cyr1r2rs r6rrurr7cyr1r2rs r6rr}rr7cFtjt|||S)a This method is like :func:`flat_map` except that it recursively flattens the mapped results up to `depth` times. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: Flattened mapped list. Example: >>> duplicate = lambda n: [[n, n]] >>> flat_map_depth([1, 2], duplicate, 1) [[1, 1], [2, 2]] >>> flat_map_depth([1, 2], duplicate, 2) [1, 1, 2, 2] .. versionadded:: 4.0.0 r)r)r= flatten_depthrrs r6rrs,   WZ(C5 QQr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrcr7cyr1r2r@s r6rrrcr7cyr1r2r@s r6rrrcr7c@tdt||Dd|S)a Iterates over elements of a collection, executing the iteratee for each element. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: `collection` Example: >>> results = {} >>> def cb(x): ... results[x] = x**2 >>> for_each([1, 2, 3, 4], cb) [1, 2, 3, 4] >>> assert results == {1: 1, 2: 4, 3: 9, 4: 16} .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed alias ``each``. c34K|]\}}}}|dus dywFNr2rTrOrks r6rWzfor_each..s V<31aPU$ VNryr r@s r6rrs"2 V< H#E VX\] r7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrcr7cyr1r2r@s r6rrrcr7cyr1r2r@s r6rrrcr7cDtdt||dDd|S)a_ This method is like :func:`for_each` except that it iterates over elements of a `collection` from right to left. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: `collection` Example: >>> results = {"total": 1} >>> def cb(x): ... results["total"] = x * results["total"] >>> for_each_right([1, 2, 3, 4], cb) [1, 2, 3, 4] >>> assert results == {"total": 24} .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed alias ``each_right``. c34K|]\}}}}|dus dywrr2rs r6rWz!for_each_right..*s!c,#q!QVY]bVbcrTrNrr@s r6rrs(4 c,z8T"Rc  r7cyr1r2r@s r6rr0rr7cyr1r2r@s r6rr4s #r7ci}tj|}|D]0}||}|j|g||j|2|S)a Creates an object composed of keys generated from the results of running each element of a `collection` through the iteratee. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: Results of grouping by `iteratee`. Example: >>> results = group_by([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}], 'a') >>> assert results == {1: [{'a': 1, 'b': 2}], 3: [{'a': 3, 'b': 4}]} >>> results = group_by([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}], {'a': 1}) >>> assert results == {False: [{'a': 3, 'b': 4}], True: [{'a': 1, 'b': 2}]} .. versionadded:: 1.0.0 )r=rArNappend)r4rArOrVrjkeys r6rr:sT, C ,,x C%j sB C Jr7c\t|tr|j}||vS||d}||vS)a Checks if a given value is present in a collection. If `from_index` is negative, it is used as the offset from the end of the collection. Args: collection: Collection to iterate over. target: Target value to compare to. from_index: Offset to start search from. Returns: Whether `target` is in `collection`. Example: >>> includes([1, 2, 3, 4], 2) True >>> includes([1, 2, 3, 4], 2, from_index=2) False >>> includes({"a": 1, "b": 2, "c": 3, "d": 4}, 2) True .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Renamed from ``contains`` to ``includes`` and removed alias ``include``. N) isinstancedictvalues)r4target from_indexcollection_valuess r6rr[sF>*d#&--/ & &&'z{3 & &&r7c*t|fdS)aS Invokes the method at `path` of each element in `collection`, returning a list of the results of each invoked method. Any additional arguments are provided to each invoked method. If `path` is a function, it's invoked for each element in `collection`. Args: collection: Collection to iterate over. path: String path to method to invoke or callable to invoke for each element in `collection`. args: Arguments to pass to method call. kwargs: Keyword arguments to pass to method call. Returns: List of results of invoking method of each item. Example: >>> items = [{"a": [{"b": 1}]}, {"a": [{"c": 2}]}] >>> expected = [{"b": 1}.items(), {"c": 2}.items()] >>> invoke_map(items, "a[0].items") == expected True .. versionadded:: 4.0.0 c8tj|giSr1)r=invoke)rUargskwargspaths r6zinvoke_map..sD$)P)P)Pr7)r)r4rrrs ```r6rrs6  P QQr7cyr1r2r@s r6rrWZr7cyr1r2r@s r6rrsr7cXi}tj|}|D] }||||<|S)aE Creates an object composed of keys generated from the results of running each element of the collection through the given iteratee. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: Results of indexing by `iteratee`. Example: >>> results = key_by([{"a": 1, "b": 2}, {"a": 3, "b": 4}], "a") >>> assert results == {1: {"a": 1, "b": 2}, 3: {"a": 3, "b": 4}} .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Renamed from ``index_by`` to ``key_by``. )r=rA)r4rArOrVrjs r6rrs:. C ,,x C CJ  Jr7cyr1r2r@s r6rrrBr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrHr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7cyr1r2r@s r6rrrr7c,tt||S)a Creates an array of values by running each element in the collection through the iteratee. The iteratee is invoked with three arguments: ``(value, index|key, collection)``. If a property name is passed for iteratee, the created :func:`pluck` style iteratee will return the property value of the given element. If an object is passed for iteratee, the created :func:`.matches` style iteratee will return ``True`` for elements that have the properties of the given object, else ``False``. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. Returns: Mapped list. Example: >>> map_([1, 2, 3, 4], str) ['1', '2', '3', '4'] >>> map_([{"a": 1, "b": 2}, {"a": 3, "b": 4}, {"a": 5, "b": 6}], "a") [1, 3, 5] >>> map_([[[0, 1]], [[2, 3]], [[4, 5]]], "0.1") [1, 3, 5] >>> map_([{"a": {"b": 1}}, {"a": {"b": 2}}], "a.b") [1, 2] >>> map_([{"a": {"b": [0, 1]}}, {"a": {"b": [2, 3]}}], "a.b[1]") [1, 3] .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed alias ``collect``. )listrr@s r6rrsD  H- ..r7c|s|Stj|}|d|ddc}tjt||fdS)a This method is like :func:`group_by` except that it supports nested grouping by multiple string `properties`. If only a single key is given, it is like calling ``group_by(collection, prop)``. Args: collection: Collection to iterate over. *properties: Properties to nest by. Returns: Results of nested grouping by `properties`. Example: >>> results = nest([{'shape': 'square', 'color': 'red', 'qty': 5}, {'shape': 'square', 'color': 'blue', 'qty': 10}, {'shape': 'square', 'color': 'orange', 'qty': 5}, {'shape': 'circle', 'color': 'yellow', 'qty': 5}, {'shape': 'circle', 'color': 'pink', 'qty': 10}, {'shape': 'oval', 'color': 'purple', 'qty': 5}], 'shape', 'qty') >>> expected = { 'square': {5: [{'shape': 'square', 'color': 'red', 'qty': 5}, {'shape': 'square', 'color': 'orange', 'qty': 5}], 10: [{'shape': 'square', 'color': 'blue', 'qty': 10}]}, 'circle': {5: [{'shape': 'circle', 'color': 'yellow', 'qty': 5}], 10: [{'shape': 'circle', 'color': 'pink', 'qty': 10}]}, 'oval': {5: [{'shape': 'oval', 'color': 'purple', 'qty': 5}]}} >>> results == expected True .. versionadded:: 4.3.0 rrNct|gSr1)r)rjrests r6rznest..9sT%EWRVEWr7)r=r map_valuesr)r4r>flat_propertiesfirstrs @r6rrsMB kk*-O!!$oab&9KE4 >>(:u57W XXr7cyr1r2r4keysordersrs r6rr< r7cyr1r2rs r6rrErr7cyr1r2rs r6rrN r7cyr1r2rs r6rrWrr7ct|tr|j}tj|r|}d}g|r\t |D]M\}}tj ||r ||rdnd}nd}jtj||fOnH|D]C}|jdrd}|dd}nd}jtj||fEfd}t|t||S)ax This method is like :func:`sort_by` except that it sorts by key names instead of an iteratee function. Keys can be sorted in descending order by prepending a ``"-"`` to the key name (e.g. ``"name"`` would become ``"-name"``) or by passing a list of boolean sort options via `orders` where ``True`` is ascending and ``False`` is descending. Args: collection: Collection to iterate over. keys: List of keys to sort by. By default, keys will be sorted in ascending order. To sort a key in descending order, prepend a ``"-"`` to the key name. For example, to sort the key value for ``"name"`` in descending order, use ``"-name"``. orders: List of boolean sort orders to apply for each key. ``True`` corresponds to ascending order while ``False`` is descending. Defaults to ``None``. reverse (bool, optional): Whether to reverse the sort. Defaults to ``False``. Returns: Sorted list. Example: >>> items = [{'a': 2, 'b': 1}, {'a': 3, 'b': 2}, {'a': 1, 'b': 3}] >>> results = order_by(items, ['b', 'a']) >>> assert results == [{'a': 2, 'b': 1}, {'a': 3, 'b': 2}, {'a': 1, 'b': 3}] >>> results = order_by(items, ['a', 'b']) >>> assert results == [{'a': 1, 'b': 3}, {'a': 2, 'b': 1}, {'a': 3, 'b': 2}] >>> results = order_by(items, ['-a', 'b']) >>> assert results == [{'a': 3, 'b': 2}, {'a': 2, 'b': 1}, {'a': 1, 'b': 3}] >>> results = order_by(items, ['a', 'b'], [False, True]) >>> assert results == [{'a': 3, 'b': 2}, {'a': 2, 'b': 1}, {'a': 1, 'b': 3}] .. versionadded:: 3.0.0 .. versionchanged:: 3.2.0 Added `orders` argument. .. versionchanged:: 3.2.0 Added :func:`sort_by_order` as alias. .. versionchanged:: 4.0.0 Renamed from ``order_by`` to ``order_by`` and removed alias ``sort_by_order``. Nr-c\D]&\}}t||||}|s!||zcSy)Nr)r)leftrightfuncmultrP comparerss r6 comparisonzorder_by..comparisons<# %JD$dT%[1Ff}$ %r7rr) rrrr= is_boolean enumeratehasr property_ startswithsortedr) r4rrrirorderrrs @r6rr`sf*d#&&(  ~~fI o :FAswwvq!#AYB   cmmC0%8 9  : :C~~c"!"g   cmmC0%8 9 : **Z"8' JJr7cyr1r2r^s r6rrr7cyr1r2r^s r6rrr r7cyr1r2r^s r6rrr r7cyr1r2r^s r6rrr r7cyr1r2r^s r6rrr7cyr1r2r^s r6rrrr7cyr1r2r^s r6rrrr7cyr1r2r^s r6rrrr7cg}g}t||D],\}}}}|r|j||j|.||gS)a Creates an array of elements split into two groups, the first of which contains elements the `predicate` returns truthy for, while the second of which contains elements the `predicate` returns falsey for. The `predicate` is invoked with three arguments: ``(value, index|key, collection)``. If a property name is provided for `predicate` the created :func:`pluck` style predicate returns the property value of the given element. If an object is provided for `predicate` the created :func:`.matches` style predicate returns ``True`` for elements that have the properties of the given object, else ``False``. Args: collection: Collection to iterate over. predicate: Predicate applied per iteration. Returns: List of grouped elements. Example: >>> partition([1, 2, 3, 4], lambda x: x >= 3) [[3, 4], [1, 2]] .. versionadded:: 1.1.0 )r r)r4r\truesfalsesrirjrks r6rrsT6 E F ,Z C!1  LL  MM% ! 6?r7c@t|tj|S)a* Retrieves the value of a specified property from all elements in the collection. Args: collection: List of dicts. path: Collection's path to pluck Returns: Plucked list. Example: >>> pluck([{"a": 1, "b": 2}, {"a": 3, "b": 4}, {"a": 5, "b": 6}], "a") [1, 3, 5] >>> pluck([[[0, 1]], [[2, 3]], [[4, 5]]], "0.1") [1, 3, 5] >>> pluck([{"a": {"b": 1}}, {"a": {"b": 2}}], "a.b") [1, 2] >>> pluck([{"a": {"b": [0, 1]}}, {"a": {"b": [2, 3]}}], "a.b.1") [1, 3] >>> pluck([{"a": {"b": [0, 1]}}, {"a": {"b": [2, 3]}}], ["a", "b", 1]) [1, 3] .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Function removed. .. versionchanged:: 4.0.1 Made property access deep. )rr=r)r4rs r6r r s@  CMM$/ 00r7cyr1r2r4rA accumulators r6r!r!4 r7cyr1r2rs r6r!r!<rr7cyr1r2rs r6r!r!Drr7cyr1r2rs r6r!r!Lrr7cyr1r2rs r6r!r!Trr7cyr1r2rs r6r!r!\ r7cyr1r2rs r6r!r!drr7cyr1r2rs r6r!r!lrr7cyr1r2rs r6r!r!trr7cyr1r2rs r6r!r!|rr7cyr1r2rs r6r!r!rr7cyr1r2rs r6r!r!rr7cyr1r2rs r6r!r! r7ct|}| t|\}}|}|tj }d}n t |d}|D]\}} t||| ||}|S#t$r}td|d}~wwxYw)a Reduces a collection to a value which is the accumulated result of running each element in the collection through the iteratee, where each successive iteratee execution consumes the return value of the previous execution. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. accumulator: Initial value of aggregator. Default is to use the result of the first iteration. Returns: Accumulator object containing results of reduction. Example: >>> reduce_([1, 2, 3, 4], lambda total, x: total * x) 24 .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed aliases ``foldl`` and ``inject``. Nz1reduce_() of empty sequence with no initial valuermaxargsargcount)r ry StopIteration TypeErrorr=identityrr) r4rAriterablerkexcrPr-indexrUs r6r!r!s2 #H Z!(^NA{F<<x3J t&$IJ M ZOPVY Y ZsA A7& A22A7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r" rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"rr7cyr1r2rs r6r"r"!rr7cyr1r2rs r6r"r")r'r7c^t|tst|ddd}t|||S)a This method is like :func:`reduce_` except that it iterates over elements of a `collection` from right to left. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. accumulator: Initial value of aggregator. Default is to use the result of the first iteration. Returns: Accumulator object containing results of reduction. Example: >>> reduce_right([1, 2, 3, 4], lambda total, x: total**x) 4096 .. versionadded:: 1.0.0 .. versionchanged:: 3.2.1 Fix bug where collection was not reversed correctly. .. versionchanged:: 4.0.0 Removed alias ``foldr``. Nr)rrrr!rs r6r"r"/s06 j$ '*%dd+ :x 55r7cyr1r2r4rAr from_rights r6r#r#Prr7cyr1r2rCs r6r#r#Yrr7cyr1r2rCs r6r#r#brr7cyr1r2rCs r6r#r#krr7cyr1r2rCs r6r#r#trr7cyr1r2rCs r6r#r#}rr7cyr1r2rCs r6r#r#rr7cyr1r2rCs r6r#r#rr7cyr1r2rCs r6r#r#rr7cyr1r2rCs r6r#r#rr7cyr1r2rCs r6r#r#rr7cyr1r2rCs r6r#r#rr7cyr1r2rCs r6r#r#rr7ctjdn tdgfd}|rtnt}||||S)a This function is like :func:`reduce_` except that it returns a list of every intermediate value in the reduction operation. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. accumulator: Initial value of aggregator. Default is to use the result of the first iteration. Returns: Results of each reduction operation. Example: >>> reductions([1, 2, 3, 4], lambda total, x: total * x) [2, 6, 24] Note: The last element of the returned list would be the result of using :func:`reduce_`. .. versionadded:: 2.0.0 rr)r*cJt|||}j||S)Nr,)rr)rPrUr3r-rAresultss r6 interceptorzreductions..interceptors&&$Iv r7)r=r0rr"r!)r4rArrDrTreducerr-rSs ` @@r6r#r#sK2<<x3G )lgG J [1 Nr7cyr1r2rs r6r$r$ r7cyr1r2rs r6r$r$rWr7cyr1r2rs r6r$r$rWr7cyr1r2rs r6r$r$ rWr7cyr1r2rs r6r$r$rWr7cyr1r2rs r6r$r$ r7cyr1r2rs r6r$r$!rWr7cyr1r2rs r6r$r$)rWr7cyr1r2rs r6r$r$1rWr7cyr1r2rs r6r$r$9r]r7cyr1r2rs r6r$r$Ar]r7cyr1r2rs r6r$r$Ir]r7cyr1r2rs r6r$r$Qsr7c t|||dS)a This method is like :func:`reductions` except that it iterates over elements of a `collection` from right to left. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. accumulator: Initial value of aggregator. Default is to use the result of the first iteration. Returns: Results of each reduction operation. Example: >>> reductions_right([1, 2, 3, 4], lambda total, x: total**x) [64, 4096, 4096] Note: The last element of the returned list would be the result of using :func:`reduce_`. .. versionadded:: 2.0.0 T)rD)r#rs r6r$r$Ws2 j(KD IIr7cyr1r2r^s r6r%r%sr_r7cyr1r2r^s r6r%r%zr_r7cyr1r2r^s r6r%r%r_r7cyr1r2r^s r6r%r%rcr7cyr1r2r^s r6r%r%rcr7cyr1r2r^s r6r%r%rcr7c \t||Dcgc] \}}}}|r |c}}}Scc}}}w)aL The opposite of :func:`filter_` this method returns the elements of a collection that the predicate does **not** return truthy for. Args: collection: Collection to iterate over. predicate: Predicate applied per iteration. Returns: Rejected elements of `collection`. Example: >>> reject([1, 2, 3, 4], lambda x: x >= 3) [1, 2] >>> reject([{"a": 0}, {"a": 1}, {"a": 2}], "a") [{'a': 0}] >>> reject([{"a": 0}, {"a": 1}, {"a": 2}], {"a": 1}) [{'a': 0}, {'a': 2}] .. versionadded:: 1.0.0 rgrhs r6r%r%s../;:y.Q a a*guaY`E aa arlc,tj|S)a Retrieves a random element from a given `collection`. Args: collection: Collection to iterate over. Returns: Random element from the given collection. Example: >>> items = [1, 2, 3, 4, 5] >>> results = sample(items) >>> assert results in items .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Moved multiple samples functionality to :func:`sample_size`. This function now only returns a single random sample. )randomchoicer4s r6r&r&s, == $$r7c`t|xsdt|}tj||S)a Retrieves list of `n` random elements from a collection. Args: collection: Collection to iterate over. n: Number of random samples to return. Returns: List of `n` sampled collection values. Examples: >>> items = [1, 2, 3, 4, 5] >>> results = sample_size(items, 2) >>> assert len(results) == 2 >>> assert set(items).intersection(results) == set(results) .. versionadded:: 4.0.0 r)minlenrnr&)r4nnums r6r'r's)( af1c*o &C ==S ))r7cyr1r2rps r6r(r(s;>r7cyr1r2rps r6r(r(s58r7ct|tr|j}t|}t j ||S)a Creates a list of shuffled values, using a version of the Fisher-Yates shuffle. Args: collection: Collection to iterate over. Returns: Shuffled list of values. Example: >>> items = [1, 2, 3, 4] >>> results = shuffle(items) >>> assert len(results) == len(items) >>> assert set(results) == set(items) .. versionadded:: 1.0.0 )rrrrrnr(rps r6r(r(s<&*d#&&( j!J NN: r7ct|S)a Gets the size of the `collection` by returning `len(collection)` for iterable objects. Args: collection: Collection to iterate over. Returns: Collection length. Example: >>> size([1, 2, 3, 4]) 4 .. versionadded:: 1.0.0 )rsrps r6r)r)s" z?r7c^|r tj|fd|D}t|S)a Checks if the predicate returns a truthy value for any element of a collection. The predicate is invoked with three arguments: ``(value, index|key, collection)``. If a property name is passed for predicate, the created :func:`map_` style predicate will return the property value of the given element. If an object is passed for predicate, the created :func:`.matches` style predicate will return ``True`` for elements that have the properties of the given object, else ``False``. Args: collection: Collection to iterate over. predicate: Predicate applied per iteration. Returns: Whether any of the elements are truthy. Example: >>> some([False, True, 0]) True >>> some([False, 0, None]) False >>> some([1, 2, 3, 4], lambda x: x >= 3) True >>> some([1, 2, 3, 4], lambda x: x == 0) False .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed alias ``any_``. c3.K|] }|ywr1r2rSs r6rWzsome..GrXrY)r=rAanyr[s @r6r*r*#s+Dll9%7J7 z?r7cyr1r2r4rArs r6r+r+LrWr7cyr1r2r~s r6r+r+Tr]r7ct|tr|j}t|t j ||S)a Creates a list of elements, sorted in ascending order by the results of running each element in a `collection` through the iteratee. Args: collection: Collection to iterate over. iteratee: Iteratee applied per iteration. reverse: Whether to reverse the sort. Defaults to ``False``. Returns: Sorted list. Example: >>> sort_by({"a": 2, "b": 3, "c": 1}) [1, 2, 3] >>> sort_by({"a": 2, "b": 3, "c": 1}, reverse=True) [3, 2, 1] >>> sort_by([{"a": 2}, {"a": 3}, {"a": 1}], "a") [{'a': 1}, {'a': 2}, {'a': 3}] .. versionadded:: 1.0.0 r)rrrrr=rAr~s r6r+r+\s40*d#&&( *#,,x"8' JJr7c#<Kt||D] }|d yw)zGenerative mapper.rNrg)r4rArPs r6rrs' z84Qis)r4t.Mapping[T, T2]r5r,returnzt.List[t.Union[T2, None]])r4zt.Mapping[T, t.Any]r5zt.Union[T, t.Iterable[T]]r t.List[t.Any])r4 t.Iterable[T]r5intrzt.List[t.Union[T, None]])r4t.Iterable[t.Any]r5zt.Union[int, t.Iterable[int]]rrr1)r4t.Mapping[t.Any, T2]rANonert.Dict[T2, int])r4rrA&t.Callable[[T2, T, t.Dict[T, T2]], T3]rt.Dict[T3, int])r4rrAt.Callable[[T2, T], T3]rr)r4rrAt.Callable[[T2], T3]rr)r4rrArrzt.Dict[T, int])r4rrA#t.Callable[[T, int, t.List[T]], T2]rr)r4rrAt.Callable[[T, int], T2]rr)r4rrAt.Callable[[T], T2]rr)r4rr\3t.Union[t.Callable[[T], t.Any], IterateeObjT, None]rbool)r4rr\Ft.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT, None]r t.List[T2])r4rr\7t.Union[t.Callable[[T2, T], t.Any], IterateeObjT, None]rr)r4rr\4t.Union[t.Callable[[T2], t.Any], IterateeObjT, None]rr)r4rr\Ct.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT, None]r t.List[T])r4rr\8t.Union[t.Callable[[T, int], t.Any], IterateeObjT, None]rr)r4rr\rrr)r4 t.Dict[T, T2]r\rrt.Union[T2, None])r4rr\rrr)r4rr\rrr)r4rr\rrt.Union[T, None])r4rr\rrr)r4rr\rrr)r4zt.Dict[t.Any, T2]r\rrr)r4rrAz2t.Callable[[T2, T, t.Dict[T, T2]], t.Iterable[T3]]r t.List[T3])r4rrAz#t.Callable[[T2, T], t.Iterable[T3]]rr)r4rrAz t.Callable[[T2], t.Iterable[T3]]rr)r4rrArrr)r4rrArrr)r4rrArrr)r4z t.Mapping[t.Any, t.Iterable[T2]]rArrr)r4rrArrr)r4rrAz/t.Callable[[T, int, t.List[T]], t.Iterable[T2]]rr)r4rrAz$t.Callable[[T, int], t.Iterable[T2]]rr)r4rrAzt.Callable[[T], t.Iterable[T2]]rr)r4rrArrr)r4rrArrr)r4rrArrr)r4zt.Iterable[t.Iterable[T]]rArrr)r4rrArrr)r4rrA8t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], None]rr)r4rrA)t.Union[t.Callable[[T2, T], t.Any], None]rr)r4rrA&t.Union[t.Callable[[T2], t.Any], None]rr)r4rrA5t.Union[t.Callable[[T, int, t.List[T]], t.Any], None]rr)r4rrA*t.Union[t.Callable[[T, int], t.Any], None]rr)r4rrA%t.Union[t.Callable[[T], t.Any], None]rr)Nr)r4rrArrrrr)r4rrArrrrr)r4rrArrrrr)r4rrArrrrr)r4rrArrrrr)r4rrArrrrr)r4rrArrr)r4rrArrr)r4rrArrr)r4rrArrr)r4rrArrr)r4rrArrr)r4rrAz@t.Union[t.Callable[[T2, T, t.Dict[T, T2]], t.Any], IterateeObjT]rr)r4rrAz1t.Union[t.Callable[[T2, T], t.Any], IterateeObjT]rr)r4rrAz.t.Union[t.Callable[[T2], t.Any], IterateeObjT]rr)r4rrAz=t.Union[t.Callable[[T, int, t.List[T]], t.Any], IterateeObjT]rr)r4rrAz2t.Union[t.Callable[[T, int], t.Any], IterateeObjT]rr)r4rrAz-t.Union[t.Callable[[T], t.Any], IterateeObjT]rr)r4rrArrzt.Dict[T2, t.List[T]])r4rrAt.Union[IterateeObjT, None]rzt.Dict[t.Any, t.List[T]])r)r4z0t.Union[t.Sequence[t.Any], t.Dict[t.Any, t.Any]]rt.Anyrrrr) r4rrr rrrrrr)r4rrArrz t.Dict[T2, T])r4rrArrzt.Dict[t.Any, t.Any])r4rrArrr)r4rr>rrr)F) r4rrt.Iterable[t.Union[str, int]]rt.Union[t.Iterable[bool], bool]rrrr)NF) r4rrt.Iterable[str]rrrrrr) r4rrrrrrrrr) r4rrrrrrrrr)r4rr\z)t.Callable[[T2, T, t.Dict[T, T2]], t.Any]rt.List[t.List[T2]])r4rr\zt.Callable[[T2, T], t.Any]rr)r4rr\zt.Callable[[T2], t.Any]rr)r4rr\rrr)r4rr\z&t.Callable[[T, int, t.List[T]], t.Any]rt.List[t.List[T]])r4rr\zt.Callable[[T, int], t.Any]rr)r4rr\zt.Callable[[T], t.Any]rr)r4rr\rrr)r4rrr rr)r4rrAt.Callable[[T3, T2, T], T3]rr.rr.)r4rrAt.Callable[[T3, T2], T3]rr.rr.)r4t.Mapping[t.Any, t.Any]rAt.Callable[[T3], T3]rr.rr.)r4rrAt.Callable[[T2, T2, T], T2]rrrr-)r4rrAt.Callable[[T2, T2], T2]rrrr-)r4rrAt.Callable[[T], T]rrrr,)r4rrAt.Callable[[T2, T, int], T2]rr-rr-)r4rrAt.Callable[[T2, T], T2]rr-rr-)r4rrAt.Callable[[T2], T2]rr-rr-)r4rrAt.Callable[[T, T, int], T]rrrr,)r4rrAt.Callable[[T, T], T]rrrr,)r4rrArrrrr,)NN)r4rrArrrrr,) r4rrArrr.rDrrr) r4rrArrr.rDrrr) r4rrArrr.rDrrr) r4rrArrrrDrrr) r4rrArrrrDrrr) r4rrArrrrDrrr) r4rrArrr-rDrrr) r4rrArrr-rDrrr) r4rrArrr-rDrrr) r4rrArrrrDrrr) r4rrArrrrDrrr) r4rrArrrrDrrr)NNF) r4rrArrrrDrrr)r4rrArrr.rr)r4rrArrr.rr)r4rrArrr.rr)r4rrArrrrr)r4rrArrrrr)r4rrArrrrr)r4rrArrr-rr)r4rrArrr-rr)r4rrArrr-rr)r4rrArrrrr)r4rrArrrrr)r4rrArrrrr)r4rrArrrrr)r4 t.Sequence[T]rr,)r4rrtzt.Union[int, None]rr)r4zt.Mapping[t.Any, T]rr)r4rrr)r4zt.Sizedrr)r4rr\rrr)r4rrArrrrr)r4rrArrrrr)r4rrAz3t.Union[t.Callable[..., t.Any], IterateeObjT, None]rzt.Generator[t.Any, None, None]):__doc__ __future__r functoolsrrntypingtpydashr=helpersrrrr r typesr r __all__TypeVarr,r-r.r/overloadr rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+rr2r7r6rsK" # EE& DAIIcNQYYt_QYYt_QYYt_Q Q` `O Ob b.<] ] ,R   ,C  $0D  U U)L  c c^ ^Bae***]* *ZY] U  JN F  GK$C  VZR  KOG  FJB  ^6Y]U  JNF  GKC  VZR  KOG  FJB  8Y]U  JNF  GK!C  VZR  KOG  FJB  < ,^   ,O  $0P   ,R  ` `a ad dX X)X  )M  )H  )L  ^ ^Y Y\ \P P?0JN F  X\ ,U  Y]$0V  GKC  VZ)S  QU)N  D,JN F   ;? 7   8<$4   GKC   <@8   7;3   R2X\T  IME  FJB  UYQ  JNF  EIA  :N  ?  <  K  @  ;  Bd dGK##)D## # Dde%'@%'JO%']`%' %'PR!R).R7<RHMRR<Z ZKO!-H  @] ]\ \ ,R  U UZ Z)L  KO!-H  "/J'YT  $ ' ,     $         ' ,           WKt -V   -G  $1H  OS$1L  *P  *E  *@  HL*E  $N 1F   )       $ &       ' "         )       $ &       '          *        %       ! "        (        #       !        VZ  )- CS    ,^   )       $ &       ' "         )       $ &       '          *        %       ! "        (        #       !        VZ  )- CS    6B   )      $&      '"      )     $&     '       *      %      !"     (     #     !     $( "    )X )  $&  '"   )  $&  '   *  %  !"  (  #  !   VZ)-CS  J8Y] U  JN F  GK$C  VZR  KOG  FJB  b4%2*0> >8 8>*SW&&*O& &RFJ$B  EIA  KJEI!A$r7