[ckddlZddlZddlZddlZddlmZddlmZmZddlm Z ddl m Z dZ dZ e fdZd Zd Zd Zd Zd Zd1dZdZdZdZdZdZdZdZdZdZdZeedZdZ e fdZ!dZ"dZ#dZ$dZ%d Z&d!Z'e fd"Z(d#Z)d$Z*d%Z+e+fd&Z,d'Z-d(Z.e fd)Z/d*Z0e e fd+Z1d,Z2d1d-Z3d.Z4d/Z5d1d0Z6dS)2N)partial) filterfalse zip_longest)Sequence) no_default)$remove accumulategroupby merge_sorted interleaveunique isiterable isdistincttakedroptake_nthfirstsecondnthlastgetconcatconcatvmapcatcons interpose frequenciesreducebyiteratesliding_window partition partition_allcountpluckjointaildifftopkpeekpeekn random_samplec"t||S)z Return those items of sequence for which predicate(item) is False >>> def iseven(x): ... return x % 2 == 0 >>> list(remove(iseven, [1, 2, 3, 4])) [1, 3] )r) predicateseqs /lib/python3.11/site-packages/toolz/itertoolz.pyrrs y# & &&c#Kt|}|tkr" t|}n#t$rYdSwxYw|}|V|D]}|||}|VdS)a Repeatedly apply binary function to a sequence, accumulating results >>> from operator import add, mul >>> list(accumulate(add, [1, 2, 3, 4, 5])) [1, 3, 6, 10, 15] >>> list(accumulate(mul, [1, 2, 3, 4, 5])) [1, 2, 6, 24, 120] Accumulate is similar to ``reduce`` and is good for making functions like cumulative sum: >>> from functools import partial, reduce >>> sum = partial(reduce, add) >>> cumsum = partial(accumulate, add) Accumulate also takes an optional argument that will be used as the first value. This is similar to reduce. >>> list(accumulate(add, [1, 2, 3], -1)) [-1, 0, 2, 5] >>> list(accumulate(add, [], 1)) [1] See Also: itertools.accumulate : In standard itertools for Python 3.2+ N)iterrnext StopIteration)binopr.initialresultelems r/r r s6 s))C* #YYFF    FF  LLLvt$$ s . <<ct|st|}tjd}|D]}||||i}|D]\}}|j||<|S)aV Group a collection by a key function >>> names = ['Alice', 'Bob', 'Charlie', 'Dan', 'Edith', 'Frank'] >>> groupby(len, names) # doctest: +SKIP {3: ['Bob', 'Dan'], 5: ['Alice', 'Edith', 'Frank'], 7: ['Charlie']} >>> iseven = lambda x: x % 2 == 0 >>> groupby(iseven, [1, 2, 3, 4, 5, 6, 7, 8]) # doctest: +SKIP {False: [1, 3, 5, 7], True: [2, 4, 6, 8]} Non-callable keys imply grouping on a member. >>> groupby('gender', [{'name': 'Alice', 'gender': 'F'}, ... {'name': 'Bob', 'gender': 'M'}, ... {'name': 'Charlie', 'gender': 'M'}]) # doctest:+SKIP {'F': [{'gender': 'F', 'name': 'Alice'}], 'M': [{'gender': 'M', 'name': 'Bob'}, {'gender': 'M', 'name': 'Charlie'}]} Not to be confused with ``itertools.groupby`` See Also: countby cgjSN)appendr0r/zgroupby..bs r0)callablegetter collections defaultdictitems__self__)keyr.ditemrvkvs r/r r Gs2 C==Skk 1 122A##d)) T B 1 1 Ir0ct|dkrtgSt|dkrt|dS|dd}|t|St ||S)a Merge and sort a collection of sorted collections This works lazily and only keeps one value from each iterable in memory. >>> list(merge_sorted([1, 3, 5], [2, 4, 6])) [1, 2, 3, 4, 5, 6] >>> ''.join(merge_sorted('abc', 'abc', 'abc')) 'aaabbbccc' The "key" function used to sort the input may be passed as a keyword. >>> list(merge_sorted([2, 3], [1, 3], key=lambda x: x // 3)) [2, 1, 3, 3] rrEN)lenr2r_merge_sorted_binary_merge_sorted_binary_key)seqskwargsrEs r/r r ks|  4yyA~Bxx TaDG}} **UD ! !C 3#D)))'c222r0c#Kt|dz}|d|}t|dkrt|d}nt|}||d}t|dkrt|d}nt|} t|}n#t$r |D]}|VYdSwxYw|D](}||kr|V|D]}||kr|V |Vnn$|V)|V|D]}|VdS|V|D]}|VdSNrLr)rMr2rNr3r4)rPmidL1seq1L2seq2val2val1s r/rNrNs d))q.C dsdB 2ww!|(BqE{{#B'' cddB 2ww!|(BqE{{#B''Dzz   DJJJJ  $; JJJ  $;JJJJJJJEJJJJ   DJJJJ JJJ sB**CCc#`Kt|dz}|d|}t|dkrt|d}nt||}||d}t|dkrt|d}nt||} t|}n#t$r |D]}|VYdSwxYw||} |D]>}||} | | kr'|V|D]}||} | | kr|V|Vnn:|V?|V|D]}|VdS|V|D]}|VdSrS)rMr2rOr3r4) rPrErUrVrWrXrYrZr[key2key1s r/rOrOs d))q.C dsdB 2ww!|1BqE{{'C00 cddB 2ww!|1BqE{{'C00Dzz   DJJJJ 3t99Ds4yy $; JJJ  s4yy$;JJJJJJJEJJJJ   DJJJJ JJJ sB,,CCc#,Ktjtt|} |D]}t |VdS#t $rDt tj|}tjtj ||}YnwxYwk)a  Interleave a sequence of sequences >>> list(interleave([[1, 2], [3, 4]])) [1, 3, 2, 4] >>> ''.join(interleave(('ABC', 'XY'))) 'AXBYC' Both the individual sequences and the sequence of sequences may be infinite Returns a lazy iterator TN) itertoolscyclemapr2r3r4roperatoris_not takewhile)rPitersitrr-s r/r r s OCdOO , ,EK K  3ii F K K K55IOI$7 5$I$IJJEEE K KsAA BBc#Kt}|j}||D]}||vr|||VdS|D] }||}||vr|||V!dS)a Return only unique elements of a sequence >>> tuple(unique((1, 2, 3))) (1, 2, 3) >>> tuple(unique((1, 2, 1, 3))) (1, 2, 3) Uniqueness can be defined by key keyword >>> tuple(unique(['cat', 'mouse', 'dog', 'hen'], key=len)) ('cat', 'mouse') N)setadd)r.rEseenseen_addrGvals r/r r s 55DxH   D4       D#d))C$     r0cH t|dS#t$rYdSwxYw)z Is x iterable? >>> isiterable([1, 2, 3]) True >>> isiterable('abc') True >>> isiterable(5) False TF)r2 TypeErrorxs r/rrs9 Qt uus  !!ct||ur.t}|j}|D]}||vrdS||dSt|tt|kS)z All values in sequence are distinct >>> isdistinct([1, 2, 3]) True >>> isdistinct([1, 2, 1]) False >>> isdistinct("Hello") False >>> isdistinct("World") True FT)r2rirjrM)r.rkrlrGs r/rr%sz CyyC )uu8  Dt| uu HTNNNNt3xx3s3xx==((r0c,tj||S)z The first n elements of a sequence >>> list(take(2, [10, 20, 30, 40, 50])) [10, 20] See Also: drop tail r`islicenr.s r/rr>s  C # ##r0c || dS#ttf$r%ttj||cYSwxYw)z The last n elements of a sequence >>> tail(2, [10, 20, 30, 40, 50]) [40, 50] See Also: drop take N)roKeyErrortuplerAdequervs r/r&r&KsW0A233x x 000[&sA../////0s 3AAc.tj||dS)z The sequence following the first n elements >>> list(drop(2, [10, 20, 30, 40, 50])) [30, 40, 50] See Also: take tail Nrtrvs r/rr[s  CD ) ))r0c0tj|dd|S)z] Every nth item in seq >>> list(take_nth(2, [10, 20, 30, 40, 50])) [10, 30, 50] rNrtrvs r/rrhs  CD! , ,,r0c:tt|S)zC The first element in a sequence >>> first('ABC') 'A' )r3r2r.s r/rrqs S ??r0c\t|}t|t|S)zE The second element in a sequence >>> second('ABC') 'B' )r2r3rs r/rrzs& s))CIII 99r0ct|tttfr||St t j||dS)zB The nth element in a sequence >>> nth(1, 'ABC') 'B' N) isinstancerzlistrr3r`rurvs r/rrsC #tX.//41v I$S!T22333r0c.td|dS)zA The last element in a sequence >>> last('ABC') 'C' rLr)r&rs r/rrs 3<<?r0rLcF ||S#ttf$r|cYSwxYwr;)ry IndexErrorindr.defaults r/_getrs93x j !s    c |S#t$rt|trktkrBt |dkrt j|cYS|r|dfcYSYdStfd|DcYStkrcYSttf$rtkrcYSwxYw)a Get element in a sequence or dict Provides standard indexing >>> get(1, 'ABC') # Same as 'ABC'[1] 'B' Pass a list to get multiple values >>> get([1, 2], 'ABC') # ('ABC'[1], 'ABC'[2]) ('B', 'C') Works on any value that supports indexing/getitem For example here we see that it works with dictionaries >>> phonebook = {'Alice': '555-1234', ... 'Bob': '555-5678', ... 'Charlie':'555-9999'} >>> get('Alice', phonebook) '555-1234' >>> get(['Alice', 'Bob'], phonebook) ('555-1234', '555-5678') Provide a default for missing values >>> get(['Alice', 'Dennis'], phonebook, None) ('555-1234', None) See Also: pluck rLrr=c3:K|]}t|VdSr;r).0irr.s r/ zget..s/@@qT!S'22@@@@@@r0) rorrrrMrc itemgetterrzryrrs ``r/rrsB3x  c4 *$ As88a<48.4S99999s1v;<'''22@@@@@C@@@@@@@@  " NNN  j ! j   NNN s( AC"C8C C%CCc@tj|S)a{ Concatenate zero or more iterables, any of which may be infinite. An infinite sequence will prevent the rest of the arguments from being included. We use chain.from_iterable rather than ``chain(*seqs)`` so that seqs can be a generator. >>> list(concat([[], [1], [2, 3]])) [1, 2, 3] See also: itertools.chain.from_iterable equivalent )r`chain from_iterablerPs r/rrs ? ( ( . ..r0c t|S)z Variadic version of concat >>> list(concatv([], ["a"], ["b", "c"])) ['a', 'b', 'c'] See also: itertools.chain )rrs r/rrs $<<r0c<tt||S)z Apply func to each sequence in seqs, concatenating results. >>> list(mapcat(lambda s: [c.upper() for c in s], ... [["a", "b"], ["c", "d", "e"]])) ['A', 'B', 'C', 'D', 'E'] )rrb)funcrPs r/rrs #dD// " ""r0c.tj|g|S)zk Add el to beginning of (possibly infinite) sequence seq. >>> list(cons(1, [2, 3])) [1, 2, 3] )r`r)elr.s r/rrs ?B4 % %%r0ctttj||}t ||S)z} Introduce element between each pair of elements in seq >>> list(interpose("a", [1, 2, 3])) [1, 'a', 2, 'a', 3] )rzipr`repeatr3)rr.inposeds r/rrs6 S)"--s3344GMMM Nr0c|tjt}|D]}||xxdz cc<t|S)z Find number of occurrences of each value in seq >>> frequencies(['cat', 'cat', 'ox', 'pig', 'pig', 'cat']) #doctest: +SKIP {'cat': 3, 'ox': 1, 'pig': 2} See Also: countby groupby rL)rArBintdict)r.rFrGs r/rrsE $$A $1  77Nr0c |tk}|st|s|fd}t|st|}i}|D];}||}||vr|r|||<|||<||||||<<|S)a Perform a simultaneous groupby and reduction The computation: >>> result = reduceby(key, binop, seq, init) # doctest: +SKIP is equivalent to the following: >>> def reduction(group): # doctest: +SKIP ... return reduce(binop, group, init) # doctest: +SKIP >>> groups = groupby(key, seq) # doctest: +SKIP >>> result = valmap(reduction, groups) # doctest: +SKIP But the former does not build the intermediate groups, allowing it to operate in much less space. This makes it suitable for larger datasets that do not fit comfortably in memory The ``init`` keyword argument is the default initialization of the reduction. This can be either a constant value like ``0`` or a callable like ``lambda : 0`` as might be used in ``defaultdict``. Simple Examples --------------- >>> from operator import add, mul >>> iseven = lambda x: x % 2 == 0 >>> data = [1, 2, 3, 4, 5] >>> reduceby(iseven, add, data) # doctest: +SKIP {False: 9, True: 6} >>> reduceby(iseven, mul, data) # doctest: +SKIP {False: 15, True: 8} Complex Example --------------- >>> projects = [{'name': 'build roads', 'state': 'CA', 'cost': 1000000}, ... {'name': 'fight crime', 'state': 'IL', 'cost': 100000}, ... {'name': 'help farmers', 'state': 'IL', 'cost': 2000000}, ... {'name': 'help farmers', 'state': 'CA', 'cost': 200000}] >>> reduceby('state', # doctest: +SKIP ... lambda acc, x: acc + x['cost'], ... projects, 0) {'CA': 1200000, 'IL': 2100000} Example Using ``init`` ---------------------- >>> def set_add(s, i): ... s.add(i) ... return s >>> reduceby(iseven, set_add, [1, 2, 3, 4, 1, 2, 3], set) # doctest: +SKIP {True: set([2, 4]), False: set([1, 3])} cSr;r=)_initsr/r>zreduceby..isur0)rr?r@) rEr5r.init is_no_defaultrFrGrIrs @r/rr)szJ&M $}}} C==Skk A!! CII A:  !tvv!uQqT4  ! Hr0c#(K |V||})a Repeatedly apply a function func onto an original input Yields x, then func(x), then func(func(x)), then func(func(func(x))), etc.. >>> def inc(x): return x + 1 >>> counter = iterate(inc, 0) >>> next(counter) 0 >>> next(counter) 1 >>> next(counter) 2 >>> double = lambda x: x * 2 >>> powers_of_two = iterate(double, 1) >>> next(powers_of_two) 1 >>> next(powers_of_two) 2 >>> next(powers_of_two) 4 >>> next(powers_of_two) 8 r=)rrqs r/rrys&2 DGGr0c htdttj||DS)ah A sequence of overlapping subsequences >>> list(sliding_window(2, [1, 2, 3, 4])) [(1, 2), (2, 3), (3, 4)] This function creates a sliding window suitable for transformations like sliding means / smoothing >>> mean = lambda seq: float(sum(seq)) / len(seq) >>> list(map(mean, sliding_window(2, [1, 2, 3, 4]))) [1.5, 2.5, 3.5] c3pK|]1\}}tjtj||dp|V2dS)rN)rAr{r`ru)rrits r/rz!sliding_window..sY>>1b"9#3B#:#:A>>D">>>>>>r0)r enumerater`teervs r/r r sA >>%imC&;&;<<>>> ??r0 __no__pad__cdt|g|z}|tur t|St|d|iS)a Partition sequence into tuples of length n >>> list(partition(2, [1, 2, 3, 4])) [(1, 2), (3, 4)] If the length of ``seq`` is not evenly divisible by ``n``, the final tuple is dropped if ``pad`` is not specified, or filled to length ``n`` by pad: >>> list(partition(2, [1, 2, 3, 4, 5])) [(1, 2), (3, 4)] >>> list(partition(2, [1, 2, 3, 4, 5], pad=None)) [(1, 2), (3, 4), (5, None)] See Also: partition_all fillvalue)r2no_padrr)rwr.padargss r/r!r!s>$ II;?D f}1DzD0C000r0c#Kt|g|z}t|dti} t|}n#t$rYdSwxYw|D]}|V|} |dturk |dt ||zVdS#t $r?d|}}||kr%||zdz}||tur|}n|dz}||k%|d|VYdSwxYw|VdS)a; Partition all elements of sequence into tuples of length at most n The final tuple may be shorter to accommodate extra elements. >>> list(partition_all(2, [1, 2, 3, 4])) [(1, 2), (3, 4)] >>> list(partition_all(2, [1, 2, 3, 4, 5])) [(1, 2), (3, 4), (5,)] See Also: partition rNrrTrL)r2rrr3r4rMro) rwr.rrprevrGlohirUs r/r"r"sQ II;?D d -f - -BBxx   Bx6 }C1 }% % % % % %    Br' !Bw1n9&!BBqB r' ! ss)OOOOOO  s"8 AA$BAC  C crt|drt|Std|DS)z Count the number of items in seq Like the builtin ``len`` but works on lazy sequences. Not to be confused with ``itertools.count`` See also: len __len__c3K|]}dVdS)rLNr=)rrs r/rzcount..s"Qqr0)hasattrrMsumrs r/r#r#s>sI3xx #  r0ctkrt}t||Sttrfd|DSfd|DS)a plucks an element or several elements from each item in a sequence. ``pluck`` maps ``itertoolz.get`` over a sequence and returns one or more elements of each item in the sequence. This is equivalent to running `map(curried.get(ind), seqs)` ``ind`` can be either a single string/index or a list of strings/indices. ``seqs`` should be sequence containing sequences or dicts. e.g. >>> data = [{'id': 1, 'name': 'Cheese'}, {'id': 2, 'name': 'Pies'}] >>> list(pluck('name', data)) ['Cheese', 'Pies'] >>> list(pluck([0, 1], [[1, 2, 3], [4, 5, 7]])) [(1, 2), (4, 5)] See Also: get map c3RK|] tfdDV!dS)c3:K|]}t|VdSr;r)rrGrr.s r/rz"pluck...s/??4d4g..??????r0N)rzrr.rrs @r/rzpluck..sX!!?????3?????!!!!!!r0c3:K|]}t|VdSr;rrs r/rzpluck..s/ 4 4Dc7 # # 4 4 4 4 4 4r0)rr@rbrr)rrPrrs` ` r/r$r$s.*!Skk3~~ C  !!!!!!!!! ! 4 4 4 4 4t 4 4 44r0cttr3tdkr dfdSrtjSdStjS)NrLrc|fSr;r=)rqindexs r/r>zgetter..$s ah[r0cdS)Nr=r=rps r/r>zgetter..(sRr0)rrrMrcr)rs`r/r@r@ sn% * u::? !HE(((( (  &. .< "5)))r0c# Kt|st|}t|st|}t||}|tkr2|tkr'|D]"}||}||vr||D]} | |fV #dS|tkr9|tkr.|D])}||}||vr||D]} | |fV #||fV*dS|tkrt } | j} |tkr1|D]-}||}| |||vr||D]} | |fV .n7|D]4}||}| |||vr||D]} | |fV .||fV5|D]\}} || vr | D]} | |fV dSdS)a= Join two sequences on common attributes This is a semi-streaming operation. The LEFT sequence is fully evaluated and placed into memory. The RIGHT sequence is evaluated lazily and so can be arbitrarily large. (Note: If right_default is defined, then unique keys of rightseq will also be stored in memory.) >>> friends = [('Alice', 'Edith'), ... ('Alice', 'Zhao'), ... ('Edith', 'Alice'), ... ('Zhao', 'Alice'), ... ('Zhao', 'Edith')] >>> cities = [('Alice', 'NYC'), ... ('Alice', 'Chicago'), ... ('Dan', 'Syndey'), ... ('Edith', 'Paris'), ... ('Edith', 'Berlin'), ... ('Zhao', 'Shanghai')] >>> # Vacation opportunities >>> # In what cities do people have friends? >>> result = join(second, friends, ... first, cities) >>> for ((a, b), (c, d)) in sorted(unique(result)): ... print((a, d)) ('Alice', 'Berlin') ('Alice', 'Paris') ('Alice', 'Shanghai') ('Edith', 'Chicago') ('Edith', 'NYC') ('Zhao', 'Chicago') ('Zhao', 'NYC') ('Zhao', 'Berlin') ('Zhao', 'Paris') Specify outer joins with keyword arguments ``left_default`` and/or ``right_default``. Here is a full outer join in which unmatched elements are paired with None. >>> identity = lambda x: x >>> list(join(identity, [1, 2, 3], ... identity, [2, 3, 4], ... left_default=None, right_default=None)) [(2, 2), (3, 3), (None, 4), (1, None)] Usually the key arguments are callables to be applied to the sequences. If the keys are not obviously callable then it is assumed that indexing was intended, e.g. the following is a legal change. The join is implemented as a hash join and the keys of leftseq must be hashable. Additionally, if right_default is defined, then keys of rightseq must also be hashable. >>> # result = join(second, friends, first, cities) >>> result = join(1, friends, 0, cities) # doctest: +SKIP N)r?r@r rrirjrC)leftkeyleftseqrightkeyrightseq left_default right_defaultrFrGrE left_match seen_keysrkmatchesmatchs r/r%r%-sv G  "// H  $(##!!Az!*1mz&A*1 - -D(4..Cax -"#C&--J%t,,,,,  - -  ##1 (C#1 + +D(4..Cax +"#C&--J%t,,,,,-$T*****  + + * $1EE } : % /  1 1htnnS !81&'f11 )400000  1! / /htnnS !8/&'f11 )4000001(.....GGII 1 1LC)# 1$11E -00000511. 1 1r0c/HKt|}|dkr2t|dtr|d}t|}|dkrtd|dt }|t kr t |}n t|d|i}|dd}|*|D]%}||d|kr|V&dS|D]B}tt||}||d|kr|VCdS) a Return those items that differ between sequences >>> list(diff([1, 2, 3], [1, 2, 10, 100])) [(3, 10)] Shorter sequences may be padded with a ``default`` value: >>> list(diff([1, 2, 3], [1, 2, 10, 100], default=None)) [(3, 10), (None, 100)] A ``key`` function may also be applied to each item to use during comparisons: >>> list(diff(['apples', 'bananas'], ['Apples', 'Oranges'], key=str.lower)) [('bananas', 'Oranges')] rLrrTz(Too few sequences given (min 2 required)rrrEN) rMrrrorrrrr#rzrb)rPrQNrrfrErCvalss r/r'r'sS" D AAv*T!Wd++Aw II1uDBCCCjjJ//G*6T T5W55 **UD ! !C   E{{58$$)      ES%))Dzz$q'""a'    r0c|t|st|}ttj|||S)a: Find the k largest elements of a sequence Operates lazily in ``n*log(k)`` time >>> topk(2, [1, 100, 10, 1000]) (1000, 100) Use a key function to change sorted order >>> topk(2, ['Alice', 'Bob', 'Charlie', 'Dan'], key=len) ('Charlie', 'Alice') See also: heapq.nlargest N)rE)r?r@rzheapqnlargest)rIr.rEs r/r(r(sC  x}}Skk 3C000 1 11r0cnt|}t|}|tj|f|fS)a! Retrieve the next element of a sequence Returns the first element and an iterable equivalent to the original sequence, still having the element retrieved. >>> seq = [0, 1, 2, 3, 4] >>> first, seq = peek(seq) >>> first 0 >>> list(seq) [0, 1, 2, 3, 4] )r2r3r`r)r.iteratorrGs r/r)r)s3CyyH >>D $(33 33r0ct|}tt||}|tjt||fS)a; Retrieve the next n elements of a sequence Returns a tuple of the first n elements and an iterable equivalent to the original, still having the elements retrieved. >>> seq = [0, 1, 2, 3, 4] >>> first_two, seq = peekn(2, seq) >>> first_two (0, 1) >>> list(seq) [0, 1, 2, 3, 4] )r2rzrr`r)rwr.rpeekeds r/r*r*sCCyyH 48$$ % %F 9?4<<:: ::r0cptdsddlm}|tfd|S)a Return elements from a sequence with probability of prob Returns a lazy iterator of random items from seq. ``random_sample`` considers each item independently and without replacement. See below how the first time it returned 13 items and the next time it returned 6 items. >>> seq = list(range(100)) >>> list(random_sample(0.1, seq)) # doctest: +SKIP [6, 9, 19, 35, 45, 50, 58, 62, 68, 72, 78, 86, 95] >>> list(random_sample(0.1, seq)) # doctest: +SKIP [6, 44, 54, 61, 69, 94] Providing an integer seed for ``random_state`` will result in deterministic sampling. Given the same seed it will return the same sample every time. >>> list(random_sample(0.1, seq, random_state=2016)) [7, 9, 19, 25, 30, 32, 34, 48, 59, 60, 81, 98] >>> list(random_sample(0.1, seq, random_state=2016)) [7, 9, 19, 25, 30, 32, 34, 48, 59, 60, 81, 98] ``random_state`` can also be any object with a method ``random`` that returns floats between 0.0 and 1.0 (exclusive). >>> from random import Random >>> randobj = Random(2016) >>> list(random_sample(0.1, seq, random_state=randobj)) [7, 9, 19, 25, 30, 32, 34, 48, 59, 60, 81, 98] randomr)Randomc4kSr;)r)_prob random_states r/r>zrandom_sample..!sL//11D8r0)rrrfilter)rr.rrs` ` r/r+r+sW@ < * *,!!!!!!vl++ 88888# > >>r0r;)7r`rrArc functoolsrrrcollections.abcr toolz.utilsr__all__rr r r rNrOr r rrrr&rrrrrrrestrrrrrrrrrrr rr!r"r#r$r@r%r'r(r)r*r+r=r0r/rsc ........$$$$$$"""""" M'''$.&&&&R!!!H3338(((V+++\KKK08")))2 $ $ $ 0 0 0 * * *--- 4 4 4wtQ%6666r///$   ###&&&    $.M M M M `<???" !11112***Z   (5555@ * * *! l1l1l1l1^%%%P2222*444$;;;$$?$?$?$?$?$?r0