O=dm}6dZddlmZddlZddlZddlmZmZm Z m Z m Z dZ dZ d(dZd(d Zd(d Zd(d Zd(d Zd(d Zd(dZd)dZd(dZdZd(dZd*dZdZd(dZd(dZdZd+dZd(dZdZ d,dZ!d,dZ"d-dZ#d,dZ$d(d Z%d!Z&d(d"Z'd#Z(d$Z)d(d%Z*d+d&Z+d(d'Z,dS).zE Functions that operate on lists and dicts. .. versionadded:: 1.0.0 ) cmp_to_keyN)callitcmp getargcountiterator iteriteratee)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_byc0tj||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 (list|dict): Collection to iterate over. *paths (mixed): The indexes of `collection` to retrieve, specified as individual indexes or arrays of indexes. Returns: list: 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 properties) collectionpathss 5 !* - --ci}t||D]4}||dd||dxxdz cc<5|S)a Creates an object composed of keys generated from the results of running each element of `collection` through the iteratee. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: dict: 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)r,iterateeretresults r.r r Ps[. Cz844 vay!$$$ F1I! Jr/cj|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 (list|dict): Collection to iterate over. predicate (mixed, optional): Predicate applied per iteration. Returns: bool: 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|]}|VdSN.0itemcbks r. zevery..+77Dcc$ii777777r/)r*r2allr, predicater<s @r.r r psBH8l9%%7777J777 z??r/c6dt||DS)ak Iterates over elements of a collection, returning a list of all elements the predicate returns truthy for. Args: collection (list|dict): Collection to iterate over. predicate (mixed, optional): Predicate applied per iteration. Returns: list: 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``. c g|] \}}}}| | Sr8r8r:is_truevalue_s r. zfilter_..s' ] ] ]*guaU\ ]E ] ] ]r/r r,rAs r.r r s#0 ^ ]l:y.Q.Q ] ] ]]r/cVdt||D}t|dS)aT Iterates over elements of a collection, returning the first element that the predicate returns truthy for. Args: collection (list|dict): Collection to iterate over. predicate (mixed, optional): Predicate applied per iteration. Returns: mixed: 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``. c3(K|] \}}}}| |VdSr7r8rDs r.r=zfind..s1 _ _,1W^ _e _ _ _ _ _ _r/Nr nextr,rAsearchs r.rrs20` _ Z0S0S _ _ _F   r/cZdt||dD}t|dS)aQ This method is like :func:`find` except that it iterates over elements of a `collection` from right to left. Args: collection (list|dict): Collection to iterate over. predicate (mixed, optional): Predicate applied per iteration. Returns: mixed: 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|] \}}}}| |VdSr7r8rDs r.r=zfind_last..sD GUAq  r/TreverseNrMrOs r.rrsB,$0YPT$U$U$UF   r/cHtjt||S)a7 Creates a flattened list of values by running each element in collection thru `iteratee` and flattening the mapped results. The `iteratee` is invoked with three arguments: ``(value, index|key, collection)``. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: list: Flattened mapped list. Example: >>> duplicate = lambda n: [[n, n]] >>> flat_map([1, 2], duplicate) [[1, 1], [2, 2]] .. versionadded:: 4.0.0 r2)r*flattenitermapr,r2s r.rrs!* ;wzH=== > >>r/cHtjt||S)a This method is like :func:`flat_map` except that it recursively flattens the mapped results. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: list: Flattened mapped list. Example: >>> duplicate = lambda n: [[n, n]] >>> flat_map_deep([1, 2], duplicate) [1, 1, 2, 2] .. versionadded:: 4.0.0 rV)r* flatten_deeprXrYs r.rrs"&  GJBBB C CCr/cLtjt|||S)a# This method is like :func:`flat_map` except that it recursively flattens the mapped results up to `depth` times. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: list: 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 rV)depth)r* flatten_depthrX)r,r2r]s r.rrs',  WZ(CCC5 Q Q QQr/cVtdt||Dd|S)a6 Iterates over elements of a collection, executing the iteratee for each element. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: list|dict: `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``. c3,K|]\}}}}|du dVdSFNr8r:r3rGs r.r=zfor_each..Os/ V V<31aPU$ V Vr/NrNr rYs r.rr7s40 V V< H#E#E V V VX\]]] r/cZtdt||dDd|S)ax This method is like :func:`for_each` except that it iterates over elements of a `collection` from right to left. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: list|dict: `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``. c3,K|]\}}}}|du dVdSrar8rbs r.r=z!for_each_right..ms6cc,#q!QVY]bVbVbVbVbVbVbccr/TrSNrcrYs r.rrSsA2 cc,z8T"R"R"Rccc  r/ci}tj|}|D]>}||}||g|||?|S)a Creates an object composed of keys generated from the results of running each element of a `collection` through the iteratee. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: dict: 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*r2r1append)r,r2r3r<rFkeys r.rrssf, C ,x Cc%jj sB C Jr/crt|tr|}n ||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 (list|dict): Collection to iterate over. target (mixed): Target value to compare to. from_index (int, optional): Offset to start search from. Returns: bool: 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)r,target from_indexs r.rrsD8*d##-&&((  , Z r/c2t|fdS)a 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 (list|dict): Collection to iterate over. path (str|func): String path to method to invoke or callable to invoke for each element in `collection`. args (optional): Arguments to pass to method call. kwargs (optional): Keyword arguments to pass to method call. Returns: list: 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 c0tj|gRiSr7)r*invoke)r;argskwargspaths r.zinvoke_map..s#D$)P)P)P)P)P)Pr/)r)r,rtrrrss ```r.rrs'2  PPPPPP Q QQr/cXi}tj|}|D]}||||<|S)ai Creates an object composed of keys generated from the results of running each element of the collection through the given iteratee. Args: collection (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: dict: 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*r2)r,r2r3r<rFs r.rrs?. C ,x C  CCJJ Jr/c<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 (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. Returns: list: 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``. )listrXrYs r.rrsD  H-- . ..r/c|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 (list|dict): Collection to iterate over. *properties (str): Properties to nest by. Returns: dict: 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|gRSr7)r)rFrests r.ruznest..AsT%EWRVEWEWEWr/)r*rW map_valuesr)r,r+firstr{s @r.rrs`B Z((JQ-ABBKE4 >(:u557W7W7W7W X XXr/Fc@t|tr|}tj|r|}d}g|rct |D]R\}}tj||r ||rdnd}nd}tj||fSnR|D]O}| dr d}|dd}nd}tj||fPfd}t|t||S)a 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 (list|dict): Collection to iterate over. keys (list): 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, optional): 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: list: 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-cnD]0\}}t||||}|r||zcS1dS)Nr)r)leftrightfuncmultr4 comparerss r. comparisonzorder_by..comparisonsY#  JD$dTT%[[11F %f}$$$ %1r/rhrT) rjrkrlr* is_boolean enumeratehasrg property_ startswithsortedr) r,keysordersrTirhorderrrs @r.rrDsaf*d##)&&((  ~fI :oo : :FAswvq!! #AY.B   cmC00%8 9 9 9 9  : : :C~~c"" !""g   cmC00%8 9 9 9 9 **Z"8"8' J J JJr/cg}g}t||D]4\}}}}|r||||5||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 (list|dict): Collection to iterate over. predicate (mixed, optional): Predicate applied per iteration. Returns: list: List of grouped elements. Example: >>> partition([1, 2, 3, 4], lambda x: x >= 3) [[3, 4], [1, 2]] .. versionadded:: 1.1.0 )r rg)r,rAtruesfalsesrErFrGs r.rrsl6 E F ,Z C C!!1  ! LL     MM% 6?r/cFt|tj|S)aB Retrieves the value of a specified property from all elements in the collection. Args: collection (list): List of dicts. path (str|list): Collection's path to pluck Returns: list: 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)r,rts r.rrs@  CM$// 0 00r/c t|}|1 t|\}}n#t$rtdwxYw|}|tj}d}nt |d}|D]\}}t|||||}|S)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 (list|dict): Collection to iterate over. iteratee (mixed): Iteratee applied per iteration. accumulator (mixed, optional): Initial value of aggregator. Default is to use the result of the first iteration. Returns: mixed: 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)rrN StopIteration TypeErrorr*identityrr) r,r2 accumulatoriterablerGr4rindexr;s r.rrs2 ##H Q!(^^NA{{ Q Q QOPP P QF<x333JJ t&$III Ms &Ac~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 (list|dict): Collection to iterate over. iteratee (mixed): Iteratee applied per iteration. accumulator (mixed, optional): Initial value of aggregator. Default is to use the result of the first iteration. Returns: mixed: 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)rjrkrxrr,r2rs r.rrs@6 j$ ' ',*%%ddd+ :x 5 55r/ctjdntdgfd}|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 (list|dict): Collection to iterate over. iteratee (mixed): Iteratee applied per iteration. accumulator (mixed, optional): Initial value of aggregator. Default is to use the result of the first iteration. Returns: list: 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 NrrrcZt|||}||S)Nr)rrg)r4r;rrr2resultss r. interceptorzreductions..interceptorZs2&$IIIv r/)r*rrrr)r,r2r from_rightrreducerrrs ` @@r.r r 9s~2<x333G )5llgG GJ [111 Nr/c(t|||dS)a This method is like :func:`reductions` except that it iterates over elements of a `collection` from right to left. Args: collection (list|dict): Collection to iterate over. iteratee (mixed): Iteratee applied per iteration. accumulator (mixed, optional): Initial value of aggregator. Default is to use the result of the first iteration. Returns: list: 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)r)r rs r.r!r!es2 j(KD I I IIr/c6dt||DS)ap The opposite of :func:`filter_` this method returns the elements of a collection that the predicate does **not** return truthy for. Args: collection (list|dict): Collection to iterate over. predicate (mixed, optional): Predicate applied per iteration. Returns: list: 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 c g|] \}}}}| | Sr8r8rDs r.rHzreject..s' a a a*guaY` aE a a ar/rIrJs r.r"r"s#. b al:y.Q.Q a a aar/c*tj|S)a Retrieves a random element from a given `collection`. Args: collection (list|dict): Collection to iterate over. Returns: mixed: 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. )randomchoicer,s r.r#r#s, = $ $$r/cjt|pdt|}tj||S)a Retrieves list of `n` random elements from a collection. Args: collection (list|dict): Collection to iterate over. n (int, optional): Number of random samples to return. Returns: list: 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)minlenrr#)r,nnums r.r$r$s/( af1c*oo & &C =S ) ))r/ct|tr|}t|}t j||S)a Creates a list of shuffled values, using a version of the Fisher-Yates shuffle. Args: collection (list|dict): Collection to iterate over. Returns: list: 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 )rjrkrlrxrr%rs r.r%r%sN&*d##)&&(( j!!J N: r/c t|S)a* Gets the size of the `collection` by returning `len(collection)` for iterable objects. Args: collection (list|dict): Collection to iterate over. Returns: int: Collection length. Example: >>> size([1, 2, 3, 4]) 4 .. versionadded:: 1.0.0 )rrs r.r&r&s" z??r/cj|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 (list|dict): Collection to iterate over. predicate (mixed, optional): Predicate applied per iteration. Returns: bool: 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|]}|VdSr7r8r9s r.r=zsome..!r>r/)r*r2anyr@s @r.r'r'sB@8l9%%7777J777 z??r/ct|tr|}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 (list|dict): Collection to iterate over. iteratee (mixed, optional): Iteratee applied per iteration. reverse (bool, optional): Whether to reverse the sort. Defaults to ``False``. Returns: list: 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)rjrkrlrr*r2)r,r2rTs r.r(r(&sF0*d##)&&(( *#,x"8"8' J J JJr/c#DKt||D] }|dV dS)zGenerative mapper.rNrI)r,r2r4s r.rXrXIs8z844Qir/r7)Nr)r)NF)NN)NNF)-__doc__ functoolsrrpydashr*helpersrrrrr __all__r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(rXr8r/r.rs ! EEEEEEEEEEEEEE F...<@((((V^^^^68<????0DDDD,RRRR28@B" " " " JRRR8@"/"/"/"/J'Y'Y'YTXKXKXKXKv$$$$N 1 1 1F,,,,^6666B))))XJJJJ8bbbb4%%%2****0>($$$$NKKKKFr/