E#ikSSKrSSKrSSKrSSKrSSKJr SSKJrJr SSKJ r SSK J r Sr Sr \ 4S jrS rS rS rS rSrS1SjrSrSrSrSrSrSrSrSrSrSr\"\S5rSr \ 4Sjr!Sr"Sr#Sr$Sr%S r&S!r'\ 4S"jr(S#r)S$r*S%r+\+4S&jr,S'r-S(r.\ 4S)jr/S*r0\ \ 4S+jr1S,r2S1S-jr3S.r4S/r5S1S0jr6g)2N)partial) filterfalse zip_longest)Sequence) no_default)$remove accumulategroupby merge_sorted interleaveunique isiterable isdistincttakedroptake_nthfirstsecondnthlastgetconcatconcatvmapcatcons interpose frequenciesreducebyiteratesliding_window partition partition_allcountpluckjointaildifftopkpeekpeekn random_samplec[X5$)zReturn 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 b/home/james-whalen/.local/lib/python3.13/site-packages/ccxt/static_dependencies/toolz/itertoolz.pyr r s y &&c## [U5nU[:Xa [U5nOUnUv UHnU"X45nUv M g![a gf=f7f)aRepeatedly 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 r0r r s^6 s)C* #YF Lv$     s'A AA A A AAc[U5(d [U5n[R"S5nUHnX "U5"U5 M 0nUR 5HupVUR XE'M U$)aGroup 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 c/R$N)appendr1r0groupby..bs r1)callablegetter collections defaultdictitems__self__)keyr/ditemrvkvs r0r r Gsh2 C==Sk 12A #d) T B   Ir1c[U5S:Xa [/5$[U5S:Xa[US5$URSS5nUc [U5$[ X5$)aMerge 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] rrrGN)lenr3r_merge_sorted_binary_merge_sorted_binary_key)seqskwargsrGs r0r r ks\  4yA~Bx TaDG} **UD !C {#D))'22r1c## [U5S-nUSUn[U5S:Xa[US5nO [U5nXSn[U5S:Xa[US5nO [U5n[U5nUH+nXg:aUv UHnXg:aUv MUv M# OUv M- Uv UHnUv M gUv UHnUv M g![a UHnUv M gf=f7fNrr)rNr3rOr4r5)rQmidL1seq1L2seq2val2val1s r0rOrOs d)q.C dsB 2w!|BqE{#B' dB 2w!|BqE{#B'Dz  ;J;JJ J DJ J 1 DJs+A*C*- C 8AC* C'$C*&C''C*c## [U5S-nUSUn[U5S:Xa[US5nO [X15nXSn[U5S:Xa[US5nO [XQ5n[U5nU"U5n UH;nU"U5n X:a'Uv UHnU"U5n X:aUv MUv M3 OUv M= Uv UHnUv M gUv UHnUv M g![a UHnUv M gf=f7frT)rNr3rPr4r5) rQrGrVrWrXrYrZr[r\key2key1s r0rPrPs d)q.C dsB 2w!|BqE{'0 dB 2w!|BqE{'0Dz t9D4y ;J4y;JJ J  DJ J 7 DJs+A*D- C%8A-D%C?<D>C??Dc#0# [R"[[U55nUHn[ U5v M g![ aG [ [RW5n[R"[R"X155nOf=fMn7f)zInterleave 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 N) itertoolscyclemapr3r4r5roperatoris_not takewhile)rQitersitrr.s r0r r sy OOCdO ,E  K3i  K5IOOI$7$7 $IJE K s(&BABABBBBc## [5nURnUcUHnXB;dM U"U5 Uv M gUHnU"U5nXR;dMU"U5 Uv M g7f)zReturn 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/rGseenseen_addrIvals r0rrs^ 5DxxH {D  Dd)C  s"A!A Ac<[U5 g![a gf=f)zbIs x iterable? >>> isiterable([1, 2, 3]) True >>> isiterable('abc') True >>> isiterable(5) False TF)r3 TypeErrorxs r0rrs# Q s  c[U5ULa/[5nURnUHnX1;a gU"U5 M g[U5[[U55:H$)zAll values in sequence are distinct >>> isdistinct([1, 2, 3]) True >>> isdistinct([1, 2, 1]) False >>> isdistinct("Hello") False >>> isdistinct("World") True FT)r3rjrkrN)r/rlrmrIs r0rr%sU CyCu88D| TN3x3s3x=((r1c.[R"X5$)zrThe first n elements of a sequence >>> list(take(2, [10, 20, 30, 40, 50])) [10, 20] See Also: drop tail raislicenr/s r0rr>s   C ##r1cxX*S$![[4a" [[R"X55s$f=f)zkThe last n elements of a sequence >>> tail(2, [10, 20, 30, 40, 50]) [40, 50] See Also: drop take N)rpKeyErrortuplerCdequerws r0r'r'Ks<023x x 0[&&s.//0s /99c0[R"XS5$)zThe sequence following the first n elements >>> list(drop(2, [10, 20, 30, 40, 50])) [30, 40, 50] See Also: take tail Nrurws r0rr[s   CD ))r1c4[R"USSU5$)zPEvery nth item in seq >>> list(take_nth(2, [10, 20, 30, 40, 50])) [10, 30, 50] rNrurws r0rrhs   CD! ,,r1c*[[U55$)z6The first element in a sequence >>> first('ABC') 'A' )r4r3r/s r0rrqs S ?r1cD[U5n[U5 [U5$)z8The second element in a sequence >>> second('ABC') 'B' )r3r4rs r0rrzs s)CI 9r1c[U[[[45(aX$[ [ R "XS55$)z5The nth element in a sequence >>> nth(1, 'ABC') 'B' N) isinstancer{listrr4rarvrws r0rrs7 #tX.//v I$$ST233r1c [SU5S$)z4The last element in a sequence >>> last('ABC') 'C' rr)r'rs r0rrs 3<?r1c<X$![[4a Us$f=fr<)rz IndexErrorindr/defaults r0_getrs'x j !s cr^^TU$![a [U[5(a`T[:Xa>[ U5S:a[ R "U6"T5s$U(a TUS4s$g[UU4SjU55s$T[:waTs$e[[4a T[:XaeTs$f=f)aGet 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 rrr>c3>># UHn[UTT5v M g7fr<r).0irr/s r0 get..s@CqT!S'22C) rprrrrNrd itemgetterr{rzrrs ``r0rrsB3x  c4 *$s8a<#..4S99s1v;<'@C@@@  "N  j ! j N s( AB6B60B6 B6B65B6c@[RRU5$)aVConcatenate 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 )rachain from_iterablerQs r0rrs ?? ( ( ..r1c[U5$)ztVariadic version of concat >>> list(concatv([], ["a"], ["b", "c"])) ['a', 'b', 'c'] See also: itertools.chain )rrs r0rrs $<r1c*[[X55$)zApply 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'] )rrc)funcrQs r0rrs #d/ ""r1c2[R"U/U5$)z^Add el to beginning of (possibly infinite) sequence seq. >>> list(cons(1, [2, 3])) [1, 2, 3] )rar)elr/s r0rrs ??B4 %%r1cn[[[R"U5U55n[ U5 U$)zpIntroduce element between each pair of elements in seq >>> list(interpose("a", [1, 2, 3])) [1, 'a', 2, 'a', 3] )rziprarepeatr4)rr/inposeds r0rrs, S))"-s34GM Nr1cv[R"[5nUHnX==S- ss'M [U5$)zFind 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 r)rCrDintdict)r/rHrIs r0rrs2 $A 1  7Nr1c^U[:HnU(d[U5(dUmU4Sjn[U5(d [U5n0nUH3nU"U5nXu;aU(aXeU'MU"5XW'U"XWU5XW'M5 U$)aPerform 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])} c>T$r<r>)_initsr0r?reduceby..isur1)rrArB) rGr6r/init is_no_defaultrHrIrKrs @r0rr)szJ&M $ C==Sk A I :!vQT4  Hr1c#(# Uv U"U5nM7f)aRepeatedly 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>)rrrs r0r r ys2  G sc Z[S[[R"X5556$)aGA 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] c3# UH;up[R"[R"X!5S5=(d Uv M= g7f)rN)rCr|rarv)rrits r0r!sliding_window..s9><51""9#3#3B#:A>D"D%immC&;<> ??r1 __no__pad__cX[U5/U-nU[La[U6$[USU06$)aPartition 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)r3no_padrr)rxr/padargss r0r"r"s4$ I;?D f}DzD0C00r1c#h# [U5/U-n[US[06n[U5nUH nUv UnM US[LaUS[ U5U-v gUv g![a gf=f![ a3 SUpvXg:a!Xg-S-nXH[LaUnOUS-nXg:aM!USUv gf=f7f)aPartition 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 rNrrUr)r3rrr4r5rNrp) rxr/rrprevrIlohirVs r0r#r#s I;?D d -f -BBx  Bx6 }C1 % % 1   'w1n9&BqB ' s)O sQB2 A"B2 A2B2" A/,B2.A//B221B/%B/,B2.B//B2c^[US5(a [U5$[SU55$)zCount 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__c3&# UHnSv M g7f)rNr>)rrs r0rcount..s#Qq#s)hasattrrNsumrs r0r$r$s+sI3x # r1c^^T[:Xa[T5n[X15$[T[5(a UU4SjU5$UU4SjU5$)aPplucks 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 c3R>^# UHm[UU4SjT55v M g7f)c3>># UHn[UTT5v M g7fr<r)rrIrr/s r0r"pluck...s?34d4g..3rN)r{rr/rrs @r0rpluck..s&!C?3???s#'c3>># UHn[TUT5v M g7fr<rrs r0rrs 4tDc7 # #tr)rrBrcrr)rrQrrs` ` r0r%r%sJ.*Sk3~ C  !! ! 4t 44r1c^[T[5(a7[T5S:Xa TSmU4Sj$T(a[R"T6$S$[R"T5$)Nrrc>UT4$r<r>)rrindexs r0r?getter..$s ah[r1cg)Nr>r>rqs r0r?r(sRr1)rrrNrdr)rs`r0rBrB sU% u:?!HE( ( &&. . ""5))r1c# # [U5(d [U5n[U5(d [U5n[X5nU[:Xa3U[:Xa)UH"nU"U5nX;dMXhHn X4v M M$ gU[:wa8U[:Xa.UH'nU"U5nX;aXhHn X4v M M"XG4v M) gU[:wa[ 5n U R n U[:Xa1UH*nU"U5nU "U5 X;dMXhHn X4v M M, O5UH/nU"U5nU "U5 X;aXhHn X4v M M*XG4v M1 UR 5HupX;dM U Hn X4v M M gg7f)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', 'Sydney'), ... ('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)rArBr rrjrkrE)leftkeyleftseqrightkeyrightseq left_default right_defaultrHrIrG left_match seen_keysrlmatchesmatchs r0r&r&-sv G  / H  (#!Az!mz&AD4.Cx"#&J%,,#)  # (CD4.Cx"#&J%,,#)$**  * $E }} : % tnS 8&'f )00'- !!tnS 8&'f )00'-(..!GGILC#$E 00%&/ %sA&F,BF A"F/Fc/# [U5nUS:Xa([US[5(aUSn[U5nUS:a [S5eUR S[ 5nU[ :Xa [ U6nO [USU06nUR SS5nUc(UH!nURUS5U:wdMUv M# gUH5n[[XV55nURUS5U:wdM1Uv M7 g7f) aReturn 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')] rrrUz(Too few sequences given (min 2 required)rrrGN) rNrrrprrrrr$r{rc)rQrRNrrgrGrEvalss r0r(r(s" D AAv*T!Wd++Aw I1uBCCjjJ/G*T T5W5 **UD !C {E{{58$) ES)Dzz$q'"a' sB/C:58C:1 C:czUb[U5(d [U5n[[R"XUS95$)aFind 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 )rG)rArBr{heapqnlargest)rKr/rGs r0r)r)s0  x}}Sk C0 11r1cb[U5n[U5nU[R"U4U54$)zRetrieve 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] )r3r4rar)r/iteratorrIs r0r*r*s.CyH >D $(3 33r1c[U5n[[X55nU[R"[U5U54$)aRetrieve 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] )r3r{rrar)rxr/rpeekeds r0r+r+s6CyH 4$ %F 9??4<: ::r1cf^^[TS5(dSSKJn U"T5m[UU4SjU5$)aWReturn 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)Randomc*>TR5T:$r<)r)_prob random_states r0r?random_sample..!sL//1D8r1)rrrfilter)rr/rrs` ` r0r,r,s.@ < * *!l+ 8# >>r1r<)7rarrCrd functoolsrrrcollections.abcrutilsr__all__r r r r rOrPr rrrrr'rrrrrrrestrrrrrrrrrr r!rr"r#r$r%rBr&r(r)r*r+r,r>r1r0rs/ .$ M'$.&R!H38(V+\K08")2 $ 0 *- 4tQ%6r/$ #&  $.M `<?" !12*Z (5@ *! l1^%P2*4$;$$?r1