bgCddlZddlZddlmZmZmZmZddlmZddl m Z m Z m Z m Z ddlmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZm Z ddlm!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,dd l-m-Z-m.Z.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7dd l8m9Z9m:Z:dd l;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHgdZIeJeddZKddZLe>fdZMe>fdZNe>fdZOGddZPdZQdZRdZSdZTddZUdZVddZWdd ZXdd!ZYd"ZZdd#Z[d$Z\dd%Z]Gd&d'Z^dd(Z_d)Z`d*Zadd+Zbdd,Zcdd-Zddd.Zedd0Zfdd1Zgdd2Zhdd3Zid4Zjdd5Zkdd7Zldd8Zmd9Zndd;Zod<Zpddd=d>Zqdd@ZrdAZsdBZteuevffdCZwddDZxddEZyGdFdGejejzZ{ddHZ|dIZ}e~dfdJZdKZdLZdMZdNZGdOdPZdQZdRZdSfdTZe3fddUdVZGdWdXeZGdYdZZGd[d\Ze~fd]Zd^Zd?d_Zdd`Ze~dfdaZddbZdcZdddZGdedfZddgZdhZdiZdjZdkZdlZdmZdnfdoZdpZdqZddrZddsZGdtdueZGdvdwZdxZddyZdzZd{Zd|Zd}Zd~ZdZdZdZGddZdZeuevfdddZddZddZddZddZde>ddZdedfdZdZdZdZdZdZdZdZdZdZdZdZdZdS)N)Counter defaultdictdequeabc)Sequence)cached_propertypartialreducewraps)heapify heapreplaceheappop)chain combinationscompresscountcycle dropwhilegroupbyislicerepeatstarmap takewhiletee zip_longestproduct) combeexp factorialfloorfsumlogpermtau)EmptyQueue)random randrangeuniform) itemgettermulsubgtltgele) hexversionmaxsize) monotonic) _marker _zip_equalUnequalIterablesErrorconsumeflattenpairwisepowersettakeunique_everseen all_equalbatched)n AbortThread SequenceViewr8adjacent all_uniquealways_iterablealways_reversiblebucket callback_iterchunked chunked_evencircular_shiftscollapsecombination_index"combination_with_replacement_indexconsecutive_groupsconstrained_batchesconsumer count_cycle countabledft differencedistinct_combinationsdistinct_permutations distributedivide doublestarmapduplicates_everseenduplicates_justseenclassify_unique exactly_n filter_except filter_mapfirst gray_productgroupby_transformichunkediequalsidftilen interleaveinterleave_evenlyinterleave_longest intersperse is_sortedislice_extendediterate iter_suppress join_mappingslastlocatelongest_common_prefixlstripmake_decorator map_exceptmap_if map_reduce mark_endsminmax nth_or_lastnth_permutation nth_product nth_combination_with_replacement numeric_rangeoneonly outer_productpaddedpartial_product partitionspeekablepermutation_indexpowerset_of_sets product_indexraise_ repeat_each repeat_lastreplacerlocaterstrip run_lengthsampleseekableset_partitions side_effectsliced sort_together split_aftersplit_at split_before split_into split_whenspystaggerstrip strictly_n substringssubstrings_indexestakewhile_inclusive time_limitedunique_in_windowunique_to_eachunzip value_chainwindowedwindowed_complete with_iter zip_broadcast zip_equal zip_offsetsumprodcHttt||SN)r"mapr,)xys ]/opt/cloudlinux/venv/lib64/python3.11/site-packages/setuptools/_vendor/more_itertools/more.pyrs$s31~~2F2FFc tttt|g|r.tdfd}t|SS)aJBreak *iterable* into lists of length *n*: >>> list(chunked([1, 2, 3, 4, 5, 6], 3)) [[1, 2, 3], [4, 5, 6]] By the default, the last yielded list will have fewer than *n* elements if the length of *iterable* is not divisible by *n*: >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)) [[1, 2, 3], [4, 5, 6], [7, 8]] To use a fill-in value instead, see the :func:`grouper` recipe. If the length of *iterable* is not divisible by *n* and *strict* is ``True``, then ``ValueError`` will be raised before the last list is yielded. Nz*n must not be None when using strict mode.c3bKD](}t|krtd|V)dS)Nziterable is not divisible by n.len ValueError)chunkiteratorns rretzchunked..retsI!  u::??$%FGGG   r)iterr r=r)iterablerstrictrrs ` @rrIrIsz&GD!T(^^44b99H  9IJJ J       CCEE{{rcF|D]}|cS|turtd|S)aReturn the first item of *iterable*, or *default* if *iterable* is empty. >>> first([0, 1, 2, 3]) 0 >>> first([], 'some default') 'some default' If *default* is not provided and there are no items in the iterable, raise ``ValueError``. :func:`first` is useful when you have a generator of expensive-to-retrieve values and want any arbitrary one. It is marginally shorter than ``next(iter(iterable), default)``. zKfirst() was called on an empty iterable, and no default value was provided.)r6r)rdefaultitems rrarasE" ' *    NrcH t|tr|dSt|dr'tdkrt t |St |ddS#tttf$r|turtd|cYSwxYw)aReturn the last item of *iterable*, or *default* if *iterable* is empty. >>> last([0, 1, 2, 3]) 3 >>> last([], 'some default') 'some default' If *default* is not provided and there are no items in the iterable, raise ``ValueError``. __reversed__ir5maxlenzDlast() was called on an empty iterable, and no default was provided.) isinstancerhasattrr2nextreversedr IndexError TypeError StopIterationr6r)rrs rrqrqs h ) ) 1B<  X~ . . 1J*4L4L**++ +!,,,R0 0  = 1 g    sA-6A-A--1B! B!cFtt||dz|S)agReturn the nth or the last item of *iterable*, or *default* if *iterable* is empty. >>> nth_or_last([0, 1, 2, 3], 2) 2 >>> nth_or_last([0, 1], 2) 1 >>> nth_or_last([], 0, 'some default') 'some default' If *default* is not provided and there are no items in the iterable, raise ``ValueError``. r5r)rqr)rrrs rr{r{s% xQ'' 9 9 99rcFeZdZdZdZdZdZefdZdZ dZ dZ d Z d S) raWrap an iterator to allow lookahead and prepending elements. Call :meth:`peek` on the result to get the value that will be returned by :func:`next`. This won't advance the iterator: >>> p = peekable(['a', 'b']) >>> p.peek() 'a' >>> next(p) 'a' Pass :meth:`peek` a default value to return that instead of raising ``StopIteration`` when the iterator is exhausted. >>> p = peekable([]) >>> p.peek('hi') 'hi' peekables also offer a :meth:`prepend` method, which "inserts" items at the head of the iterable: >>> p = peekable([1, 2, 3]) >>> p.prepend(10, 11, 12) >>> next(p) 10 >>> p.peek() 11 >>> list(p) [11, 12, 1, 2, 3] peekables can be indexed. Index 0 is the item that will be returned by :func:`next`, index 1 is the item after that, and so on: The values up to the given index will be cached. >>> p = peekable(['a', 'b', 'c', 'd']) >>> p[0] 'a' >>> p[1] 'b' >>> next(p) 'a' Negative indexes are supported, but be aware that they will cache the remaining items in the source iterator, which may require significant storage. To check whether a peekable is exhausted, check its truth value: >>> p = peekable(['a', 'b']) >>> if p: # peekable has items ... list(p) ['a', 'b'] >>> if not p: # peekable is exhausted ... list(p) [] cTt||_t|_dSr)r_itr_cacheselfrs r__init__zpeekable.__init__Is>>gg rc|Srrs r__iter__zpeekable.__iter__M rcT |n#t$rYdSwxYwdSNFTpeekrrs r__bool__zpeekable.__bool__P=  IIKKKK   55 t  %%c|jsJ |jt|jn#t$r|t ur|cYSwxYw|jdS)zReturn the item that will be next returned from ``next()``. Return ``default`` if there are no items left. If ``default`` is not provided, raise ``StopIteration``. r)rappendrrrr6)rrs rrz peekable.peekWst{   ""4>>2222    g%% {1~s,6AAcT|jt|dS)aStack up items to be the next ones returned from ``next()`` or ``self.peek()``. The items will be returned in first in, first out order:: >>> p = peekable([1, 2, 3]) >>> p.prepend(10, 11, 12) >>> next(p) 10 >>> list(p) [11, 12, 1, 2, 3] It is possible, by prepending items, to "resurrect" a peekable that previously raised ``StopIteration``. >>> p = peekable([]) >>> next(p) Traceback (most recent call last): ... StopIteration >>> p.prepend(1) >>> next(p) 1 >>> next(p) Traceback (most recent call last): ... StopIteration N)r extendleftr)ritemss rprependzpeekable.prependgs&: x/////rcj|jr|jSt|jSr)rpopleftrrrs r__next__zpeekable.__next__s. ; );&&(( (DH~~rcd|jdn|j}|dkr&|jdn|j}|jtn|j}n?|dkr*|jdn|j}|j t dz n|j}nt d|dks|dkr |j|jnptt||dzt}t|j}||kr0|jt|j||z t|j|S)Nr5rrzslice step cannot be zero) stepstartstopr3rrextendrminmaxrrlist)rindexrrrr cache_lens r _get_slicezpeekable._get_slices(Z'qqej !88+-AAEKE$z177 DD AXX ;.BBU[E&+j&8WHqLLuzDD899 9 AII4!88 K  tx ( ( ( (Ct$$q('22ADK((II~~ ""6$(A M#B#BCCCDK  ''rcVt|tr||St|j}|dkr |j|jn9||kr3|jt|j|dz|z |j|SNrr5)rslicerrrrrr)rrrs r __getitem__zpeekable.__getitem__s eU # # *??5)) ) $$ 199 K  tx ( ( ( ( i   K  vdh I0EFF G G G{5!!rN) __name__ __module__ __qualname____doc__rrrr6rrrrrrrrrrs88t# 000> (((4 " " " " "rrc<tfd}|S)abDecorator that automatically advances a PEP-342-style "reverse iterator" to its first yield point so you don't have to call ``next()`` on it manually. >>> @consumer ... def tally(): ... i = 0 ... while True: ... print('Thing number %s is %s.' % (i, (yield))) ... i += 1 ... >>> t = tally() >>> t.send('red') Thing number 0 is red. >>> t.send('fish') Thing number 1 is fish. Without the decorator, you would have to call ``next(t)`` before ``t.send()`` could be used. c6|i|}t||Srr)argskwargsgenfuncs rwrapperzconsumer..wrappers'dD#F## S  r)r )r r s` rrQrQs5. 4[[[ Nrczt}tt||dt|S)zReturn the number of items in *iterable*. >>> ilen(x for x in range(1000000) if x % 3 == 0) 333334 This consumes the iterable, so handle with care. rr)rrzipr)rcounters rrgrgs6ggG #h ++++ ==rc#NK |V ||}n#t$rYdSwxYw#)zReturn ``start``, ``func(start)``, ``func(func(start))``, ... >>> from itertools import islice >>> list(islice(iterate(lambda x: 2*x, 1), 10)) [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] TN)r)r rs rrnrnsO  DKKEE    EE  s  ##c#PK|5}|Ed{VddddS#1swxYwYdS)a:Wrap an iterable in a ``with`` statement, so it closes once exhausted. For example, this will close the file when the iterator is exhausted:: upper_lines = (line.upper() for line in with_iter(open('foo'))) Any context manager which returns an iterable is a candidate for ``with_iter``. Nr)context_managerrs rrrs Hs ct|} t|}n$#t$r}|ptd|d}~wwxYw t|}d||}|pt|#t$rYnwxYw|S)aReturn the first item from *iterable*, which is expected to contain only that item. Raise an exception if *iterable* is empty or has more than one item. :func:`one` is useful for ensuring that an iterable contains only one item. For example, it can be used to retrieve the result of a database query that is expected to return a single row. If *iterable* is empty, ``ValueError`` will be raised. You may specify a different exception with the *too_short* keyword: >>> it = [] >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: too many items in iterable (expected 1)' >>> too_short = IndexError('too few items') >>> one(it, too_short=too_short) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... IndexError: too few items Similarly, if *iterable* contains more than one item, ``ValueError`` will be raised. You may specify a different exception with the *too_long* keyword: >>> it = ['too', 'many'] >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: Expected exactly one item in iterable, but got 'too', 'many', and perhaps more. >>> too_long = RuntimeError >>> one(it, too_long=too_long) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... RuntimeError Note that :func:`one` attempts to advance *iterable* twice to ensure there is only one item. See :func:`spy` or :func:`peekable` to check iterable contents less destructively. z&too few items in iterable (expected 1)NLExpected exactly one item in iterable, but got {!r}, {!r}, and perhaps more.)rrrrformat)r too_shorttoo_longit first_valueexc second_valuemsgs rrrsX hB2hh   M$LMM  *Bxx  &{L A A )*S//)       s$! A=AA<< B B c ||rr) exceptionrs rrrFs )T rc# K|d}|d}t|}t|D]3} t|}|V#t$r||YdSwxYw t|||dzdS#t$rYdSwxYw)awValidate that *iterable* has exactly *n* items and return them if it does. If it has fewer than *n* items, call function *too_short* with those items. If it has more than *n* items, call function *too_long* with the first ``n + 1`` items. >>> iterable = ['a', 'b', 'c', 'd'] >>> n = 4 >>> list(strictly_n(iterable, n)) ['a', 'b', 'c', 'd'] Note that the returned iterable must be consumed in order for the check to be made. By default, *too_short* and *too_long* are functions that raise ``ValueError``. >>> list(strictly_n('ab', 3)) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: too few items in iterable (got 2) >>> list(strictly_n('abc', 2)) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: too many items in iterable (got at least 3) You can instead supply functions that do something else. *too_short* will be called with the number of items in *iterable*. *too_long* will be called with `n + 1`. >>> def too_short(item_count): ... raise RuntimeError >>> it = strictly_n('abcd', 6, too_short=too_short) >>> list(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... RuntimeError >>> def too_long(item_count): ... print('The boss is going to hear about this') >>> it = strictly_n('abcdef', 4, too_long=too_long) >>> list(it) The boss is going to hear about this ['a', 'b', 'c', 'd'] NcRttd|S)Nz"Too few items in iterable (got {})rrr item_counts rrzstrictly_n..zs$v  0 7 7 C C( ( rcRttd|S)Nz,Too many items in iterable (got at least {})rr s rrzstrictly_n..s$f  : A A* M M' ' rr5)rrangerr)rrrrrirs rrrJs^     hB 1XX 88D JJJJ     IaLLL FFF   R Q      s#AAA A?? B  B cfd}d}t|}t||}d|cxkrkr nn|kr ||n |||St|rdndS)aYield successive distinct permutations of the elements in *iterable*. >>> sorted(distinct_permutations([1, 0, 1])) [(0, 1, 1), (1, 0, 1), (1, 1, 0)] Equivalent to ``set(permutations(iterable))``, except duplicates are not generated and thrown away. For larger input sequences this is much more efficient. Duplicate permutations arise when there are duplicated elements in the input iterable. The number of items returned is `n! / (x_1! * x_2! * ... * x_n!)`, where `n` is the total number of items input, and each `x_i` is the count of a distinct item in the input sequence. If *r* is given, only the *r*-length permutations are yielded. >>> sorted(distinct_permutations([1, 0, 1], r=2)) [(0, 1), (1, 0), (1, 1)] >>> sorted(distinct_permutations(range(3), r=2)) [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)] c3>K t|Vtdz ddD]}||||dzkrndStdz |dD]}||||krn||||c||<||<|d|z d||dzd<)NTrr5)tupler#)Ar$jsizes r_fullz$distinct_permutations.._fulls ,((NNN4!8R,,  Q4!AE(??E#4!8Q++  Q4!A$;;E 1qtJAaD!A$?QX?+Aa!eggJ) ,rc34K|d|||d}}t|dz dd}tt|} t|V|d}|D]}|||krn ||}dS|D]-}||||kr||||c||<||<n1.|D]-}||||kr||||c||<||<n.||d||z dz }|dz }|d||z |||z dc||d<|dd<)Nr5r)r#rr() r)rheadtailright_head_indexesleft_tail_indexespivotr$r*s r_partialz'distinct_permutations.._partialsrrUAabbEd"1q5"b11!#d)),, =++   HE'  7U??EQ'  7T!W$$'+AwQ$DGT!WE% ,AAwa((+/7DG(Qa) D1q52& &D FA $Wq1uW tAEGG} DHd111g? =rNrr)r)sortedrr)rr.r,r4rr+s @rrWrWs4,,,,,0%=%=%=N 8  E u::Dy 1}}}}}}}}} !T uuU|||0B0BB a"U # ##rc(|dkrtd|dkr,ttt||ddSt|g}t ||}t tt||ddS)a6Intersperse filler element *e* among the items in *iterable*, leaving *n* items between each filler element. >>> list(intersperse('!', [1, 2, 3, 4, 5])) [1, '!', 2, '!', 3, '!', 4, '!', 5] >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2)) [1, 2, None, 3, 4, None, 5] rz n must be > 0r5N)rrrhrrIr:)rrrfillerchunkss rrkrks Avv))) ajH55q$??? 1%%vj88!TBBCCCrcd|D}ttjtt|fdDfd|DS)aReturn the elements from each of the input iterables that aren't in the other input iterables. For example, suppose you have a set of packages, each with a set of dependencies:: {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}} If you remove one package, which dependencies can also be removed? If ``pkg_1`` is removed, then ``A`` is no longer necessary - it is not associated with ``pkg_2`` or ``pkg_3``. Similarly, ``C`` is only needed for ``pkg_2``, and ``D`` is only needed for ``pkg_3``:: >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'}) [['A'], ['C'], ['D']] If there are duplicates in one input iterable that aren't in the others they will be duplicated in the output. Input order is preserved:: >>> unique_to_each("mississippi", "missouri") [['p', 'p'], ['o', 'u', 'r']] It is assumed that the elements of each iterable are hashable. c,g|]}t|Sr)r.0rs r z"unique_to_each..1s ) ) )DHH ) ) )rc,h|]}|dk|Sr5r)r<elementcountss r z!unique_to_each..3s'EEE7w10D0Dw0D0D0DrcTg|]$}ttj|%Sr)rfilter __contains__)r<runiquess rr=z"unique_to_each..4s. B B BrD,b11 2 2 B B Br)rr from_iterablerset) iterablespoolrArFs @@rrrsl6 * )y ) ) )D U(S$88 9 9FEEEEfEEEG B B B BT B B BBrc#6K|dkrtd|dkrdVdS|dkrtdt|}tt|||}|sdSt ||kr*t ||f|t |z zzVdSt |V|f||kr|dz n|dz z}t |jt||}t||dz d|D]}t |VdS)aMReturn a sliding window of width *n* over the given iterable. >>> all_windows = windowed([1, 2, 3, 4, 5], 3) >>> list(all_windows) [(1, 2, 3), (2, 3, 4), (3, 4, 5)] When the window is larger than the iterable, *fillvalue* is used in place of missing values: >>> list(windowed([1, 2, 3], 4)) [(1, 2, 3, None)] Each window will advance in increments of *step*: >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2)) [(1, 2, 3), (3, 4, 5), (5, 6, '!')] To slide into the iterable's items, use :func:`chain` to add filler items to the left: >>> iterable = [1, 2, 3, 4] >>> n = 3 >>> padding = [None] * (n - 1) >>> list(windowed(chain(padding, iterable), 3)) [(None, None, 1), (None, 1, 2), (1, 2, 3), (2, 3, 4)] rn must be >= 0rNr5zstep must be >= 1r) rrrrrr(rrr) seqr fillvaluerrwindowpaddingr7_s rrr7sT6 1uu)***Avv axx,---CyyH6(A&&q 1 1 1F  6{{QFmm |q3v;;?@@@@ --ltqyya!eedQh?G h 8 8 9 9FFD1HdD 1 1Fmmrc#Kg}t|D]}|||fVt|}t|}t d|dzD])}t ||z dzD]}||||zV*dS)aFYield all of the substrings of *iterable*. >>> [''.join(s) for s in substrings('more')] ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more'] Note that non-string iterables can also be subdivided. >>> list(substrings([0, 1, 2])) [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)] r'r5N)rrr(rr#)rrMrr!rr$s rrrqs CX 4g **CSJ1j1n % %!!zA~)** ! !Aa!a%i.  !!!rctdtdz}|rt|}fd|DS)a@Yield all substrings and their positions in *seq* The items yielded will be a tuple of the form ``(substr, i, j)``, where ``substr == seq[i:j]``. This function only works for iterables that support slicing, such as ``str`` objects. >>> for item in substrings_indexes('more'): ... print(item) ('m', 0, 1) ('o', 1, 2) ('r', 2, 3) ('e', 3, 4) ('mo', 0, 2) ('or', 1, 3) ('re', 2, 4) ('mor', 0, 3) ('ore', 1, 4) ('more', 0, 4) Set *reverse* to ``True`` to yield the same items in the opposite order. r5c3K|]<}tt|z dzD]}|||z|||zfV=dSr5N)r#r)r<Lr$rMs r z%substrings_indexes..sv  '(uSXX\A=M7N7N  23QQYAE"       r)r#rr)rMreverser.s` rrrs\4 aSAA QKK    ,-   rc2eZdZdZddZdZdZdZdZdS) rGaWrap *iterable* and return an object that buckets the iterable into child iterables based on a *key* function. >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3'] >>> s = bucket(iterable, key=lambda x: x[0]) # Bucket by 1st character >>> sorted(list(s)) # Get the keys ['a', 'b', 'c'] >>> a_iterable = s['a'] >>> next(a_iterable) 'a1' >>> next(a_iterable) 'a2' >>> list(s['b']) ['b1', 'b2', 'b3'] The original iterable will be advanced and its items will be cached until they are used by the child iterables. This may require significant storage. By default, attempting to select a bucket to which no items belong will exhaust the iterable and cache all values. If you specify a *validator* function, selected buckets will instead be checked against it. >>> from itertools import count >>> it = count(1, 2) # Infinite sequence of odd numbers >>> key = lambda x: x % 10 # Bucket by last digit >>> validator = lambda x: x in {1, 3, 5, 7, 9} # Odd digits only >>> s = bucket(it, key=key, validator=validator) >>> 2 in s False >>> list(s[2]) [] Nct||_||_tt|_|pd|_dS)NcdSNTrrs rrz!bucket.__init__..s$r)rr_keyrrr _validator)rrkey validators rrzbucket.__init__s7>> !%(( #7rc||sdS t||}|j||n#t$rYdSwxYwdSr)r_rr appendleftr)rvaluers rrEzbucket.__contains__s|u%% 5 0U $$D K  ) )$ / / / /   55  tsA AAc#dK |j|r"|j|Vn~ t|j}n#t$rYdSwxYw||}||kr|Vn6||r |j||})z Helper to yield items from the parent iterator that match *value*. Items that don't match are stored in the local cache as they are encountered. TN)rrrrrr^r_r)rrdr item_values r _get_valueszbucket._get_valuess  ={5! =k%(00222222 =#DH~~(!%4J!U**" 44= J/66t<<< = =sA AAc#K|jD]L}||}||r |j||M|jEd{VdSr)rr^r_rrkeys)rrrfs rrzbucket.__iter__sH 5 5D4Jz** 5 J'..t444;##%%%%%%%%%%%rct||stdS||S)Nr)r_rrgrrds rrzbucket.__getitem__s5u%% 88O&&&rr) rrrrrrErgrrrrrrGrGso!!F8888   ===4&&&'''''rrGct|}t||}|t||fS)aReturn a 2-tuple with a list containing the first *n* elements of *iterable*, and an iterator with the same items as *iterable*. This allows you to "look ahead" at the items in the iterable without advancing it. There is one item in the list by default: >>> iterable = 'abcdefg' >>> head, iterable = spy(iterable) >>> head ['a'] >>> list(iterable) ['a', 'b', 'c', 'd', 'e', 'f', 'g'] You may use unpacking to retrieve items instead of lists: >>> (head,), iterable = spy('abcdefg') >>> head 'a' >>> (first, second), iterable = spy('abcdefg', 2) >>> first 'a' >>> second 'b' The number of items requested can be larger than the number of items in the iterable: >>> iterable = [1, 2, 3, 4, 5] >>> head, iterable = spy(iterable, 10) >>> head [1, 2, 3, 4, 5] >>> list(iterable) [1, 2, 3, 4, 5] )rr=copyr)rrrr/s rrr s8J hB 2;;D 99;;dB ''rc8tjt|S)a4Return a new iterable yielding from each iterable in turn, until the shortest is exhausted. >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8])) [1, 4, 6, 2, 5, 7] For a version that doesn't terminate after the shortest iterable is exhausted, see :func:`interleave_longest`. )rrGr rIs rrhrh8s  sI / //rc`tjt|dti}d|DS)asReturn a new iterable yielding from each iterable in turn, skipping any that are exhausted. >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8])) [1, 4, 6, 2, 5, 7, 3, 8] This function produces the same output as :func:`roundrobin`, but may perform better for some inputs (in particular when the number of iterables is large). rNc3,K|]}|tu |VdSr)r6r<rs rrWz%interleave_longest..Ss, - -!AW,,A,,,, - -r)rrGrr6)rIr$s rrjrjFs5 KFgFFGGA - -q - - --rc#K+ dDnL#t$rtdwxYwttkrtdt}tt |fdd}fd|D}fd |D}|d |d d}}|d |d d} }||zgt|z} t } | r{t |V| d z} d t| |D} t| D]7\} } | d kr,t | | V| d z} | | xx|z cc<8| ydSdS) aG Interleave multiple iterables so that their elements are evenly distributed throughout the output sequence. >>> iterables = [1, 2, 3, 4, 5], ['a', 'b'] >>> list(interleave_evenly(iterables)) [1, 2, 'a', 3, 4, 'b', 5] >>> iterables = [[1, 2, 3], [4, 5], [6, 7, 8]] >>> list(interleave_evenly(iterables)) [1, 6, 4, 2, 7, 3, 8, 5] This function requires iterables of known length. Iterables without ``__len__()`` can be used by manually specifying lengths with *lengths*: >>> from itertools import combinations, repeat >>> iterables = [combinations(range(4), 2), ['a', 'b', 'c']] >>> lengths = [4 * (4 - 1) // 2, 3] >>> list(interleave_evenly(iterables, lengths=lengths)) [(0, 1), (0, 2), 'a', (0, 3), (1, 2), 'b', (1, 3), (2, 3), 'c'] Based on Bresenham's algorithm. Nc,g|]}t|Sr)rr;s rr=z%interleave_evenly..ps3332s2ww333rz^Iterable lengths could not be determined automatically. Specify them with the lengths keyword.z,Mismatching number of iterables and lengths.c|Srr)r$lengthss rrz#interleave_evenly..}s 71:rTr`rXc g|] }| Srr)r<r$rvs rr=z%interleave_evenly..s8881GAJ888rc:g|]}t|Sr)r)r<r$rIs rr=z%interleave_evenly..s%>>>$y|$$>>>rrr5cg|] \}}||z  Srr)r<rdeltas rr=z%interleave_evenly..s JJJ5!e)JJJr) rrrr5r#sumrr  enumerate)rIrvdimslengths_permute lengths_desc iters_desc delta_primarydeltas_secondary iter_primaryiters_secondaryerrorsto_yieldr$e_s`` rririVs0 33333GG   9   Y3w<< ' 'GHHH w<>>>o>>>J'31o|ABB7G#M$.qM:abb>/Lt# $s+;'<'< Flatten an iterable with multiple levels of nesting (e.g., a list of lists of tuples) into non-iterable types. >>> iterable = [(1, 2), ([3, 4], [[5], [6]])] >>> list(collapse(iterable)) [1, 2, 3, 4, 5, 6] Binary and text strings are not considered iterable and will not be collapsed. To avoid collapsing other types, specify *base_type*: >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']] >>> list(collapse(iterable, base_type=tuple)) ['ab', ('cd', 'ef'), 'gh', 'ij'] Specify *levels* to stop flattening after a certain level: >>> iterable = [('a', ['b']), ('c', ['d'])] >>> list(collapse(iterable)) # Fully flattened ['a', 'b', 'c', 'd'] >>> list(collapse(iterable, levels=1)) # Only one level flattened ['a', ['b'], 'c', ['d']] rr5N) rrcrrrstrbytesrr) r base_typelevelsstack node_grouplevelnodesnodetrees rrLrLsR4 GGE a!,,-... ]]__ ! u  %&..          D$e -- &JtY,G,G&  ::D $$Z000$$eai%6777E!JJJJJ' sCC+*C+c#K | |||D]}|||Vn&t||D]}|||Ed{V| |dSdS#| |wwxYw)auInvoke *func* on each item in *iterable* (or on each *chunk_size* group of items) before yielding the item. `func` must be a function that takes a single argument. Its return value will be discarded. *before* and *after* are optional functions that take no arguments. They will be executed before iteration starts and after it ends, respectively. `side_effect` can be used for logging, updating progress bars, or anything that is not functionally "pure." Emitting a status message: >>> from more_itertools import consume >>> func = lambda item: print('Received {}'.format(item)) >>> consume(side_effect(func, range(2))) Received 0 Received 1 Operating on chunks of items: >>> pair_sums = [] >>> func = lambda chunk: pair_sums.append(sum(chunk)) >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2)) [0, 1, 2, 3, 4, 5] >>> list(pair_sums) [1, 5, 9] Writing to a file-like object: >>> from io import StringIO >>> from more_itertools import consume >>> f = StringIO() >>> func = lambda x: print(x, file=f) >>> before = lambda: print(u'HEADER', file=f) >>> after = f.close >>> it = [u'a', u'b', u'c'] >>> consume(side_effect(func, it, before=before, after=after)) >>> f.closed True N)rI)r r chunk_sizebeforeafterrrs rrrsX   FHHH     T   !:66 ! !U            EGGGGG  5  EGGGG s A AA,cttfdtdD|rfd}t|SS)apYield slices of length *n* from the sequence *seq*. >>> list(sliced((1, 2, 3, 4, 5, 6), 3)) [(1, 2, 3), (4, 5, 6)] By the default, the last yielded slice will have fewer than *n* elements if the length of *seq* is not divisible by *n*: >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3)) [(1, 2, 3), (4, 5, 6), (7, 8)] If the length of *seq* is not divisible by *n* and *strict* is ``True``, then ``ValueError`` will be raised before the last slice is yielded. This function will only work for iterables that support slicing. For non-sliceable iterables, see :func:`chunked`. c32K|]}||zVdSrr)r<r$rrMs rrWzsliced..%s/CC!s1q1u9~CCCCCCrrc3bKD](}t|krtd|V)dS)Nzseq is not divisible by n.r)_slicerrs rrzsliced..ret(sK"  v;;!##$%ABBB   r)rrrr)rMrrrrs`` @rrrsu(CCCCCuQ{{CCCDDH        CCEE{{rrc# K|dkrt|VdSg}t|}|D]O}||r-|V|r|gV|dkrt|VdSg}|dz}:||P|VdS)a;Yield lists of items from *iterable*, where each list is delimited by an item where callable *pred* returns ``True``. >>> list(split_at('abcdcba', lambda x: x == 'b')) [['a'], ['c', 'd', 'c'], ['a']] >>> list(split_at(range(10), lambda n: n % 2 == 1)) [[0], [2], [4], [6], [8], []] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_at(range(10), lambda n: n % 2 == 1, maxsplit=2)) [[0], [2], [4, 5, 6, 7, 8, 9]] By default, the delimiting items are not included in the output. To include them, set *keep_separator* to ``True``. >>> list(split_at('abcdcba', lambda x: x == 'b', keep_separator=True)) [['a'], ['b'], ['c', 'd', 'c'], ['b'], ['a']] rNr5rrr)rpredmaxsplitkeep_separatorbufrrs rrr3s.1}}8nn C hB   4:: III f 1}}2hhC MHH JJt     IIIIIrc#K|dkrt|VdSg}t|}|D]M}||r+|r)|V|dkr|gt|zVdSg}|dz}||N|r|VdSdS)a\Yield lists of items from *iterable*, where each list ends just before an item for which callable *pred* returns ``True``: >>> list(split_before('OneTwo', lambda s: s.isupper())) [['O', 'n', 'e'], ['T', 'w', 'o']] >>> list(split_before(range(10), lambda n: n % 3 == 0)) [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_before(range(10), lambda n: n % 3 == 0, maxsplit=2)) [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]] rNr5rrrrrrrs rrr_s 1}}8nn C hB 4:: # III1}}ftBxx''''C MH 4  rc#K|dkrt|VdSg}t|}|D]M}||||r+|r)|V|dkrt|}|r|VdSg}|dz}N|r|VdSdS)a[Yield lists of items from *iterable*, where each list ends with an item where callable *pred* returns ``True``: >>> list(split_after('one1two2', lambda s: s.isdigit())) [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']] >>> list(split_after(range(10), lambda n: n % 3 == 0)) [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_after(range(10), lambda n: n % 3 == 0, maxsplit=2)) [[0], [1, 2, 3], [4, 5, 6, 7, 8, 9]] rNr5rrs rrrs"1}}8nn C hB   4 4:: # III1}}2hhIIIC MH  rc#NK|dkrt|VdSt|} t|}n#t$rYdSwxYw|g}|D]N}|||r)|V|dkr|gt|zVdSg}|dz}|||}O|VdS)aSplit *iterable* into pieces based on the output of *pred*. *pred* should be a function that takes successive pairs of items and returns ``True`` if the iterable should be split in between them. For example, to find runs of increasing numbers, split the iterable when element ``i`` is larger than element ``i + 1``: >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], lambda x, y: x > y)) [[1, 2, 3, 3], [2, 5], [2, 4], [2]] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], ... lambda x, y: x > y, maxsplit=2)) [[1, 2, 3, 3], [2, 5], [2, 4, 2]] rNr5)rrrrr)rrrrcur_itemr next_items rrrs&1}}8nn hB88  *C   4) $ $ III1}} kDHH,,,,C MH 9 IIIIIs< A  A c#Kt|}|D]7}|t|VdStt||V8dS)aYield a list of sequential items from *iterable* of length 'n' for each integer 'n' in *sizes*. >>> list(split_into([1,2,3,4,5,6], [1,2,3])) [[1], [2, 3], [4, 5, 6]] If the sum of *sizes* is smaller than the length of *iterable*, then the remaining items of *iterable* will not be returned. >>> list(split_into([1,2,3,4,5,6], [2,3])) [[1, 2], [3, 4, 5]] If the sum of *sizes* is larger than the length of *iterable*, fewer items will be returned in the iteration that overruns *iterable* and further lists will be empty: >>> list(split_into([1,2,3,4], [1,2,3,4])) [[1], [2, 3], [4], []] When a ``None`` object is encountered in *sizes*, the returned list will contain items up to the end of *iterable* the same way that itertools.slice does: >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None])) [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]] :func:`split_into` can be useful for grouping a series of items where the sizes of the groups are not uniform. An example would be where in a row from a table, multiple columns represent elements of the same feature (e.g. a point represented by x,y,z) but, the format is not the same for all columns. N)rrr)rsizesrr+s rrrsiF hB)) <r((NNN FFvb$''(( ( ( ( ( ))rcttt|Sdkrtd|r#fd}tj|Stt S)aYield the elements from *iterable*, followed by *fillvalue*, such that at least *n* items are emitted. >>> list(padded([1, 2, 3], '?', 5)) [1, 2, 3, '?', '?'] If *next_multiple* is ``True``, *fillvalue* will be emitted until the number of items emitted is a multiple of *n*: >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True)) [1, 2, 3, 4, None, None] If *n* is ``None``, *fillvalue* will be emitted indefinitely. To create an *iterable* of exactly size *n*, you can truncate with :func:`islice`. >>> list(islice(padded([1, 2, 3], '?'), 5)) [1, 2, 3, '?', '?'] >>> list(islice(padded([1, 2, 3, 4, 5, 6, 7, 8], '?'), 5)) [1, 2, 3, 4, 5] Nr5n must be at least 1c3JKD]}|fVtdz VdSNr5r)rariterable_with_repeatrs rslice_generatorzpadded..slice_generator#sI! : :h11q5999999 : :r)rrrrrGr)rrNr next_multiplerrs` ` @rrrs0H~~H 6)+<+<==y## Q/000  @ : : : : : : : "??#4#4555V0!44h???rr'c ltjtt|t|S)zRepeat each element in *iterable* *n* times. >>> list(repeat_each('ABC', 3)) ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C'] )rrGrr)rrs rrr/s'  s68VAYY?? @ @@rc#nKt}|D]}|V|tur|n|}t|Ed{VdS)a"After the *iterable* is exhausted, keep yielding its last element. >>> list(islice(repeat_last(range(3)), 5)) [0, 1, 2, 2, 2] If the iterable is empty, yield *default* forever:: >>> list(islice(repeat_last(range(0), 42), 5)) [42, 42, 42, 42, 42] N)r6r)rrrfinals rrr8s\ D wGGDEe}}rcdkrtdt|}fdt|DS)aDistribute the items from *iterable* among *n* smaller iterables. >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6]) >>> list(group_1) [1, 3, 5] >>> list(group_2) [2, 4, 6] If the length of *iterable* is not evenly divisible by *n*, then the length of the returned iterables will not be identical: >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7]) >>> [list(c) for c in children] [[1, 4, 7], [2, 5], [3, 6]] If the length of *iterable* is smaller than *n*, then the last returned iterables will be empty: >>> children = distribute(5, [1, 2, 3]) >>> [list(c) for c in children] [[1], [2], [3], [], []] This function uses :func:`itertools.tee` and may require significant storage. If you need the order items in the smaller iterables to match the original iterable, see :func:`divide`. r5rc:g|]\}}t||dSrr)r<rrrs rr=zdistribute..ms+ L L L95"F2udA & & L L Lr)rrr})rrchildrens` rrXrXKsN< 1uu/0008QH L L L L (8K8K L L LLrrrr5cXt|t|}t||||dS)a[Yield tuples whose elements are offset from *iterable*. The amount by which the `i`-th item in each tuple is offset is given by the `i`-th item in *offsets*. >>> list(stagger([0, 1, 2, 3])) [(None, 0, 1), (0, 1, 2), (1, 2, 3)] >>> list(stagger(range(8), offsets=(0, 2, 4))) [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)] By default, the sequence will end when the final element of a tuple is the last item in the iterable. To continue until the first element of a tuple is the last item in the iterable, set *longest* to ``True``:: >>> list(stagger([0, 1, 2, 3], longest=True)) [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)] By default, ``None`` will be used to replace offsets beyond the end of the sequence. Specify *fillvalue* to use some other value. )offsetslongestrN)rrr)rrrrNrs rrrps9*8S\\**H  7Gy   rc^tdkrtjdtt |S)a ``zip`` the input *iterables* together, but raise ``UnequalIterablesError`` if they aren't all the same length. >>> it_1 = range(3) >>> it_2 = iter('abc') >>> list(zip_equal(it_1, it_2)) [(0, 'a'), (1, 'b'), (2, 'c')] >>> it_1 = range(3) >>> it_2 = iter('abcd') >>> list(zip_equal(it_1, it_2)) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... more_itertools.more.UnequalIterablesError: Iterables have different lengths i zwzip_equal will be removed in a future version of more-itertools. Use the builtin zip function with strict=True instead.)r2warningswarnDeprecationWarningr7ros rrrs:$Y '      y !!r)rrNc t|t|krtdg}t||D]~\}}|dkr3|t t || |>|dkr%|t ||di|||r t|d|iSt|S)aF``zip`` the input *iterables* together, but offset the `i`-th iterable by the `i`-th item in *offsets*. >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1))) [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')] This can be used as a lightweight alternative to SciPy or pandas to analyze data sets in which some series have a lead or lag relationship. By default, the sequence will end when the shortest iterable is exhausted. To continue until the longest iterable is exhausted, set *longest* to ``True``. >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True)) [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')] By default, ``None`` will be used to replace offsets beyond the end of the sequence. Specify *fillvalue* to use some other value. z,Number of iterables and offsets didn't matchrNrN)rrr rrrrr)rrrNrI staggeredrrs rrrs* 9~~W%%GHHHIY((!!A q55   U6)aR#8#8"== > > > > UU   VB400 1 1 1 1   R <I;;;;  ?rrc  t|}n@t|}t|dkr|dfd}nt|fd}ttt t|||S)aReturn the input iterables sorted together, with *key_list* as the priority for sorting. All iterables are trimmed to the length of the shortest one. This can be used like the sorting function in a spreadsheet. If each iterable represents a column of data, the key list determines which columns are used for sorting. By default, all iterables are sorted using the ``0``-th iterable:: >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')] >>> sort_together(iterables) [(1, 2, 3, 4), ('d', 'c', 'b', 'a')] Set a different key list to sort according to another iterable. Specifying multiple keys dictates how ties are broken:: >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')] >>> sort_together(iterables, key_list=(1, 2)) [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')] To sort by a function of the elements of the iterable, pass a *key* function. Its arguments are the elements of the iterables corresponding to the key list:: >>> names = ('a', 'b', 'c') >>> lengths = (1, 2, 3) >>> widths = (5, 2, 1) >>> def area(length, width): ... return length * width >>> sort_together([names, lengths, widths], key_list=(1, 2), key=area) [('c', 'b', 'a'), (3, 2, 1), (1, 2, 5)] Set *reverse* to ``True`` to sort in descending order. >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True) [(3, 2, 1), ('a', 'b', 'c')] Nr5rc&|Srr) zipped_itemsr` key_offsets rrzsort_together..sL4L0M0Mrc |Srr)r get_key_itemsr`s rrzsort_together.. s|,,1rrw)r+rrr r5)rIkey_listr`rX key_argumentrrs ` @@rrrsP {"8, >> x==A  "!JMMMMMLL'1ML  VCOw G G GH  rctt|\}}|sdS|d}t|t|}dt fdt |DS)aThe inverse of :func:`zip`, this function disaggregates the elements of the zipped *iterable*. The ``i``-th iterable contains the ``i``-th element from each element of the zipped iterable. The first element is used to determine the length of the remaining elements. >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] >>> letters, numbers = unzip(iterable) >>> list(letters) ['a', 'b', 'c', 'd'] >>> list(numbers) [1, 2, 3, 4] This is similar to using ``zip(*iterable)``, but it avoids reading *iterable* into memory. Note, however, that this function uses :func:`itertools.tee` and thus may require significant storage. rrcfd}|S)Nc@ |S#t$rtwxYwr)rr)objr$s rgetterz)unzip..itemgetter..getter1s4 $1v  $ $ $$# $s r)r$rs` rr+zunzip..itemgetter0s# $ $ $ $ $ rc3PK|] \}}t||V!dSrr)r<r$rr+s rrWzunzip..Bs9JJEArZZ]]B''JJJJJJr)rrrrr(r})rr/rIr+s @rrrs(h((ND( r 7DHc$ii((I$ JJJJYy5I5IJJJ J JJrcv|dkrtd |dd|}n#t$rt|}YnwxYwtt ||\}}g}d}t d|dzD]>}|}|||kr|dzn|z }|t|||?|S)a~Divide the elements from *iterable* into *n* parts, maintaining order. >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6]) >>> list(group_1) [1, 2, 3] >>> list(group_2) [4, 5, 6] If the length of *iterable* is not evenly divisible by *n*, then the length of the returned iterables will not be identical: >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7]) >>> [list(c) for c in children] [[1, 2, 3], [4, 5], [6, 7]] If the length of the iterable is smaller than n, then the last returned iterables will be empty: >>> children = divide(5, [1, 2, 3]) >>> [list(c) for c in children] [[1], [2], [3], [], []] This function will exhaust the iterable before returning. If order is not important, see :func:`distribute`, which does not first pull the iterable into memory. r5rNr)rrr(divmodrr#rr) rrrMqr.rrr$rs rrYrYEs: 1uu/000!  Hoo #c((A  DAq C D 1a!e__** aAQ& 4E$J(()))) Js $AAc|tdS| t||rt|fS t|S#t$rt|fcYSwxYw)axIf *obj* is iterable, return an iterator over its items:: >>> obj = (1, 2, 3) >>> list(always_iterable(obj)) [1, 2, 3] If *obj* is not iterable, return a one-item iterable containing *obj*:: >>> obj = 1 >>> list(always_iterable(obj)) [1] If *obj* is ``None``, return an empty iterable: >>> obj = None >>> list(always_iterable(None)) [] By default, binary and text strings are not considered iterable:: >>> obj = 'foo' >>> list(always_iterable(obj)) ['foo'] If *base_type* is set, objects for which ``isinstance(obj, base_type)`` returns ``True`` won't be considered iterable. >>> obj = {'a': 1} >>> list(always_iterable(obj)) # Iterate over the dict's keys ['a'] >>> list(always_iterable(obj, base_type=dict)) # Treat dicts as a unit [{'a': 1}] Set *base_type* to ``None`` to avoid any special handling and treat objects Python considers iterable as iterable: >>> obj = 'foo' >>> list(always_iterable(obj, base_type=None)) ['f', 'o', 'o'] Nr)rrr)rrs rrErExsxR {Bxx:c9#=#=SF||Cyy SF||sAA! A!c |dkrtdt|\}}dg|z}t|t|||}ttt |d|zdz}t ||S)asReturn an iterable over `(bool, item)` tuples where the `item` is drawn from *iterable* and the `bool` indicates whether that item satisfies the *predicate* or is adjacent to an item that does. For example, to find whether items are adjacent to a ``3``:: >>> list(adjacent(lambda x: x == 3, range(6))) [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)] Set *distance* to change what counts as adjacent. For example, to find whether items are two places away from a ``3``: >>> list(adjacent(lambda x: x == 3, range(6), distance=2)) [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)] This is useful for contextualizing the results of a search function. For example, a code comparison tool might want to identify lines that have changed, but also surrounding lines to give the viewer of the diff context. The predicate function will only be called once for each item in the iterable. See also :func:`groupby_transform`, which can be used with this function to group ranges of items with the same `bool` value. rzdistance must be at least 0Fr'r5)rrrranyrr ) predicaterdistancei1i2rPselectedadjacent_to_selecteds rrCrCs:!||6777 ]]FBg GWc)R00'::HsHXq8|a7G$H$HII #R ( ((rcjt||}rfd|D}rfd|D}|S)aAn extension of :func:`itertools.groupby` that can apply transformations to the grouped data. * *keyfunc* is a function computing a key value for each item in *iterable* * *valuefunc* is a function that transforms the individual items from *iterable* after grouping * *reducefunc* is a function that transforms each group of items >>> iterable = 'aAAbBBcCC' >>> keyfunc = lambda k: k.upper() >>> valuefunc = lambda v: v.lower() >>> reducefunc = lambda g: ''.join(g) >>> list(groupby_transform(iterable, keyfunc, valuefunc, reducefunc)) [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')] Each optional argument defaults to an identity function if not specified. :func:`groupby_transform` is useful when grouping elements of an iterable using a separate iterable as the key. To do this, :func:`zip` the iterables and pass a *keyfunc* that extracts the first element and a *valuefunc* that extracts the second element:: >>> from operator import itemgetter >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3] >>> values = 'abcdefghi' >>> iterable = zip(keys, values) >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1)) >>> [(k, ''.join(g)) for k, g in grouper] [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')] Note that the order of items in the iterable is significant. Only adjacent items are grouped together, so if you don't want any duplicate groups, you should sort the iterable by the key function. c3BK|]\}}|t|fVdSrr)r<kg valuefuncs rrWz$groupby_transform..s666$!Q3y!$$%666666rc38K|]\}}||fVdSrr)r<rr reducefuncs rrWz$groupby_transform..s422da::a==!222222rr)rkeyfuncrrrs `` rrcrcs]H (G $ $C76666#66632222c222 JrceZdZdZeeddZdZdZdZ dZ dZ dZ d Z d Zed Zd Zd ZdZdZdZdZdS)ra<An extension of the built-in ``range()`` function whose arguments can be any orderable numeric type. With only *stop* specified, *start* defaults to ``0`` and *step* defaults to ``1``. The output items will match the type of *stop*: >>> list(numeric_range(3.5)) [0.0, 1.0, 2.0, 3.0] With only *start* and *stop* specified, *step* defaults to ``1``. The output items will match the type of *start*: >>> from decimal import Decimal >>> start = Decimal('2.1') >>> stop = Decimal('5.1') >>> list(numeric_range(start, stop)) [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')] With *start*, *stop*, and *step* specified the output items will match the type of ``start + step``: >>> from fractions import Fraction >>> start = Fraction(1, 2) # Start at 1/2 >>> stop = Fraction(5, 2) # End at 5/2 >>> step = Fraction(1, 2) # Count by 1/2 >>> list(numeric_range(start, stop, step)) [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)] If *step* is zero, ``ValueError`` is raised. Negative steps are supported: >>> list(numeric_range(3, -1, -1.0)) [3.0, 2.0, 1.0, 0.0] Be aware of the limitations of floating point numbers; the representation of the yielded numbers may be surprising. ``datetime.datetime`` objects can be used for *start* and *stop*, if *step* is a ``datetime.timedelta`` object: >>> import datetime >>> start = datetime.datetime(2019, 1, 1) >>> stop = datetime.datetime(2019, 1, 3) >>> step = datetime.timedelta(days=1) >>> items = iter(numeric_range(start, stop, step)) >>> next(items) datetime.datetime(2019, 1, 1, 0, 0) >>> next(items) datetime.datetime(2019, 1, 2, 0, 0) rct|}|dkrV|\|_t|jd|_t|j|jz d|_n|dkr:|\|_|_t|j|jz d|_nf|dkr|\|_|_|_nJ|dkr"t d|t d|t|jd|_|j|jkrtd|j|jk|_ dS)Nr5rr'z2numeric_range expected at least 1 argument, got {}z2numeric_range expected at most 3 arguments, got {}z&numeric_range() arg 3 must not be zero) r_stoptype_start_steprr_zeror_growing)rrargcs rrznumeric_range.__init__7sT4yy 199 MTZ*$tz**1--DK7dj4;677::DJJ QYY&* #DK7dj4;677::DJJ QYY26 /DKTZZ QYY%%+VD\\  &&,fTll  &T$*%%a(( : # #EFF F TZ/ rcP|jr|j|jkS|j|jkSr)rrrrs rrznumeric_range.__bool__Rs* = ,;+ +;+ +rc|jr6|j|cxkr |jkrnnR||jz |jz|jkSn6|j|cxkr |jkrnn|j|z |j z|jkSdSNF)rrrrr)relems rrEznumeric_range.__contains__Xs = J{d////TZ/////t{*dj8DJFF0{d////TZ///// d* {;tzIIurct|trtt| }t| }|s|r|o|S|j|jko;|j|jko+|d|dkSdS)NrF)rrboolrr _get_by_index)rother empty_self empty_others r__eq__znumeric_range.__eq__bs e] + + !$ZZJ"5kk/K [ !1k1K5</J ek1J**2..%2E2Eb2I2II 5rct|tr||St|tr|j|jn|j|jz}|j|j|j kr|j}n2|j|jkr|j }n||j}|j |j |jkr|j }n3|j |j kr|j}n||j }t|||Std t|j)Nz8numeric range indices must be integers or slices, not {})rintrrrrr_lenrrrrrrrr)rr`rrrs rrznumeric_range.__getitem__qs0 c3   %%c** * U # # !$!14::sx$*7LDy CI$)$;$; di'' **3955x38ty#8#8zdiZ''{))#(33 d33 3--3VDII4F-G-G rcr|r/t|j|d|jfS|jSNr)hashrrr _EMPTY_HASHrs r__hash__znumeric_range.__hash__s:  $d&8&8&<&.s0BBQ$+TZ0BBBBBBr)rrrr r.rr/)rvaluess` rrznumeric_range.__iter__sbBBBB%''BBB = >WR44f== =WR44f== =rc|jSr)rrs r__len__znumeric_range.__len__s yrc|jr|j}|j}|j}n|j}|j}|j }||z }||jkrdSt ||\}}t |t ||jkzSNr)rrrrrrr)rrrrrrr.s rrznumeric_range._lens = KE:D:DDJE;DJ;D%< tz ! !1(D))DAqq66CTZ000 0rc8t|j|j|jffSr)rrrrrs r __reduce__znumeric_range.__reduce__st{DJ CCCrc&|jdkr:dt|jt|jSdt|jt|jt|jS)Nr5znumeric_range({}, {})znumeric_range({}, {}, {}))rrreprrrrs r__repr__znumeric_range.__repr__s} :??*11T[!!4 #3#3 /55T[!!4 #3#3T$*5E5E rctt|d|j|jz |j Sr)rrrrrrs rrznumeric_range.__reversed__sC ""2&& dj(@4:+     rc$t||vSr)rrks rrznumeric_range.counts5D=!!!rc|jrU|j|cxkr |jkr=nnt||jz |j\}}||jkrt |SnU|j|cxkr |jkr>nn;t|j|z |j \}}||jkrt |Std|)Nz{} is not in numeric range) rrrrrrrrr)rrdrr.s rrznumeric_range.indexs = "{e0000dj00000edk14:>>1 ??q66M{e0000dj00000dkE1DJ;??1 ??q66M5<>>11_1 DDD   """ E E E,,,,,rrctstdS|tnt|}fd|DS)aCycle through the items from *iterable* up to *n* times, yielding the number of completed cycles along with each item. If *n* is omitted the process repeats indefinitely. >>> list(count_cycle('AB', 3)) [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')] rNc3*K|] }D]}||fV dSrr)r<r$rrs rrWzcount_cycle..s4 < >> list(mark_ends('ABC')) [(True, False, 'A'), (False, False, 'B'), (False, True, 'C')] Use this when looping over an iterable to take special action on its first and/or last items: >>> iterable = ['Header', 100, 200, 'Footer'] >>> total = 0 >>> for is_first, is_last, item in mark_ends(iterable): ... if is_first: ... continue # Skip the header ... if is_last: ... continue # Skip the footer ... total += item >>> print(total) 300 NrFT)rrrr)rrbr$as rryrys( hB HH  # #AARAq&%" " " " " # # 1fdAos# 11-A$$A=<A=c|*ttt||S|dkrtdt ||t }ttt ||S)aYield the index of each item in *iterable* for which *pred* returns ``True``. *pred* defaults to :func:`bool`, which will select truthy items: >>> list(locate([0, 1, 1, 0, 1, 0, 0])) [1, 2, 4] Set *pred* to a custom function to, e.g., find the indexes for a particular item. >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b')) [1, 3] If *window_size* is given, then the *pred* function will be called with that many items. This enables searching for sub-sequences: >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3] >>> pred = lambda *args: args == (1, 2, 3) >>> list(locate(iterable, pred=pred, window_size=3)) [1, 5, 9] Use with :func:`seekable` to find indexes and then retrieve the associated items: >>> from itertools import count >>> from more_itertools import seekable >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count()) >>> it = seekable(source) >>> pred = lambda x: x > 100 >>> indexes = locate(it, pred=pred) >>> i = next(indexes) >>> it.seek(i) >>> next(it) 106 Nr5zwindow size must be at least 1rN)rrrrrr6r)rr window_sizers rrrrr ssLT8!4!4555Q9::: (K7 ; ; ;B EGGWT2.. / //rcNdttt|DS)zYield elements of the longest common prefix amongst given *iterables*. >>> ''.join(longest_common_prefix(['abcd', 'abc', 'abf'])) 'ab' c3&K|] }|dV dS)rNr)r<cs rrWz(longest_common_prefix..F s& @ @QAaD @ @ @ @ @ @r)rr?r ros rrsrs? s' A @)IsI?? @ @ @@rc"t||S)aYield the items from *iterable*, but strip any from the beginning for which *pred* returns ``True``. For example, to remove a set of items from the start of an iterable: >>> iterable = (None, False, None, 1, 2, None, 3, False, None) >>> pred = lambda x: x in {None, False, ''} >>> list(lstrip(iterable, pred)) [1, 2, None, 3, False, None] This function is analogous to to :func:`str.lstrip`, and is essentially an wrapper for :func:`itertools.dropwhile`. )rrrs rrtrtI s T8 $ $$rc#Kg}|j}|j}|D]/}||r |||Ed{V||V0dS)aYield the items from *iterable*, but strip any from the end for which *pred* returns ``True``. For example, to remove a set of items from the end of an iterable: >>> iterable = (None, False, None, 1, 2, None, 3, False, None) >>> pred = lambda x: x in {None, False, ''} >>> list(rstrip(iterable, pred)) [None, False, None, 1, 2, None, 3] This function is analogous to :func:`str.rstrip`. N)rclear)rrcache cache_append cache_clearrs rrr[ s Ett|||S)aYield the items from *iterable*, but strip any from the beginning and end for which *pred* returns ``True``. For example, to remove a set of items from both ends of an iterable: >>> iterable = (None, False, None, 1, 2, None, 3, False, None) >>> pred = lambda x: x in {None, False, ''} >>> list(strip(iterable, pred)) [1, 2, None, 3] This function is analogous to :func:`str.strip`. )rrtr s rrru s &4(($ / //rc*eZdZdZdZdZdZdZdS)rmaAn extension of :func:`itertools.islice` that supports negative values for *stop*, *start*, and *step*. >>> iterable = iter('abcdefgh') >>> list(islice_extended(iterable, -4, -1)) ['e', 'f', 'g'] Slices with negative values require some caching of *iterable*, but this function takes care to minimize the amount of memory required. For example, you can use a negative step with an infinite iterator: >>> from itertools import count >>> list(islice_extended(count(), 110, 99, -2)) [110, 108, 106, 104, 102, 100] You can also use slice notation directly: >>> iterable = map(str, count()) >>> it = islice_extended(iterable)[10:20:2] >>> list(it) ['10', '12', '14', '16', '18'] crt|}|rt|t||_dS||_dSr)r_islice_helperr _iterable)rrrrs rrzislice_extended.__init__ s9 (^^  +Bt ==DNNNDNNNrc|Srrrs rrzislice_extended.__iter__ rrc*t|jSr)rr*rs rrzislice_extended.__next__ DN###rct|tr"tt|j|St d)Nz4islice_extended.__getitem__ argument must be a slice)rrrmr)r*r)rr`s rrzislice_extended.__getitem__ s> c5 ! ! H">$.##F#FGG GNOOOrN)rrrrrrrrrrrrmrm s_2   $$$PPPPPrrmc#0K|j}|j}|jdkrtd|jpd}|dkrZ|dn|}|dkrt t |d| }|r|ddnd}t ||zd}||}n*|dkrt||}nt ||zd}||z } | dkrdSt|d| |D] \} } | V dS||dkrtt|||dt t|| | }t |D];\} } | } | |zdkr| V| | >> print(*always_reversible(x for x in range(3))) 2 1 0 If the iterable is already reversible, this function returns the result of :func:`reversed()`. If the iterable is not reversible, this function will cache the remaining items in the iterable and yield them in reverse order, which may require significant storage. )rrrrs rrFrF sJ(!!! (((X'''''(s &::c|Srrr]s rrr& sArc#Ktt|fdD]$\}}ttd|V%dS)aYield groups of consecutive items using :func:`itertools.groupby`. The *ordering* function determines whether two items are adjacent by returning their position. By default, the ordering function is the identity function. This is suitable for finding runs of numbers: >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40] >>> for group in consecutive_groups(iterable): ... print(list(group)) [1] [10, 11, 12] [20] [30, 31, 32, 33] [40] For finding runs of adjacent letters, try using the :meth:`index` method of a string of letters: >>> from string import ascii_lowercase >>> iterable = 'abcdfgilmnop' >>> ordering = ascii_lowercase.index >>> for group in consecutive_groups(iterable, ordering): ... print(list(group)) ['a', 'b', 'c', 'd'] ['f', 'g'] ['i'] ['l', 'm', 'n', 'o', 'p'] Each group of consecutive items is an iterator that shares it source with *iterable*. When an an output group is advanced, the previous group is no longer available unless its elements are copied (e.g., into a ``list``). >>> iterable = [1, 2, 11, 12, 21, 22] >>> saved_groups = [] >>> for group in consecutive_groups(iterable): ... saved_groups.append(list(group)) # Copy group elements >>> saved_groups [[1, 2], [11, 12], [21, 22]] c8|d|dz Srr)rorderings rrz$consecutive_groups..Q s1Q4((1Q4..+@rr`r5N)rr}rr+)rr9rrs ` rrOrO& snT(!@!@!@!@$$1*Q--######$$r)initialct|\}} t|g}n#t$rtgcYSwxYw|g}t |t |||S)aThis function is the inverse of :func:`itertools.accumulate`. By default it will compute the first difference of *iterable* using :func:`operator.sub`: >>> from itertools import accumulate >>> iterable = accumulate([0, 1, 2, 3, 4]) # produces 0, 1, 3, 6, 10 >>> list(difference(iterable)) [0, 1, 2, 3, 4] *func* defaults to :func:`operator.sub`, but other functions can be specified. They will be applied as follows:: A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ... For example, to do progressive division: >>> iterable = [1, 2, 6, 24, 120] >>> func = lambda x, y: x // y >>> list(difference(iterable, func)) [1, 2, 3, 4, 5] If the *initial* keyword is set, the first element will be skipped when computing successive differences. >>> it = [10, 11, 13, 16] # from accumulate([1, 2, 3], initial=10) >>> list(difference(it, initial=10)) [1, 2, 3] )rrrrrr)rr r;rrras rrUrUV sx< x==DAqa  Bxx D!Q ( ((s%AAc*eZdZdZdZdZdZdZdS)rBaSReturn a read-only view of the sequence object *target*. :class:`SequenceView` objects are analogous to Python's built-in "dictionary view" types. They provide a dynamic view of a sequence's items, meaning that when the sequence updates, so does the view. >>> seq = ['0', '1', '2'] >>> view = SequenceView(seq) >>> view SequenceView(['0', '1', '2']) >>> seq.append('3') >>> view SequenceView(['0', '1', '2', '3']) Sequence views support indexing, slicing, and length queries. They act like the underlying sequence, except they don't allow assignment: >>> view[1] '1' >>> view[1:-1] ['1', '2'] >>> len(view) 4 Sequence views are useful as an alternative to copying, as they don't require (much) extra storage. cLt|tst||_dSr)rrr_target)rtargets rrzSequenceView.__init__ s$&(++ O rc|j|Sr)r?)rrs rrzSequenceView.__getitem__ s|E""rc*t|jSr)rr?rs rrzSequenceView.__len__ s4<   rcfd|jjt|jS)Nz{}({}))r __class__rrr?rs rrzSequenceView.__repr__ s%t~6T\8J8JKKKrN)rrrrrrrrrrrrBrB s_: ###!!!LLLLLrrBcHeZdZdZd dZdZdZdZefdZ dZ d Z d Z dS) rap Wrap an iterator to allow for seeking backward and forward. This progressively caches the items in the source iterable so they can be re-visited. Call :meth:`seek` with an index to seek to that position in the source iterable. To "reset" an iterator, seek to ``0``: >>> from itertools import count >>> it = seekable((str(n) for n in count())) >>> next(it), next(it), next(it) ('0', '1', '2') >>> it.seek(0) >>> next(it), next(it), next(it) ('0', '1', '2') >>> next(it) '3' You can also seek forward: >>> it = seekable((str(n) for n in range(20))) >>> it.seek(10) >>> next(it) '10' >>> it.relative_seek(-2) # Seeking relative to the current position >>> next(it) '9' >>> it.seek(20) # Seeking past the end of the source isn't a problem >>> list(it) [] >>> it.seek(0) # Resetting works even after hitting the end >>> next(it), next(it), next(it) ('0', '1', '2') Call :meth:`peek` to look ahead one item without advancing the iterator: >>> it = seekable('1234') >>> it.peek() '1' >>> list(it) ['1', '2', '3', '4'] >>> it.peek(default='empty') 'empty' Before the iterator is at its end, calling :func:`bool` on it will return ``True``. After it will return ``False``: >>> it = seekable('5678') >>> bool(it) True >>> list(it) ['5', '6', '7', '8'] >>> bool(it) False You may view the contents of the cache with the :meth:`elements` method. That returns a :class:`SequenceView`, a view that updates automatically: >>> it = seekable((str(n) for n in range(10))) >>> next(it), next(it), next(it) ('0', '1', '2') >>> elements = it.elements() >>> elements SequenceView(['0', '1', '2']) >>> next(it) '3' >>> elements SequenceView(['0', '1', '2', '3']) By default, the cache grows as the source iterable progresses, so beware of wrapping very large or infinite iterables. Supply *maxlen* to limit the size of the cache (this of course limits how far back you can seek). >>> from itertools import count >>> it = seekable((str(n) for n in count()), maxlen=2) >>> next(it), next(it), next(it), next(it) ('0', '1', '2', '3') >>> list(it.elements()) ['2', '3'] >>> it.seek(0) >>> next(it), next(it), next(it), next(it) ('2', '3', '4', '5') >>> next(it) '6' Nczt||_|g|_ntg||_d|_dSr)r_sourcerr_index)rrrs rrzseekable.__init__ s9H~~ >DKKF++DK rc|Srrrs rrzseekable.__iter__ rrc|j< |j|j}|xjdz c_|S#t$r d|_YnwxYwt|j}|j||Sr)rHrrrrGrrrs rrzseekable.__next__ s ; " {4;/ q   # # #"  # DL!! 4    s-AAcT |n#t$rYdSwxYwdSrrrs rrzseekable.__bool__ rrc t|}n#t$r|tur|cYSwxYw|jt |j|_|xjdzc_|Sr)rrr6rHrr)rrpeekeds rrz seekable.peek& sv $ZZFF   '!!NNN  ; dk**DK q  s ++c*t|jSr)rBrrs relementszseekable.elements2 sDK(((rcr||_|t|jz }|dkrt||dSdSr )rHrrr9)rr remainders rseekz seekable.seek5 sC C ,,, q== D) $ $ $ $ $ =rczt|j}|t||zddSr )rrrSr)rrrs r relative_seekzseekable.relative_seek; s7DK   #eemQ''(((((rr) rrrrrrrrr6rrPrSrUrrrrr sVVp   #    )))%%% )))))rrc>eZdZdZedZedZdS)ra :func:`run_length.encode` compresses an iterable with run-length encoding. It yields groups of repeated items with the count of how many times they were repeated: >>> uncompressed = 'abbcccdddd' >>> list(run_length.encode(uncompressed)) [('a', 1), ('b', 2), ('c', 3), ('d', 4)] :func:`run_length.decode` decompresses an iterable that was previously compressed with run-length encoding. It yields the items of the decompressed iterable: >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] >>> list(run_length.decode(compressed)) ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd'] c4dt|DS)Nc3>K|]\}}|t|fVdSr)rg)r<rrs rrWz$run_length.encode..V s0;;ADGG ;;;;;;rrr5s rencodezrun_length.encodeT s;;):):;;;;rc>tjd|DS)Nc3<K|]\}}t||VdSr)r)r<rrs rrWz$run_length.decode..Z s."E"EDAq6!Q<<"E"E"E"E"E"Er)rrGr5s rdecodezrun_length.decodeX s"""E"EH"E"E"EEEErN)rrrr staticmethodrYr\rrrrr@ sY&<<\<FF\FFFrrc ftt|dzt|||kS)aReturn ``True`` if exactly ``n`` items in the iterable are ``True`` according to the *predicate* function. >>> exactly_n([True, True, False], 2) True >>> exactly_n([True, True, False], 1) False >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3) True The iterable will be advanced until ``n + 1`` truthy items are encountered, so avoid calling it on infinite iterables. r5)rr=rD)rrrs rr^r^] s/ tAE6)X6677 8 8A ==rc t|}tt|tt |t|S)zReturn a list of circular shifts of *iterable*. >>> circular_shifts(range(4)) [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)] )rr=rrr)rlsts rrKrKo s; x..C C(5::s3xx88 9 99rcfd}|S)aReturn a decorator version of *wrapping_func*, which is a function that modifies an iterable. *result_index* is the position in that function's signature where the iterable goes. This lets you use itertools on the "production end," i.e. at function definition. This can augment what the function returns without changing the function's code. For example, to produce a decorator version of :func:`chunked`: >>> from more_itertools import chunked >>> chunker = make_decorator(chunked, result_index=0) >>> @chunker(3) ... def iter_range(n): ... return iter(range(n)) ... >>> list(iter_range(9)) [[0, 1, 2], [3, 4, 5], [6, 7, 8]] To only allow truthy items to be returned: >>> truth_serum = make_decorator(filter, result_index=1) >>> @truth_serum(bool) ... def boolean_test(): ... return [0, 1, '', ' ', False, True] ... >>> list(boolean_test()) [1, ' ', True] The :func:`peekable` and :func:`seekable` wrappers make for practical decorators: >>> from more_itertools import peekable >>> peekable_function = make_decorator(peekable) >>> @peekable_function() ... def str_range(*args): ... return (str(x) for x in range(*args)) ... >>> it = str_range(1, 20, 2) >>> next(it), next(it), next(it) ('1', '3', '5') >>> it.peek() '7' >>> next(it) '7' cfd}|S)Ncfd}|S)Ncn|i|}t}|||iSr)rinsert) rrresultwrapping_args_f result_index wrapping_args wrapping_funcwrapping_kwargss r inner_wrapperzOmake_decorator..decorator..outer_wrapper..inner_wrapper sOD+F++!%m!4!4%%lF;;;$}nHHHHrr)rhrmrirjrkrls` r outer_wrapperz8make_decorator..decorator..outer_wrapper sB I I I I I I I I I ! rr)rjrlrnrirks`` r decoratorz!make_decorator..decorator s5 ! ! ! ! ! ! ! !rr)rkriros`` rruruy s+f       rc |dn|}tt}|D]3}||}||}|||4|(|D]\}}||||<d|_|S)aReturn a dictionary that maps the items in *iterable* to categories defined by *keyfunc*, transforms them with *valuefunc*, and then summarizes them by category with *reducefunc*. *valuefunc* defaults to the identity function if it is unspecified. If *reducefunc* is unspecified, no summarization takes place: >>> keyfunc = lambda x: x.upper() >>> result = map_reduce('abbccc', keyfunc) >>> sorted(result.items()) [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])] Specifying *valuefunc* transforms the categorized items: >>> keyfunc = lambda x: x.upper() >>> valuefunc = lambda x: 1 >>> result = map_reduce('abbccc', keyfunc, valuefunc) >>> sorted(result.items()) [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])] Specifying *reducefunc* summarizes the categorized items: >>> keyfunc = lambda x: x.upper() >>> valuefunc = lambda x: 1 >>> reducefunc = sum >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc) >>> sorted(result.items()) [('A', 1), ('B', 2), ('C', 3)] You may want to filter the input iterable before applying the map/reduce procedure: >>> all_items = range(30) >>> items = [x for x in all_items if 10 <= x <= 20] # Filter >>> keyfunc = lambda x: x % 2 # Evens map to 0; odds to 1 >>> categories = map_reduce(items, keyfunc=keyfunc) >>> sorted(categories.items()) [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])] >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum) >>> sorted(summaries.items()) [(0, 90), (1, 75)] Note that all items in the iterable are gathered into a list before the summarization step, which may require significant storage. The returned object is a :obj:`collections.defaultdict` with the ``default_factory`` set to ``None``, such that it behaves like a normal dictionary. Nc|Srrr]s rrzmap_reduce.. s1r)rrrrdefault_factory) rrrrrrr`rd value_lists rrxrx sf#,"3)I d  Cgdmm $ C"yy{{ . .OC!z*--CHHC Jrc |I t|fdtt||DS#t$rYnwxYwtt t|||S)aYield the index of each item in *iterable* for which *pred* returns ``True``, starting from the right and moving left. *pred* defaults to :func:`bool`, which will select truthy items: >>> list(rlocate([0, 1, 1, 0, 1, 0, 0])) # Truthy at 1, 2, and 4 [4, 2, 1] Set *pred* to a custom function to, e.g., find the indexes for a particular item: >>> iterable = iter('abcb') >>> pred = lambda x: x == 'b' >>> list(rlocate(iterable, pred)) [3, 1] If *window_size* is given, then the *pred* function will be called with that many items. This enables searching for sub-sequences: >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3] >>> pred = lambda *args: args == (1, 2, 3) >>> list(rlocate(iterable, pred=pred, window_size=3)) [9, 5, 1] Beware, this function won't return anything for infinite iterables. If *iterable* is reversible, ``rlocate`` will reverse it and search from the right. Otherwise, it will search from the left and return the results in reverse order. See :func:`locate` to for other example applications. Nc3(K|] }|z dz V dSrUr)r<r$r1s rrWzrlocate.." s,OOHqL1$OOOOOOr)rrrrrr)rrrr1s @rrr sB 8}}HOOOOfXh5G5G.N.NOOO O    D  D$ <<== > >>s7= A  A c#JK|dkrtdt|}t|tg|dz z}t ||}d}|D]K}||r)|||kr!|dz }|Ed{Vt ||dz 0|r|dtur |dVLdS)aYYield the items from *iterable*, replacing the items for which *pred* returns ``True`` with the items from the iterable *substitutes*. >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1] >>> pred = lambda x: x == 0 >>> substitutes = (2, 3) >>> list(replace(iterable, pred, substitutes)) [1, 1, 2, 3, 1, 1, 2, 3, 1, 1] If *count* is given, the number of replacements will be limited: >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0] >>> pred = lambda x: x == 0 >>> substitutes = [None] >>> list(replace(iterable, pred, substitutes, count=2)) [1, 1, None, 1, 1, None, 1, 1, 0] Use *window_size* to control the number of items passed as arguments to *pred*. This allows for locating and replacing subsequences. >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5] >>> window_size = 3 >>> pred = lambda *args: args == (0, 1, 2) # 3 items passed to pred >>> substitutes = [3, 4] # Splice in these items >>> list(replace(iterable, pred, substitutes, window_size=window_size)) [3, 4, 5, 3, 4, 5] r5zwindow_size must be at least 1rN)rr(rr6rr9) rr substitutesrrrwindowsrws rrr) s:Q9::: $$K x'kAo6 7 7Br;''G A  48  1u99Q&&&&&&&&q111  !A$g%%A$JJJ#rc#Kt|t}ttd|D]'}fdt d|z||fzDV(dS)a"Yield all possible order-preserving partitions of *iterable*. >>> iterable = 'abc' >>> for part in partitions(iterable): ... print([''.join(p) for p in part]) ['abc'] ['a', 'bc'] ['ab', 'c'] ['a', 'b', 'c'] This is unrelated to :func:`partition`. r5c*g|]\}}||Srr)r<r$r*sequences rr=zpartitions..w s%AAAAx!}AAArrN)rrr<r#r )rrr$r|s @rrrf sH~~H H A eAqkk " "BBAAAATAXqA4x)@)@AAAAAAABBrc# Kt|}t|}||dkrtd||krdSfd|*td|dzD]}||Ed{VdS||Ed{VdS)a Yield the set partitions of *iterable* into *k* parts. Set partitions are not order-preserving. >>> iterable = 'abc' >>> for part in set_partitions(iterable, 2): ... print([''.join(p) for p in part]) ['a', 'bc'] ['ab', 'c'] ['b', 'ac'] If *k* is not given, every set partition is generated. >>> iterable = 'abc' >>> for part in set_partitions(iterable): ... print([''.join(p) for p in part]) ['abc'] ['a', 'bc'] ['ab', 'c'] ['b', 'ac'] ['a', 'b', 'c'] Nr5z6Can't partition in a negative or zero number of groupsc3XKt|}|dkr|gVdS||krd|DVdS|^}}||dz D] }|gg|V ||D]I}tt|D]*}|d||g||zgz||dzdzV+JdS)Nr5cg|]}|gSrr)r<r0s rr=zAset_partitions..set_partitions_helper.. s"""1A3"""r)rr#)rVrrrMpr$set_partitions_helpers rrz-set_partitions..set_partitions_helper s FF 66#IIIII !VV""""" " " " " "EA**1a!e44  siQi**1a00 < <s1vv<>> from time import sleep >>> def generator(): ... yield 1 ... yield 2 ... sleep(0.2) ... yield 3 >>> iterable = time_limited(0.1, generator()) >>> list(iterable) [1, 2] >>> iterable.timed_out True Note that the time is checked before each item is yielded, and iteration stops if the time elapsed is greater than *limit_seconds*. If your time limit is 1 second, but it takes 2 seconds to generate the first item from the iterable, the function will run for 2 seconds and not yield anything. As a special case, when *limit_seconds* is zero, the iterator never returns anything. c|dkrtd||_t||_t |_d|_dS)Nrzlimit_seconds must be positiveF)r limit_secondsrr*r4 _start_time timed_out)rrrs rrztime_limited.__init__ sH 1  =>> >*h$;;rc|Srrrs rrztime_limited.__iter__ rrc|jdkrd|_tt|j}t |jz |jkrd|_t|S)NrT)rrrrr*r4rrKs rrztime_limited.__next__ sX   " "!DN DN## ;;) )D,> > >!DN  rNrrrrrrrrrrrr sK4     rrct|}t||} t|}d||}|pt|#t$rYnwxYw|S)a*If *iterable* has only one item, return it. If it has zero items, return *default*. If it has more than one item, raise the exception given by *too_long*, which is ``ValueError`` by default. >>> only([], default='missing') 'missing' >>> only([1]) 1 >>> only([1, 2]) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: Expected exactly one item in iterable, but got 1, 2, and perhaps more.' >>> only([1, 2], too_long=TypeError) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... TypeError Note that :func:`only` attempts to advance *iterable* twice to ensure there is only one item. See :func:`spy` or :func:`peekable` to check iterable contents less destructively. r)rrrrr)rrrrrrrs rrr s0 hBr7##K *Bxx  &{L A A )*S//)       sA A$#A$cttt||fd}dfd }||fS)Nc3K rVn& t}|Vn#t$rYdSwxYw@r)rrr)rr#rs r generatorz_ichunk..generator sq  mmoo%%%%;;DJJJJ%FF s3 AAr5c|$tS|tz }|dkr#t|t|tSr )rrrr)rto_cacher#rs rmaterialize_nextz!_ichunk..materialize_next st 9 LL   u:: s5zz> a<< LLx00 1 1 11c%jj!!!rr?)rr)rrrrr#rs @@r_ichunkr sq GGE 8Q  E       " " " " " " " IKK) **rc#Kt|} t||\}}|sdS|V|d/)aBreak *iterable* into sub-iterables with *n* elements each. :func:`ichunked` is like :func:`chunked`, but it yields iterables instead of lists. If the sub-iterables are read in order, the elements of *iterable* won't be stored in memory. If they are read out of order, :func:`itertools.tee` is used to cache elements as necessary. >>> from itertools import count >>> all_chunks = ichunked(count(), 4) >>> c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks) >>> list(c_2) # c_1's elements have been cached; c_3's haven't been [4, 5, 6, 7] >>> list(c_1) [0, 1, 2, 3] >>> list(c_3) [8, 9, 10, 11] TN)rr)rrrrs rrdrd/ sf*H~~H ")(A"6"6 !!  F   rc rtttt|dt iS)aReturn ``True`` if all given *iterables* are equal to each other, which means that they contain the same elements in the same order. The function is useful for comparing iterables of different data types or iterables that do not support equality checks. >>> iequals("abc", ['a', 'b', 'c'], ('a', 'b', 'c'), iter("abc")) True >>> iequals("abc", "acb") False Not to be confused with :func:`all_equal`, which checks whether all elements of iterable are equal to each other. rN)allrr?robjectros rrereS s-" s9k9IIIJJ K KKrc #HK|dkrtd|dkrdVdSt|}tt|t dg}dg|z}d}|r t |d\}}n)#t $r||dz}YAwxYw|||<|dz|krt|VnR|tt||dzd|dzt d|dz }|dSdS)aBYield the distinct combinations of *r* items taken from *iterable*. >>> list(distinct_combinations([0, 0, 1], 2)) [(0, 0), (0, 1)] Equivalent to ``set(combinations(iterable))``, except duplicates are not generated and thrown away. For larger input sequences this is much more efficient. rzr must be non-negativerNr5r:r) rr(r>r}r+rrpopr)rr.rJ generators current_comborcur_idxrs rrVrVg sz 1uu1222 a ??D!)D//z!}}EEEFJFQJM E  jn--JGQQ    NN    QJE H  ! e 19>> && & & & &   d7Q;==17Q;??"1     QJE# s*B#B)(B)c'JK|D]} |||V#|$rYwxYwdS)aYield the items from *iterable* for which the *validator* function does not raise one of the specified *exceptions*. *validator* is called for each item in *iterable*. It should be a function that accepts one argument and raises an exception if that item is not valid. >>> iterable = ['1', '2', 'three', '4', None] >>> list(filter_except(int, iterable, ValueError, TypeError)) ['1', '2', '4'] If an exception other than one given by *exceptions* is raised by *validator*, it is raised like normal. Nr)rar exceptionsrs rr_r_ sb  IdOOOJJJJ    D s   c'FK|D]} ||V#|$rYwxYwdS)aTransform each item from *iterable* with *function* and yield the result, unless *function* raises one of the specified *exceptions*. *function* is called to transform each item in *iterable*. It should accept one argument. >>> iterable = ['1', '2', 'three', '4', None] >>> list(map_except(int, iterable, ValueError, TypeError)) [1, 2, 4] If an exception other than one given by *exceptions* is raised by *function*, it is raised like normal. Nr)functionrrrs rrvrv s] (4..     D s c|Srrr]s rrr sQrc#ZK|D]%}||r ||n ||V&dS)aEvaluate each item from *iterable* using *pred*. If the result is equivalent to ``True``, transform the item with *func* and yield it. Otherwise, transform the item with *func_else* and yield it. *pred*, *func*, and *func_else* should each be functions that accept one argument. By default, *func_else* is the identity function. >>> from math import sqrt >>> iterable = list(range(-5, 5)) >>> iterable [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] >>> list(map_if(iterable, lambda x: x > 3, lambda x: 'toobig')) [-5, -4, -3, -2, -1, 0, 1, 2, 3, 'toobig'] >>> list(map_if(iterable, lambda x: x >= 0, ... lambda x: f'{sqrt(x):.2f}', lambda x: None)) [None, None, None, None, None, '0.00', '1.00', '1.41', '1.73', '2.00'] Nr)rrr  func_elsers rrwrw sQ$<< DJJ;dd4jjjIIdOO;;;;<. s1@@f3vxx==6)@@@@@@rrr5c:g|]}tdSr?)r)r<rQrs rr=z$_sample_weighted.. s& 4 4 4aGI  q ! 4 4 4r) r=r r r#r(rr*r r#) rrweights weight_keyssmallest_weight_keyrQweights_to_skiprr@t_wr_2 weight_keyrs @r_sample_weightedr s: A@@@@KQK2233I I'q\&((mm&99Ow11 & & _ $ $&/q\ " f2233C#q//CSF*J  J#8 9 9 9%.q\ " !&((mm.AAOO v %OO 5 4 4 4588 4 4 44rc|dkrgSt|}|t||St|}t|||S)afReturn a *k*-length list of elements chosen (without replacement) from the *iterable*. Like :func:`random.sample`, but works on iterables of unknown length. >>> iterable = range(100) >>> sample(iterable, 5) # doctest: +SKIP [81, 60, 96, 16, 4] An iterable with *weights* may also be given: >>> iterable = range(100) >>> weights = (i * i + 1 for i in range(100)) >>> sampled = sample(iterable, 5, weights=weights) # doctest: +SKIP [79, 67, 74, 66, 78] The algorithm can also be used to generate weighted random permutations. The relative weight of each item determines the probability that it appears late in the permutation. >>> data = "abcdefgh" >>> weights = range(1, len(data) + 1) >>> sample(data, k=len(data), weights=weights) # doctest: +SKIP ['c', 'a', 'b', 'e', 'g', 'd', 'h', 'f'] r)rrr)rrrs rrrsO2 Avv H~~H!(A...w--!W555rc|r|rtntn|rtnt}||nt ||}t t |t| S)aReturns ``True`` if the items of iterable are in sorted order, and ``False`` otherwise. *key* and *reverse* have the same meaning that they do in the built-in :func:`sorted` function. >>> is_sorted(['1', '2', '3', '4', '5'], key=int) True >>> is_sorted([5, 4, 3, 1, 2], reverse=True) False If *strict*, tests for strict sorting, that is, returns ``False`` if equal elements are found: >>> is_sorted([1, 2, 2]) True >>> is_sorted([1, 2, 2], strict=True) False The function returns ``False`` after encountering the first out-of-order item. If there are no out-of-order items, the iterable is exhausted. )r1r0r/r.rrrr;)rr`rXrcomparers rrlrl2s\,*0LW$rr""G6KbbG[c#x&8&8B77HRLL1122 22rceZdZdS)rAN)rrrrrrrArAMsDrrAcdeZdZdZd dZdZdZdZdZe d Z e d Z d Z d S)rHaConvert a function that uses callbacks to an iterator. Let *func* be a function that takes a `callback` keyword argument. For example: >>> def func(callback=None): ... for i, c in [(1, 'a'), (2, 'b'), (3, 'c')]: ... if callback: ... callback(i, c) ... return 4 Use ``with callback_iter(func)`` to get an iterator over the parameters that are delivered to the callback. >>> with callback_iter(func) as it: ... for args, kwargs in it: ... print(args) (1, 'a') (2, 'b') (3, 'c') The function will be called in a background thread. The ``done`` property indicates whether it has completed execution. >>> it.done True If it completes successfully, its return value will be available in the ``result`` property. >>> it.result 4 Notes: * If the function uses some keyword argument besides ``callback``, supply *callback_kwd*. * If it finished executing, but raised an exception, accessing the ``result`` property will raise the same exception. * If it hasn't finished executing, accessing the ``result`` property from within the ``with`` block will raise ``RuntimeError``. * If it hasn't finished executing, accessing the ``result`` property from outside the ``with`` block will raise a ``more_itertools.AbortThread`` exception. * Provide *wait_seconds* to adjust how frequently the it is polled for output. callback皙?c||_||_d|_d|_||_t djd|_| |_ dS)NFzconcurrent.futuresr5) max_workers) _func _callback_kwd_aborted_future _wait_seconds __import__futuresThreadPoolExecutor _executor_reader _iterator)rr  callback_kwd wait_secondss rrzcallback_iter.__init__sg )  )#   $$$33 rc|Srrrs r __enter__zcallback_iter.__enter__rrcFd|_|jdSr\)rrshutdown)rexc_type exc_value tracebacks r__exit__zcallback_iter.__exit__s#  !!!!!rc|Srrrs rrzcallback_iter.__iter__rrc*t|jSr)rrrs rrzcallback_iter.__next__r-rcF|jdS|jSr)rdoners rrzcallback_iter.dones# < 5|  """rc`|jstd|jS)NzFunction has not yet completed)r RuntimeErrorrrfrs rrfzcallback_iter.results0y A?@@ @|""$$$rc#Ktfd}jjjfij|i_ j}|Vn#t$rYnwxYwj rn`g}  }| |n#t$rYnwxYwP |Ed{VdS)Ncbjrtd||fdS)Nzcanceled by user)rrAput)rrrrs rrz'callback_iter._reader..callbacks8} 6!"4555 EE4. ! ! ! ! !rT)timeout)r'rsubmitrrrgetr task_doner&r get_nowaitrjoin)rrr remainingrs` @rrzcallback_iter._readersw GG " " " " " " -t~, J  -x8     uuT%7u88       |  ""    ' '||~~   &&&&      ' s#A33 B?B"C C-,C-N)rr) rrrrrrrrrpropertyrrfrrrrrHrHQs00d ( ( ( ("""$$$##X# %%X% #####rrHc# K|dkrtdt|}t|}||krtdt||z dzD]-}|d|}||||z}|||zd}|||fV.dS)a Yield ``(beginning, middle, end)`` tuples, where: * Each ``middle`` has *n* items from *iterable* * Each ``beginning`` has the items before the ones in ``middle`` * Each ``end`` has the items after the ones in ``middle`` >>> iterable = range(7) >>> n = 3 >>> for beginning, middle, end in windowed_complete(iterable, n): ... print(beginning, middle, end) () (0, 1, 2) (3, 4, 5, 6) (0,) (1, 2, 3) (4, 5, 6) (0, 1) (2, 3, 4) (5, 6) (0, 1, 2) (3, 4, 5) (6,) (0, 1, 2, 3) (4, 5, 6) () Note that *n* must be at least 0 and most equal to the length of *iterable*. This function will exhaust the iterable and may require significant storage. rrLzn must be <= len(seq)r5N)rr(rr#)rrrMr+r$ beginningmiddleends rrrs0 1uu)*** //C s88D4xx0111 4!8a< %%G QQY!a%''l$$$$$ %%rct}|j}g}|j}|rt||n|D]8} ||vrdS||#t$r||vrYdS||Y5wxYwdS)a Returns ``True`` if all the elements of *iterable* are unique (no two elements are equal). >>> all_unique('ABCB') False If a *key* function is specified, it will be used to make comparisons. >>> all_unique('ABCb') True >>> all_unique('ABCb', str.lower) False The function returns as soon as the first non-unique element is encountered. Iterables with a mix of hashable and unhashable items can be used, but the function will be slower for unhashable items. FT)rHaddrrr)rr`seenset seenset_addseenlist seenlist_addr@s rrDrDs&eeG+KH?L),:3sH%%%("" "'!!uu K  " " "(""uuu L ! ! ! ! ! " 4sA  A  A) A)(A)ctttt|}ttt|}t t |}|dkr||z }d|cxkr|ks ntg}t||D](\}}| |||z||z})tt|S)aEquivalent to ``list(product(*args))[index]``. The products of *args* can be ordered lexicographically. :func:`nth_product` computes the product at sort position *index* without computing the previous products. >>> nth_product(8, range(2), range(2), range(2), range(2)) (1, 0, 0, 0) ``IndexError`` will be raised if the given *index* is invalid. r) rrr(rrr r,rr r)rrpoolsnsrrfrJrs rr}r}s UHTNN++ , ,E c#uoo  BsBA qyy   >>>>>>>> Fub>>a d519o&&& !  &!! " ""rc2t|}t|}|||kr|t|}}n&d|cxkr|ks ntt ||}|dksJ|dkr||z }d|cxkr|ks nt dg|z}||kr|t|z|zn|}t d|dzD]8}t||\}} d||z cxkr|kr nn| |||z <|dkrn9tt|j |S)a'Equivalent to ``list(permutations(iterable, r))[index]``` The subsequences of *iterable* that are of length *r* where order is important can be ordered lexicographically. :func:`nth_permutation` computes the subsequence at sort position *index* directly, without computing the previous subsequences. >>> nth_permutation('ghijk', 2, 5) ('h', 'i') ``ValueError`` will be raised If *r* is negative or greater than the length of *iterable*. ``IndexError`` will be raised if the given *index* is invalid. Nrr5) rrr rr$rr#rr(rr) rr.rrJrrrfrdr$s rr|r|:sP >>D D AyAFF)A,,1 !ZZZZaZZZZ AJJ q5555 qyy   >>>>>>>>S1WF%&UU ! !!A 1a!e__a||1 A>>>>>>>>>F1q5M 66 E  TXv&& ' ''rct|}t|}|dks||krtt||zdz |}|dkr||z }|dks||krtg}d}|rZ|dz}|dkr2t||zdz |}||krn|dz}|dz }||z}|dk2||||Zt|S)agEquivalent to ``list(combinations_with_replacement(iterable, r))[index]``. The subsequences with repetition of *iterable* that are of length *r* can be ordered lexicographically. :func:`nth_combination_with_replacement` computes the subsequence at sort position *index* directly, without computing the previous subsequences with replacement. >>> nth_combination_with_replacement(range(5), 3, 5) (0, 1, 1) ``ValueError`` will be raised If *r* is negative or greater than the length of *iterable*. ``IndexError`` will be raised if the given *index* is invalid. rr5)r(rrrrr) rr.rrJrrrfr$ num_combss rr~r~fs" ??D D A A1q55 QUQYA qyy    uzz F A  Q1ffQUQY**Iy   FA FA Y E 1ff  d1g  ==rc'K|D]@}t|ttfr|V# |Ed{V-#t$r|VY=wxYwdS)aYield all arguments passed to the function in the same order in which they were passed. If an argument itself is iterable then iterate over its values. >>> list(value_chain(1, 2, 3, [4, 5, 6])) [1, 2, 3, 4, 5, 6] Binary and text strings are not considered iterable and are emitted as-is: >>> list(value_chain('12', '34', ['56', '78'])) ['12', '34', '56', '78'] Pre- or postpend a single element to an iterable: >>> list(value_chain(1, [2, 3, 4, 5, 6])) [1, 2, 3, 4, 5, 6] >>> list(value_chain([1, 2, 3, 4, 5], 6)) [1, 2, 3, 4, 5, 6] Multiple levels of nesting are not flattened. N)rrrr)rrds rrrs0 ec5\ * * KKK             KKKKK  s2AAcd}t||tD]]\}}|tus |turtdt|}|t |z||z}^|S)aEquivalent to ``list(product(*args)).index(element)`` The products of *args* can be ordered lexicographically. :func:`product_index` computes the first index of *element* without computing the previous products. >>> product_index([8, 2], range(10), range(5)) 42 ``ValueError`` will be raised if the given *element* isn't in the product of *args*. rrz element is not a product of args)rr6rr(rr)r@rrrrJs rrrs| Ew@@@224 <<47???@@ @T{{D !DJJqMM1 Lrct|}t|d\}}|dSg}t|}|D]9\}}||kr.||t|d\}}|n|}:tdt ||df\}} d} tt |dD]#\} } || z } | | kr| t | | z } $t |dz|dz| z S)aEquivalent to ``list(combinations(iterable, r)).index(element)`` The subsequences of *iterable* that are of length *r* can be ordered lexicographically. :func:`combination_index` computes the index of the first *element*, without computing the previous combinations. >>> combination_index('adf', 'abcdefg') 10 ``ValueError`` will be raised if the given *element* isn't one of the combinations of *iterable*. NNNrz(element is not a combination of iterablerr5)r)r}rrrrqrr) r@rrrindexesrJrrtmprQrr$r*s rrMrMs-  G  & &DAqyqG X  D E E1 66 NN1   '<00FC{CDDD q$i ( ( (DAq E(7++1555  1 E 66 T!QZZ E Aq1u   %%rcht|}t|}t|}t|d\}}|dSg}t|}t|D]B\}}||kr3||t|d\} }| n| }||k3|nCt dt|}dg|z} |D]} | | xxdz cc<d} d} t d|D]<}| | |dz z } ||zdz |z | z }||z }||kr| t||z } =| S)a0Equivalent to ``list(combinations_with_replacement(iterable, r)).index(element)`` The subsequences with repetition of *iterable* that are of length *r* can be ordered lexicographically. :func:`combination_with_replacement_index` computes the index of the first *element*, without computing the previous combinations with replacement. >>> combination_with_replacement_index('adf', 'abcdefg') 20 ``ValueError`` will be raised if the given *element* isn't one of the combinations with replacement of *iterable*. rNrz9element is not a combination with replacement of iterabler5)r(rr}rrrr#r)r@rlrrrrJrrr occupationsrrcumulative_sumr*r$s rrNrNsGnnG G A  G  & &DAqyqG ??D$   11ff NN1   '<00FC{ 1ff 9 E  G    D A#'K A! EN 1a[[  +a!e,, EAIMN * E 66 T!QZZ E Lrcd}t|}ttt|dd|D]%\}}||}||z|z}||=&|S)aEquivalent to ``list(permutations(iterable, r)).index(element)``` The subsequences of *iterable* that are of length *r* where order is important can be ordered lexicographically. :func:`permutation_index` computes the index of the first *element* directly, without computing the previous permutations. >>> permutation_index([1, 3, 2], range(5)) 19 ``ValueError`` will be raised if the given *element* isn't one of the permutations of *iterable*. rr)rr r#rr)r@rrrJr$rr.s rrr3sm E >>DE#d))R,,g661 JJqMM A  GG Lrc$eZdZdZdZdZdZdS)rSaWrap *iterable* and keep a count of how many items have been consumed. The ``items_seen`` attribute starts at ``0`` and increments as the iterable is consumed: >>> iterable = map(str, range(10)) >>> it = countable(iterable) >>> it.items_seen 0 >>> next(it), next(it) ('0', '1') >>> list(it) ['2', '3', '4', '5', '6', '7', '8', '9'] >>> it.items_seen 10 c<t||_d|_dSr )rr items_seenrs rrzcountable.__init__]s>>rc|Srrrs rrzcountable.__iter__arrcNt|j}|xjdz c_|Sr)rrrrKs rrzcountable.__next__ds$DH~~ 1 rNrrrrrSrSKsK"rrSc#\Kt|}|dz |dz z}tt||}tt|j||d|D]}|d|V|d|=|sdSt |}t ||\}}||dkrdndz}t ||\}}||dkrdndz} | dz } || |zz } | | z} | dkr#td| | D]} || | | zV| dkr#t| || D]} || | | zVdSdS)aBreak *iterable* into lists of approximately length *n*. Items are distributed such the lengths of the lists differ by at most 1 item. >>> iterable = [1, 2, 3, 4, 5, 6, 7] >>> n = 3 >>> list(chunked_even(iterable, n)) # List lengths: 3, 2, 2 [[1, 2, 3], [4, 5], [6, 7]] >>> list(chunked(iterable, n)) # List lengths: 3, 3, 1 [[1, 2, 3], [4, 5, 6], [7]] r5r'Nr)rrrrrrrr#)rr min_bufferbufferrQlengthrr. num_lists full_size partial_sizenum_fullpartial_start_idxr$s rrJrJksH~~Ha%AE"J &:.. / /FC x00!T1 = =RaRj 2A2JJ  [[F &!  DAq!a%%QQQ'I &) $ $DAq!a%%QQQ'Iq=L y00H!9,1}}q+Y77 , ,AQ]*+ + + + +a(&,?? / /AQ--. . . . . / /r) scalar_typesrc'Kfd}t|}|sdSdg|z}gg}}t|D]M\}} || r| ||<|t| ||N|st |VdS|rt nt } | |D],} t || D]\}||< t |V-dS)a A version of :func:`zip` that "broadcasts" any scalar (i.e., non-iterable) items into output tuples. >>> iterable_1 = [1, 2, 3] >>> iterable_2 = ['a', 'b', 'c'] >>> scalar = '_' >>> list(zip_broadcast(iterable_1, iterable_2, scalar)) [(1, 'a', '_'), (2, 'b', '_'), (3, 'c', '_')] The *scalar_types* keyword argument determines what types are considered scalar. It is set to ``(str, bytes)`` by default. Set it to ``None`` to treat strings and byte strings as iterable: >>> list(zip_broadcast('abc', 0, 'xyz', scalar_types=None)) [('a', 0, 'x'), ('b', 0, 'y'), ('c', 0, 'z')] If the *strict* keyword argument is ``True``, then ``UnequalIterablesError`` will be raised if any of the iterables have different lengths. crrt|rdS t|dS#t$rYdSwxYw)NTF)rrr)rr s r is_scalarz zip_broadcast..is_scalars\  JsL99 4  III5   44 s ( 66N)rr}rrr(r7r ) r robjectsrr+new_itemrIiterable_positionsr$rzipperrs ` rrrs=, w<> )HQKK   T#YY ' ' '  % %a ( ( ( ( Gnn! *ZZsF "!"4d;;  NAx{ Hoorc#|K|dkrtdt|}tt}|du}|D]y}t ||kr(|d}||dkr||=n||xxdzcc<|r ||n|}||vr|V||xxdz cc<||zdS)aYield the items from *iterable* that haven't been seen recently. *n* is the size of the lookback window. >>> iterable = [0, 1, 0, 2, 3, 0] >>> n = 3 >>> list(unique_in_window(iterable, n)) [0, 1, 2, 3, 0] The *key* function, if provided, will be used to determine uniqueness: >>> list(unique_in_window('abAcda', 3, key=lambda x: x.lower())) ['a', 'b', 'c', 'd', 'a'] The items in *iterable* must be hashable. rzn must be greater than 0rNr5)rrrrrr) rrr`rOrAuse_keyr to_discardrs rrrs" Avv3444 !___F   FoG   v;;!  Jj!Q&&:&&z"""a'""" *CCIIId F??JJJq Q  a  rc#Kt}g}|du}|D]^}|r ||n|} ||vr||n|V1#t$r!||vr||n|VY[wxYwdS)a{Yield duplicate elements after their first appearance. >>> list(duplicates_everseen('mississippi')) ['s', 'i', 's', 's', 'i', 'p', 'i'] >>> list(duplicates_everseen('AaaBbbCccAaa', str.lower)) ['a', 'a', 'b', 'b', 'c', 'c', 'A', 'a', 'a'] This function is analogous to :func:`unique_everseen` and is subject to the same performance considerations. N)rHrrr)rr`seen_set seen_listrr@rs rr[r[suuHIoG  # 0CCLLL    Q     !!  ####    sA  (A54A5cPtdt||DS)a2Yields serially-duplicate elements after their first appearance. >>> list(duplicates_justseen('mississippi')) ['s', 's', 'p'] >>> list(duplicates_justseen('AaaBbbCccAaa', str.lower)) ['a', 'a', 'b', 'b', 'c', 'c', 'a', 'a'] This function is analogous to :func:`unique_justseen`. c3*K|]\}}|D]}|VdSrr)r<rQrs rrWz&duplicates_justseen..%s3CCACCA1CCCCCCCr)r:r)rr`s rr\r\s+ CC3!7!7CCC C CCrc#6Kt}g}|du}d}t|D]p\}}|r ||n|}| p||k} |}d} ||vr||d} n+#t$r||vr||d} YnwxYw|| | fVqdS)aClassify each element in terms of its uniqueness. For each element in the input iterable, return a 3-tuple consisting of: 1. The element itself 2. ``False`` if the element is equal to the one preceding it in the input, ``True`` otherwise (i.e. the equivalent of :func:`unique_justseen`) 3. ``False`` if this element has been seen anywhere in the input before, ``True`` otherwise (i.e. the equivalent of :func:`unique_everseen`) >>> list(classify_unique('otto')) # doctest: +NORMALIZE_WHITESPACE [('o', True, True), ('t', True, True), ('t', False, False), ('o', True, False)] This function is analogous to :func:`unique_everseen` and is subject to the same performance considerations. NFT)rHr}rrr) rr`rrrpreviousr$r@ris_unique_justseenis_unique_everseens rr]r](s*uuHIoGH)) > > 7# 0CCLLL!"U3h!m" *   Q%)" * * * !!  ###%)" *)+====== > >s A&&%B B)r`rc|r|g|Rn|}t|} t|x}}n2#t$r%}|turt d||cYd}~Sd}~wwxYw|3t |||D]\} } | | kr| | } } | |kr| }|| kr| } n`||x} } t |||D]@\} } || || }} || kr | | || f\} } } }| | kr| | } }| |kr| |} }A||fS)aReturns both the smallest and largest items in an iterable or the largest of two or more arguments. >>> minmax([3, 1, 5]) (1, 5) >>> minmax(4, 2, 6) (2, 6) If a *key* function is provided, it will be used to transform the input items for comparison. >>> minmax([5, 30], key=str) # '30' sorts before '5' (30, 5) If a *default* value is provided, it will be returned if there are no input items. >>> minmax([], default=(0, 0)) (0, 0) Otherwise ``ValueError`` is raised. This function is based on the `recipe `__ by Raymond Hettinger and takes care to minimize the number of comparisons performed. z[`minmax()` argument is an empty iterable. Provide a `default` value to suppress this error.Nr)rrrr6rr)iterable_or_valuer`rothersrrlohirrrlo_keyhi_keyx_keyy_keys rrzrzRs:06L!+F+++;LH hBr((RR  g  D   {B"555  DAq1uu!12vvAvv  #b''!B"555 & &DAq3q6633q665Eu}}%&5%%7"1eUv~~F~~F r6Ms- AAAATc#rK|dkrtdg}d}d}|D]}||} |r| |krtd||k} | |z|k} |r-| s| r)t|V|d}d}|||| z }|dz }|rt|VdSdS)aBYield batches of items from *iterable* with a combined size limited by *max_size*. >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1'] >>> list(constrained_batches(iterable, 10)) [(b'12345', b'123'), (b'12345678', b'1', b'1'), (b'12', b'1')] If a *max_count* is supplied, the number of items per batch is also limited: >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1'] >>> list(constrained_batches(iterable, 10, max_count = 2)) [(b'12345', b'123'), (b'12345678', b'1'), (b'1', b'12'), (b'1',)] If a *get_len* function is supplied, use that instead of :func:`len` to determine item size. If *strict* is ``True``, raise ``ValueError`` if any single item is bigger than *max_size*. Otherwise, allow single items to exceed *max_size*. rz&maximum size must be greater than zerozitem size exceeds maximum sizer5N)rr(r"r) rmax_size max_countget_lenrbatch batch_size batch_countritem_len reached_count reached_sizes rrPrPs.1}}ABBB EJK74==  ?h))=>> >#y0 *,x7  L M ,,    KKMMMJK Th q  Ellrc'PKtd|Dt}D]$}t|dkrtd%dg|ztt |dz}dg|z} tfdt |DV|d}d|d<||krdS|||z|<|dks"|t|dz kr%|| ||<||dz||<|dz||dz<) afLike :func:`itertools.product`, but return tuples in an order such that only one element in the generated tuple changes from one iteration to the next. >>> list(gray_product('AB','CD')) [('A', 'C'), ('B', 'C'), ('B', 'D'), ('A', 'D')] This function consumes all of the input iterables before producing output. If any of the input iterables have fewer than two items, ``ValueError`` is raised. For information on the algorithm, see `this section `__ of Donald Knuth's *The Art of Computer Programming*. c34K|]}t|VdSr)r(rrs rrWzgray_product..s(66q%((666666rr'z)each iterable must have two or more itemsrr5Tc3@K|]}||VdSrr)r<r$r all_iterabless rrWzgray_product..s1JJqM!$QqT*JJJJJJrN)r(rrrr#)rIiterable_countrrhor*rr7s @@rrbrbsp 66I66666M''N!JJ x==1  HII I  nA U>A% & &''A nA JJJJJE.4I4IJJJJJJJJ aD!    Etad{! Q4199!M!$4 5 5 999aD5AaDQU8AaD1uAa!eH rc' Kttt|} d|D}n#t$rYdSwxYwt |Vt |D]\}}|D]||<t |VdS)aYields tuples containing one item from each iterator, with subsequent tuples changing a single item at a time by advancing each iterator until it is exhausted. This sequence guarantees every value in each iterable is output at least once without generating all possible combinations. This may be useful, for example, when testing an expensive function. >>> list(partial_product('AB', 'C', 'DEF')) [('A', 'C', 'D'), ('B', 'C', 'D'), ('B', 'C', 'E'), ('B', 'C', 'F')] c,g|]}t|Srrr;s rr=z#partial_product..s---RR---rN)rrrrr(r})rI iteratorsprodr$rs rrrsSy))**I--9---  ++9%%2  DG++     s 3 AAc#8K|D]}|V||sdSdS)zA variant of :func:`takewhile` that yields one additional element. >>> list(takewhile_inclusive(lambda x: x < 5, [1, 4, 6, 4, 1])) [1, 4, 6] :func:`takewhile` would return ``[1, 4]``. Nr)rrrs rrrsFy||  EE rc t|}ttfdt||t |S)aA generalized outer product that applies a binary function to all pairs of items. Returns a 2D matrix with ``len(xs)`` rows and ``len(ys)`` columns. Also accepts ``*args`` and ``**kwargs`` that are passed to ``func``. Multiplication table: >>> list(outer_product(mul, range(1, 4), range(1, 6))) [(1, 2, 3, 4, 5), (2, 4, 6, 8, 10), (3, 6, 9, 12, 15)] Cross tabulation: >>> xs = ['A', 'B', 'A', 'A', 'B', 'B', 'A', 'A', 'B', 'B'] >>> ys = ['X', 'X', 'X', 'Y', 'Z', 'Z', 'Y', 'Y', 'Z', 'Z'] >>> rows = list(zip(xs, ys)) >>> count_rows = lambda x, y: rows.count((x, y)) >>> list(outer_product(count_rows, sorted(set(xs)), sorted(set(ys)))) [(2, 3, 0), (1, 0, 4)] Usage with ``*args`` and ``**kwargs``: >>> animals = ['cat', 'wolf', 'mouse'] >>> list(outer_product(min, animals, animals, key=len)) [('cat', 'cat', 'cat'), ('cat', 'wolf', 'wolf'), ('cat', 'wolf', 'mouse')] c||gRiSrr)rrrr rs rrzouter_product..8s#TT!Q888888r)r)r(r@rrr)r xsysrrs` ``rrrsW4 rB 888888'"b//JJ b''   rc'4K |Ed{VdS#|$rYdSwxYw)a.Yield each of the items from *iterable*. If the iteration raises one of the specified *exceptions*, that exception will be suppressed and iteration will stop. >>> from itertools import chain >>> def breaks_at_five(x): ... while True: ... if x >= 5: ... raise RuntimeError ... yield x ... x += 1 >>> it_1 = iter_suppress(breaks_at_five(1), RuntimeError) >>> it_2 = iter_suppress(breaks_at_five(2), RuntimeError) >>> list(chain(it_1, it_2)) [1, 2, 3, 4, 2, 3, 4] Nr)rrs rroro=sK" s c#6K|D]}||}||VdS)zApply *func* to every element of *iterable*, yielding only those which are not ``None``. >>> elems = ['1', 'a', '2', 'b', '3'] >>> list(filter_map(lambda s: int(s) if s.isnumeric() else None, elems)) [1, 2, 3] Nr)r rrrs rr`r`Ts= DGG =GGGrc #lKtttttt t |}tt|dzD]7}ttj t||Ed{V8dS)axYields all possible subsets of the iterable. >>> list(powerset_of_sets([1, 2, 3])) # doctest: +SKIP [set(), {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}] >>> list(powerset_of_sets([1, 1, 0])) # doctest: +SKIP [set(), {1}, {0}, {0, 1}] :func:`powerset_of_sets` takes care to minimize the number of hash operations performed. r5N) r(rrHdictfromkeys frozensetr r#rrunionr)rsetsr.s rrrbs S$--Is8}}(E(EFFGG H HD 3t99q= ! !??355; T1(=(=>>>>>>>>>>??rc tt}|D]*\}}|D]\}}||||<+t|S)a2 Joins multiple mappings together using their common keys. >>> user_scores = {'elliot': 50, 'claris': 60} >>> user_times = {'elliot': 30, 'claris': 40} >>> join_mappings(score=user_scores, time=user_times) {'elliot': {'score': 50, 'time': 30}, 'claris': {'score': 60, 'time': 40}} )rrFr) field_to_mapr field_namemappingr`rds rrprprsp d  C+1133)) G!--// ) )JC#(CHZ  ) 99rcztd|Dd|D}td|Dd|D}td|Dd|D}td|Dd|D}tt||t||S) z\High precision sumprod() for complex numbers. Used by :func:`dft` and :func:`idft`. c3$K|] }|jV dSrrealr<rs rrWz#_complex_sumprod..$##1######rc3&K|] }|j V dSrimagrSs rrWz#_complex_sumprod..s&%:%:!qvg%:%:%:%:%:%:rc3$K|] }|jV dSrrQr<rs rrWz#_complex_sumprod..rTrc3$K|] }|jV dSrrVrYs rrWz#_complex_sumprod..$%9%9af%9%9%9%9%9%9rc3$K|] }|jV dSrrQrSs rrWz#_complex_sumprod..rTrc3$K|] }|jV dSrrVrSs rrWz#_complex_sumprod..r[rc3$K|] }|jV dSrrVrYs rrWz#_complex_sumprod..rTrc3$K|] }|jV dSrrQrYs rrWz#_complex_sumprod..r[r)rcomplex _fsumprod)v1v2r1r2rrs r_complex_sumprodrfs #####%:%:r%:%:%: ; ;B #####%9%9b%9%9%9 : :B #####%9%9b%9%9%9 : :B #####%9%9b%9%9%9 : :B 9R$$iB&7&7 8 88rc#Kt|fdtDtD]1fdtD}t||V2dS)anDiscrete Fourier Tranform. *xarr* is a sequence of complex numbers. Yields the components of the corresponding transformed output vector. >>> import cmath >>> xarr = [1, 2-1j, -1j, -1+2j] >>> Xarr = [2, -2-2j, -2j, 4+4j] >>> all(map(cmath.isclose, dft(xarr), Xarr)) True See :func:`idft` for the inverse Discrete Fourier Transform. c@g|]}t|z tzdzzS)yrr%r<rNs rr=zdft..s+AAA1aAECK#-.AAArc,g|]}|zzSrrr<rrkrroots_of_unitys rr=zdft..&>>>.Q+>>>rNrr#rf)xarrcoeffsrkrrns @@@rrTrTs D AAAAAaAAAN 1XX-->>>>>>U1XX>>>tV,,,,,,--rc#Kt|fdtDtD]4fdtD}t||z V5dS)azInverse Discrete Fourier Tranform. *Xarr* is a sequence of complex numbers. Yields the components of the corresponding inverse-transformed output vector. >>> import cmath >>> xarr = [1, 2-1j, -1j, -1+2j] >>> Xarr = [2, -2-2j, -2j, 4+4j] >>> all(map(cmath.isclose, idft(Xarr), xarr)) True See :func:`dft` for the Discrete Fourier Transform. c@g|]}t|z tzdzzS)y?rirjs rr=zidft..s+@@@!aAECK",-@@@rc,g|]}|zzSrrrms rr=zidft..rorNrp)Xarrrrrkrrns @@@rrfrfs D A@@@@uQxx@@@N 1XX11>>>>>>U1XX>>>tV,,q0000011rc#(K|D] }|di|V dS)aApply *func* to every item of *iterable* by dictionary unpacking the item into *func*. The difference between :func:`itertools.starmap` and :func:`doublestarmap` parallels the distinction between ``func(*a)`` and ``func(**a)``. >>> iterable = [{'a': 1, 'b': 2}, {'a': 40, 'b': 60}] >>> list(doublestarmap(lambda a, b: a + b, iterable)) [3, 100] ``TypeError`` will be raised if *func*'s signature doesn't match the mapping contained in *iterable* or if *iterable* does not contain mappings. Nrr)r rrs rrZrZs<dllTllr)Frrr?r)NNN)rF)r)NNF)r')rFN)rNF)NFF)mathr collectionsrrrrcollections.abcr functoolsrr r r heapqr r r itertoolsrrrrrrrrrrrrrrrrrr r!r"r#r$r%queuer&r'r(r)r*operatorr+r,r-r.r/r0r1sysr2r3timer4recipesr6r7r8r9r:r;r<r=r>r?r@__all__getattrrarIrarqr{rrQrgrnrrrrrWrkrrrrrGrrhrjrirLrrrrrrrrrrrXrrrrrrYrrrErCrcHashablerrRryrrrrsrtrrrmr)rFrOrUrBrrr^rKrurxrrrrrrrrdrerVr_rvrwrrrrl BaseExceptionrArHrrDr}r|r~rrrMrNrrSrJrrr[r\r]rzrrPrbrrrror`rrprfrTrfrZrrrrs  888888888888$$$$$$============////////// FEEEEEEEEEEEEEEEEEEEEE----------999999999999999999########                          o o o d GD)%F%F G G     F$6#:&-::::"b"b"b"b"b"b"b"b"J@"      @@@@FJJJJZb$b$b$b$JDDDD4CCCB7777t!!!4D]']']']']']']']'@((((((((V 0 0 0 . . . ?+?+?+?+D9999x::::zD))))X    F####L****Z*)*)*)Z*@*@*@*@ZAAAA&"M"M"MJ8""">-2T$$$$$N????D.K.K.Kb000f%(<2222j$)$)$)$)N****ZV,V,V,V,V,CL#,V,V,V,r = = = = """JD-0-0-0-0`AAA%%%$4000"+P+P+P+P+P+P+P+P\]&]&]&@((($+6+-$-$-$-$`"')d')')')')')T*L*L*L*L*L8*L*L*LZP)P)P)P)P)P)P)P)fFFFFFFFF:&*>>>>$:::????D@@@@F T(?(?(?(?V::::zBBB(5/5/5/5/p////////d&&&&R+++D!!!HLLL(%%%P0*,7;<<<<,2 5 5 5F!6!6!6!6H33336     -   ||||||||~%%%%%%P    F###>)()()(X+++\D2(&(&(&V666r0@//////d+.ue55555p$$$$N< D D D D'>'>'>'>T,0DDDDDP#'D////d'''T2   B.    ? ? ? $ 9 9 9---&111(r