OwlCyberSecurity - MANAGER
Edit File: recipes.cpython-313.pyc
� a0biHc � �N � S r SSKrSSKrSSKrSSKJr SSKJr SSKJ r SSK J r J r J r JrJrJrJrJrJrJrJrJr SSKJrJrJr SSKJ r / S Qr \ " 5 r S r S9S jr!S r"S:S jr#S:S jr$S r%\&4S jr'S r(\(r)S r*S r+S r,S:S jr-S r. SSK J/r0 S r/\.R \/l " S S\25 r3S r4S r5S;S jr6S r7S r8S r9S:S! jr:S:S" jr;S:S# jr<S<S$ jr=S%S&.S' jr>S:S( jr?S) r@S* rAS+ rBS, rCS- rDS. rES/ rFS0 rGS1 rHS2 rIS9S3 jrJS4 rKS5 rLS6 rMS7 rNS8 rOg! \1 a \.r/ N|f = f)=a Imported from the recipes section of the itertools documentation. All functions taken from the recipes section of the itertools library docs [1]_. Some backward-compatible usability improvements have been made. .. [1] http://docs.python.org/library/itertools.html#recipes � N)�deque)�Sized)�reduce) �chain� combinations�compress�count�cycle�groupby�islice�product�repeat�starmap�tee� zip_longest)� randrange�sample�choice)� hexversion)(� all_equal�batched�before_and_after�consume�convolve� dotproduct� first_true�factor�flatten�grouper� iter_except� iter_index�matmul�ncycles�nth�nth_combination�padnone�pad_none�pairwise� partition�polynomial_from_roots�powerset�prepend�quantify�#random_combination_with_replacement�random_combination�random_permutation�random_product� repeatfunc� roundrobin�sieve�sliding_window� subslices�tabulate�tail�take� transpose� triplewise�unique_everseen�unique_justseenc �* � [ [ X5 5 $ )z�Return first *n* items of the iterable as a list. >>> take(3, range(10)) [0, 1, 2] If there are fewer than *n* items in the iterable, all of them are returned. >>> take(10, range(3)) [0, 1, 2] )�listr ��n�iterables ڥ/builddir/build/BUILDROOT/alt-python313-setuptools-69.0.2-3.el8.x86_64/opt/alt/python313/lib/python3.13/site-packages/pkg_resources/_vendor/more_itertools/recipes.pyr9 r9 P s � � ��x�#� $�$� c �, � [ U [ U5 5 $ )a� Return an iterator over the results of ``func(start)``, ``func(start + 1)``, ``func(start + 2)``... *func* should be a function that accepts one integer argument. If *start* is not specified it defaults to 0. It will be incremented each time the iterator is advanced. >>> square = lambda x: x ** 2 >>> iterator = tabulate(square, -3) >>> take(4, iterator) [9, 4, 1, 0] )�mapr )�function�starts rC r7 r7 ` s � � �x��u� � &�&rD c # �� # � [ U[ 5 ( a, [ U[ S[ U5 U - 5 S5 Sh v�N g[ [ XS95 Sh v�N g N N7f)zsReturn an iterator over the last *n* items of *iterable*. >>> t = tail(3, 'ABCDEFG') >>> list(t) ['E', 'F', 'G'] r N��maxlen)� isinstancer r �max�len�iterr r@ s rC r8 r8 r sR � � � �(�E�"�"��(�C��3�x�=�1�+<�$=�t�D�D�D���h�1�2�2�2� E�2�s! �<A#�A �A#�A!�A#�!A#c �L � Uc [ U SS9 g[ [ XU5 S5 g)a� Advance *iterable* by *n* steps. If *n* is ``None``, consume it entirely. Efficiently exhausts an iterator without returning values. Defaults to consuming the whole iterator, but an optional second argument may be provided to limit consumption. >>> i = (x for x in range(10)) >>> next(i) 0 >>> consume(i, 3) >>> next(i) 4 >>> consume(i) >>> next(i) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration If the iterator has fewer items remaining than the provided limit, the whole iterator will be consumed. >>> i = (x for x in range(3)) >>> consume(i, 5) >>> next(i) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration Nr rJ )r �nextr )�iteratorrA s rC r r � s' � �@ �y� �h�q�!� �V�H�� #�T�*rD c �. � [ [ XS5 U5 $ )zmReturns the nth item or a default value. >>> l = range(10) >>> nth(l, 3) 3 >>> nth(l, 20, "zebra") 'zebra' N)rQ r )rB rA �defaults rC r$ r$ � s � � ��x�D�)�7� 3�3rD c �` � [ U 5 n[ US5 =( a [ US5 ( + $ )z� Returns ``True`` if all the elements are equal to each other. >>> all_equal('aaaa') True >>> all_equal('aaab') False TF)r rQ )rB �gs rC r r � s( � � ���A� ��4�=� /��a�� � /�/rD c �* � [ [ X5 5 $ )zWReturn the how many times the predicate is true. >>> quantify([True, False, True]) 2 )�sumrF )rB �preds rC r- r- � s � � �s�4�"� #�#rD c �, � [ U [ S5 5 $ )z�Returns the sequence of elements and then returns ``None`` indefinitely. >>> take(5, pad_none(range(3))) [0, 1, 2, None, None] Useful for emulating the behavior of the built-in :func:`map` function. See also :func:`padded`. N)r r �rB s rC r' r' � s � � ��6�$�<� (�(rD c �T � [ R " [ [ U 5 U5 5 $ )zjReturns the sequence elements *n* times >>> list(ncycles(["a", "b"], 3)) ['a', 'b', 'a', 'b', 'a', 'b'] )r � from_iterabler �tuple)rB rA s rC r# r# � s � � � � �v�e�H�o�q� 9� :�:rD c �H � [ [ [ R X5 5 $ )zWReturns the dot product of the two iterables. >>> dotproduct([10, 10], [20, 20]) 400 )rX rF �operator�mul)�vec1�vec2s rC r r � s � � �s�8�<�<��,� -�-rD c �. � [ R " U 5 $ )z�Return an iterator flattening one level of nesting in a list of lists. >>> list(flatten([[0, 1], [2, 3]])) [0, 1, 2, 3] See also :func:`collapse`, which can flatten multiple levels of nesting. )r r] )� listOfListss rC r r � s � � � � �{� +�+rD c �\ � Uc [ U [ U5 5 $ [ U [ X!5 5 $ )a Call *func* with *args* repeatedly, returning an iterable over the results. If *times* is specified, the iterable will terminate after that many repetitions: >>> from operator import add >>> times = 4 >>> args = 3, 5 >>> list(repeatfunc(add, times, *args)) [8, 8, 8, 8] If *times* is ``None`` the iterable will not terminate: >>> from random import randrange >>> times = None >>> args = 1, 11 >>> take(6, repeatfunc(randrange, times, *args)) # doctest:+SKIP [2, 4, 8, 1, 8, 4] )r r )�func�times�argss rC r2 r2 s, � �, �}��t�V�D�\�*�*� �4���,� -�-rD c # �h # � [ U 5 u p[ US5 [ X5 Sh v�N g N7f)z�Returns an iterator of paired items, overlapping, from the original >>> take(4, pairwise(count())) [(0, 1), (1, 2), (2, 3), (3, 4)] On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`. N)r rQ �zip)rB �a�bs rC � _pairwisern s( � � � �x�=�D�A���D�M��1�y���s �(2�0�2�r( c # �6 # � [ U 5 S h v�N g N7f�N)�itertools_pairwiser[ s rC r( r( 1 s � � �%�h�/�/�/�s ���c �, ^ � \ rS rSrSU 4S jjrSrU =r$ )�UnequalIterablesErrori7 c �R >� SnUb USR " U6 - n[ TU ] U5 g )Nz Iterables have different lengthsz/: index 0 has length {}; index {} has length {})�format�super�__init__)�self�details�msg� __class__s �rC rx � UnequalIterablesError.__init__8 s8 �� �0�� � � �E�M�M��� �C� ���� rD � rq )�__name__� __module__� __qualname__�__firstlineno__rx �__static_attributes__� __classcell__)r| s @rC rt rt 7 s �� � � rD rt c # �x # � [ U S[ 06 H# nU H nU[ L d M [ 5 e Uv � M% g 7f)N� fillvalue)r �_markerrt )� iterables�combo�vals rC �_zip_equal_generatorr� B s: � � � �i�;�7�;���C��g�~�+�-�-� � � � <�s � :�:c �� � [ U S 5 n[ U SS S5 H u p#[ U5 nXA:w d M O [ U 6 $ [ XU4S9e! [ a [ U 5 s $ f = f)Nr � )rz )rN � enumeraterk rt � TypeErrorr� )r� � first_size�i�it�sizes rC � _zip_equalr� J sz � �/���1� �&� � �y���}�a�0�E�A��r�7�D��!�� 1� � �?� "� $�Z�D�,A�B�B�� � /�#�I�.�.�/�s �0A � A � A � A%�$A%c � � [ U 5 /U- nUS:X a [ USU06$ US:X a [ U6 $ US:X a [ U6 $ [ S5 e)au Group elements from *iterable* into fixed-length groups of length *n*. >>> list(grouper('ABCDEF', 3)) [('A', 'B', 'C'), ('D', 'E', 'F')] The keyword arguments *incomplete* and *fillvalue* control what happens for iterables whose length is not a multiple of *n*. When *incomplete* is `'fill'`, the last group will contain instances of *fillvalue*. >>> list(grouper('ABCDEFG', 3, incomplete='fill', fillvalue='x')) [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')] When *incomplete* is `'ignore'`, the last group will not be emitted. >>> list(grouper('ABCDEFG', 3, incomplete='ignore', fillvalue='x')) [('A', 'B', 'C'), ('D', 'E', 'F')] When *incomplete* is `'strict'`, a subclass of `ValueError` will be raised. >>> it = grouper('ABCDEFG', 3, incomplete='strict') >>> list(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... UnequalIterablesError �fillr� �strict�ignorez Expected fill, strict, or ignore)rO r r� rk � ValueError)rB rA � incompleter� ri s rC r r ^ s^ � �: ��N� �a� �D��V���D�6�I�6�6��X� ��4� � ��X� ��D�z���;�<�<rD c ' �� # � [ U 5 n[ S U 5 5 nU( a U H nU" 5 v � M U( a M gg! [ a US- n[ [ X!5 5 n N0f = f7f)a2 Yields an item from each iterable, alternating between them. >>> list(roundrobin('ABC', 'D', 'EF')) ['A', 'D', 'E', 'B', 'F', 'C'] This function produces the same output as :func:`interleave_longest`, but may perform better for some inputs (in particular when the number of iterables is small). c 3 �L # � U H n[ U5 R v � M g 7frq )rO �__next__)�.0r� s rC � <genexpr>� roundrobin.<locals>.<genexpr>� s � � �8�i��$�r�(�#�#�i�s �"$r� N)rN r � StopIterationr )r� �pending�nextsrQ s rC r3 r3 � sh � � � �)�n�G� �8�i�8� 8�E� � 2� ���f� � � �'�� � 2� �q�L�G��&��0�1�E� 2�s- �%A.�A �A.�A.�#A+�(A.�*A+�+A.c �l ^ � T c [ m U 4S jU 5 n[ U5 u p4S U 5 S U 5 4$ )aw Returns a 2-tuple of iterables derived from the input iterable. The first yields the items that have ``pred(item) == False``. The second yields the items that have ``pred(item) == True``. >>> is_odd = lambda x: x % 2 != 0 >>> iterable = range(10) >>> even_items, odd_items = partition(is_odd, iterable) >>> list(even_items), list(odd_items) ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9]) If *pred* is None, :func:`bool` is used. >>> iterable = [0, 1, False, True, '', ' '] >>> false_items, true_items = partition(None, iterable) >>> list(false_items), list(true_items) ([0, False, ''], [1, True, ' ']) c 3 �8 ># � U H nT" U5 U4v � M g 7frq r~ )r� �xrY s �rC r� � partition.<locals>.<genexpr>� s �� � �2��A�D��G�Q�<��s �c 3 �< # � U H u pU( a M Uv � M g 7frq r~ �r� �condr� s rC r� r� � s � � �+�B�y��d���B�� � � c 3 �< # � U H u pU( d M Uv � M g 7frq r~ r� s rC r� r� � s � � �'�B�y��$���B�r� )�boolr )rY rB � evaluations�t1�t2s ` rC r) r) � s? �� �( �|���2��2�K� �� �F�B�+�B�+�'�B�'� � rD c � ^� [ U 5 m[ R " U4S j[ [ T5 S- 5 5 5 $ )ah Yields all possible subsets of the iterable. >>> list(powerset([1, 2, 3])) [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)] :func:`powerset` will operate on iterables that aren't :class:`set` instances, so repeated elements in the input will produce repeated elements in the output. Use :func:`unique_everseen` on the input to avoid generating duplicates: >>> seq = [1, 1, 0] >>> list(powerset(seq)) [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)] >>> from more_itertools import unique_everseen >>> list(powerset(unique_everseen(seq))) [(), (1,), (0,), (1, 0)] c 3 �< ># � U H n[ TU5 v � M g 7frq )r )r� �r�ss �rC r� �powerset.<locals>.<genexpr>� s �� � � M�;L�a�|�A�q� 1� 1�;L�s � r� )r? r r] �rangerN )rB r� s @rC r+ r+ � s2 �� �& �X��A� � � � M�5��Q��!��;L� M� M�MrD c # � # � [ 5 nUR n/ nUR nUSLnU H( nU( a U" U5 OUn X�; a U" U5 Uv � M( M* g! [ a X�; a U" U5 Uv � MK MN f = f7f)aI Yield unique elements, preserving order. >>> list(unique_everseen('AAAABBBCCDAABBB')) ['A', 'B', 'C', 'D'] >>> list(unique_everseen('ABBCcAD', str.lower)) ['A', 'B', 'C', 'D'] Sequences with a mix of hashable and unhashable items can be used. The function will be slower (i.e., `O(n^2)`) for unhashable items. Remember that ``list`` objects are unhashable - you can use the *key* parameter to transform the list to a tuple (which is hashable) to avoid a slowdown. >>> iterable = ([1, 2], [2, 3], [1, 2]) >>> list(unique_everseen(iterable)) # Slow [[1, 2], [2, 3]] >>> list(unique_everseen(iterable, key=tuple)) # Faster [[1, 2], [2, 3]] Similary, you may want to convert unhashable ``set`` objects with ``key=frozenset``. For ``dict`` objects, ``key=lambda x: frozenset(x.items())`` can be used. N)�set�add�appendr� ) rB �key�seenset� seenset_add�seenlist� seenlist_add�use_key�element�ks rC r< r< � s� � � �6 �e�G��+�+�K��H��?�?�L���o�G��� #�C��L��� �� ��A�� � � � �� � �� � �Q�� � � !� �s) �?A?�A�A?�A<�5A?�;A<�<A?c �p � [ [ [ [ R " S5 [ X5 5 5 $ )z�Yields elements in order, ignoring serial duplicates >>> list(unique_justseen('AAAABBBCCDAABBB')) ['A', 'B', 'C', 'D', 'A', 'B'] >>> list(unique_justseen('ABBCcAD', str.lower)) ['A', 'B', 'C', 'A', 'D'] r� )rF rQ r` � itemgetterr )rB r� s rC r= r= s( � � �t�S��,�,�Q�/���1G�H� I�IrD c # �T # � Ub U" 5 v � U " 5 v � M ! U a gf = f7f)a� Yields results from a function repeatedly until an exception is raised. Converts a call-until-exception interface to an iterator interface. Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel to end the loop. >>> l = [0, 1, 2] >>> list(iter_except(l.pop, IndexError)) [2, 1, 0] Multiple exceptions can be specified as a stopping condition: >>> l = [1, 2, 3, '...', 4, 5, 6] >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) [7, 6, 5] >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) [4, 3, 2] >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) [] Nr~ )rg � exception�firsts rC r r s7 � � �, � � ��'�M���&�L� �� � � � �s �(� �%�(�%�(c �, � [ [ X 5 U5 $ )ad Returns the first true value in the iterable. If no true value is found, returns *default* If *pred* is not None, returns the first item for which ``pred(item) == True`` . >>> first_true(range(10)) 1 >>> first_true(range(10), pred=lambda x: x > 5) 6 >>> first_true(range(10), default='missing', pred=lambda x: x > 9) 'missing' )rQ �filter)rB rT rY s rC r r + s � �" ��t�&�� 0�0rD r� )r c �n � U Vs/ s H n[ U5 PM snU - n[ S U 5 5 $ s snf )a� Draw an item at random from each of the input iterables. >>> random_product('abc', range(4), 'XYZ') # doctest:+SKIP ('c', 3, 'Z') If *repeat* is provided as a keyword argument, that many items will be drawn from each iterable. >>> random_product('abcd', range(4), repeat=2) # doctest:+SKIP ('a', 2, 'd', 3) This equivalent to taking a random selection from ``itertools.product(*args, **kwarg)``. c 3 �8 # � U H n[ U5 v � M g 7frq )r )r� �pools rC r� �!random_product.<locals>.<genexpr>P s � � �0�%�$��� � �%�s �)r^ )r ri r� �poolss rC r1 r1 ? s7 � � &*� *�T�T�U�4�[�T� *�V� 3�E� �0�%�0� 0�0�� +s �2c �` � [ U 5 nUc [ U5 OUn[ [ X!5 5 $ )aF Return a random *r* length permutation of the elements in *iterable*. If *r* is not specified or is ``None``, then *r* defaults to the length of *iterable*. >>> random_permutation(range(5)) # doctest:+SKIP (3, 4, 0, 1, 2) This equivalent to taking a random selection from ``itertools.permutations(iterable, r)``. )r^ rN r )rB r� r� s rC r0 r0 S s+ � � ��?�D��Y��D� �A�A� ��� � !�!rD c � ^� [ U 5 m[ T5 n[ [ [ U5 U5 5 n[ U4S jU 5 5 $ )z�Return a random *r* length subsequence of the elements in *iterable*. >>> random_combination(range(5), 3) # doctest:+SKIP (2, 3, 4) This equivalent to taking a random selection from ``itertools.combinations(iterable, r)``. c 3 �. ># � U H nTU v � M g 7frq r~ �r� r� r� s �rC r� �%random_combination.<locals>.<genexpr>r � �� � �*�'�Q��a��'�� �)r^ rN �sortedr r� )rB r� rA �indicesr� s @rC r/ r/ e s= �� � ��?�D� �D� �A��V�E�!�H�a�(�)�G� �*�'�*� *�*rD c � ^^� [ U 5 m[ T5 m[ U4S j[ U5 5 5 n[ U4S jU 5 5 $ )a; Return a random *r* length subsequence of elements in *iterable*, allowing individual elements to be repeated. >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP (0, 0, 1, 2, 2) This equivalent to taking a random selection from ``itertools.combinations_with_replacement(iterable, r)``. c 3 �: ># � U H n[ T5 v � M g 7frq )r )r� r� rA s �rC r� �6random_combination_with_replacement.<locals>.<genexpr>� s �� � �4�8�a�Y�q�\�\�8�s �c 3 �. ># � U H nTU v � M g 7frq r~ r� s �rC r� r� � r� r� )r^ rN r� r� )rB r� r� rA r� s @@rC r. r. u s< �� � ��?�D� �D� �A��4�5��8�4�4�G� �*�'�*� *�*rD c � � [ U 5 n[ U5 nUS: d X:� a [ eSn[ XU- 5 n[ SUS- 5 H nXTU- U- - U- nM US: a X%- nUS: d X%:� a [ e/ nU( aN XQ- U- US- US- pnX%:� a X%- nXTU- - U- US- pEX%:� a M UR USU- 5 U( a MN [ U5 $ )a� Equivalent to ``list(combinations(iterable, r))[index]``. The subsequences of *iterable* that are of length *r* can be ordered lexicographically. :func:`nth_combination` computes the subsequence at sort position *index* directly, without computing the previous subsequences. >>> nth_combination(range(5), 3, 5) (0, 3, 4) ``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. r r� ���)r^ rN r� �minr� � IndexErrorr� ) rB r� �indexr� rA �cr� r� �results rC r% r% � s� � � ��?�D� �D� �A� �A��1�5��� �A� �A�1�u� �A� �1�a�!�e�_�� �Q����O�q� �� � �q�y� � �� �� �u�z��� �F� ��%�1�*�a�!�e�Q��U�a���j� �J�E��A��;�!�#�Q��U�q� �j� � � �d�2��6�l�#� �!� ��=�rD c � � [ U /U5 $ )a Yield *value*, followed by the elements in *iterator*. >>> value = '0' >>> iterator = ['1', '2', '3'] >>> list(prepend(value, iterator)) ['0', '1', '2', '3'] To prepend multiple values, see :func:`itertools.chain` or :func:`value_chain`. )r )�valuerR s rC r, r, � s � � �%��(� #�#rD c # � # � [ U5 SSS2 n[ U5 n[ S/US9U- n[ U [ SUS- 5 5 H9 nUR U5 [ [ [ R X5 5 v � M; g7f)a& Convolve the iterable *signal* with the iterable *kernel*. >>> signal = (1, 2, 3, 4, 5) >>> kernel = [3, 2, 1] >>> list(convolve(signal, kernel)) [3, 8, 14, 20, 26, 14, 5] Note: the input arguments are not interchangeable, as the *kernel* is immediately consumed and stored. Nr� r rJ r� ) r^ rN r r r r� rX rF r` ra )�signal�kernelrA �windowr� s rC r r � ss � � � �6�]�4�R�4� �F� �F� �A� �A�3�q� !�A� %�F� �6�6�!�Q��U�+� ,��� � �a���#�h�l�l�F�3�4�4� -�s �BBc �\ ^ ^^� [ T5 m/ mUU U4S jn[ TT5 nU" 5 U4$ )a� A variant of :func:`takewhile` that allows complete access to the remainder of the iterator. >>> it = iter('ABCdEfGhI') >>> all_upper, remainder = before_and_after(str.isupper, it) >>> ''.join(all_upper) 'ABC' >>> ''.join(remainder) # takewhile() would lose the 'd' 'dEfGhI' Note that the first iterator must be fully consumed before the second iterator can generate valid results. c 3 �h ># � T H' n T" U 5 ( a U v � M TR U 5 g g 7frq )r� )�elemr� � predicate� transitions ���rC � true_iterator�'before_and_after.<locals>.true_iterator� s/ �� � ��D������ ��!�!�$�'�� �s �/2)rO r )r� r� r� �remainder_iteratorr� s `` @rC r r � s5 �� � �b��B��J�� �z�2�.�� �?� .� .�.rD c # �\ # � [ [ U 5 5 H u u pu p4XU4v � M g7f)z�Return overlapping triplets from *iterable*. >>> list(triplewise('ABCDE')) [('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')] Nro )rB rl �_rm r� s rC r; r; � s, � � � #�8�H�#5�6�������A�g� � 7�s �*,c # �� # � [ U 5 n[ [ X!5 US9n[ U5 U:X a [ U5 v � U H! nUR U5 [ U5 v � M# g7f)a= Return a sliding window of width *n* over *iterable*. >>> list(sliding_window(range(6), 4)) [(0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)] If *iterable* has fewer than *n* items, then nothing is yielded: >>> list(sliding_window(range(3), 4)) [] For a variant with more features, see :func:`windowed`. rJ N)rO r r rN r^ r� )rB rA r� r� r� s rC r5 r5 � sV � � � �h� �B� �6�"�=�� +�F� �6�{�a���F�m�� ��� � �a���F�m�� �s �A#A%c � � [ U 5 n[ [ [ [ [ U5 S- 5 S5 5 n[ [ R [ U5 U5 $ )z�Return all contiguous non-empty subslices of *iterable*. >>> list(subslices('ABC')) [['A'], ['A', 'B'], ['A', 'B', 'C'], ['B'], ['B', 'C'], ['C']] This is similar to :func:`substrings`, but emits items in a different order. r� � ) r? r �slicer r� rN rF r` �getitemr )rB �seq�slicess rC r6 r6 sF � � �x�.�C� �U�L��s�3�x�!�|�)<�a� @� A�F� �x� � ����f� 5�5rD c � � [ [ SS 5 n[ [ [ R U 5 5 n [ [ U 5 S- 5 Vs/ s H! n[ [ U[ X5 5 5 PM# sn$ s snf )z�Compute a polynomial's coefficients from its roots. >>> roots = [5, -4, 3] # (x - 5) * (x + 4) * (x - 3) >>> polynomial_from_roots(roots) # x^3 - 4 * x^2 - 17 * x + 60 [1, -4, -17, 60] �prodc �8 � [ [ R U S5 $ )Nr� )r r` ra �r� s rC �<lambda>�'polynomial_from_roots.<locals>.<lambda>+ s � �6�(�,�,��1�+ErD r� ) �getattr�mathr? rF r` �negr� rN rX r )�rootsr� r� s rC r* r* # sh � � �4��!E� F�D� ��X�\�\�5�)� *�E�8=�c�%�j�1�n�8M� �8M�1��C��l�5�,� -�.�8M� � �� s �(A:c # �� # � U R nUS- n U" XS- 5 nUv � M ! [ a gf = f! [ a2 [ XS5 n[ XR5 H u pFXaL d Xa:X d M Uv � M gf = f7f)z�Yield the index of each place in *iterable* that *value* occurs, beginning with index *start*. See :func:`locate` for a more general means of finding the indexes associated with particular values. >>> list(iter_index('AABCADEAF', 'A')) [0, 1, 4, 7] r� N)r� r� �AttributeErrorr r� )rB r� rH � seq_indexr� r� r� s rC r! r! 2 s� � � �� �N�N� � �A�I�� �� �e��U�+���� �� � � � �� � � �H�T� *��#�B�.�J�A�� �7�#3��� /��sA �A7� 8 �A7�( � 5�A7�5�A7�-A4�)A4�1A7�3A4�4A7c �> � [ [ SS 5 n[ S5 U S- - nSUSS& U" U 5 S- n[ [ U5 U5 H0 n[ [ [ XD- XU- 5 5 5 X$U- XU- 2' M2 SUS' U S:� a [ US5 $ [ / 5 $ ) zXYield the primes less than n. >>> list(sieve(30)) [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] �isqrtc �@ � [ [ R " U 5 5 $ rq ��intr �sqrtr� s rC r� �sieve.<locals>.<lambda>U � � �S����1� �->rD )r r� r� )r r r N� r� ) r r � bytearrayr r� �bytesrN r! rO )rA r �data�limit�ps rC r4 r4 O s� � � �D�'�#>� ?�E� �V� ��Q�� '�D��D��!�H� �!�H�q�L�E� �e�E�l�D� )��"'��E�!�%���E�,B�(C�"D���U�Q�Q�� � � *��D��G�"#�a�%�:�d�A� �5�T�"�X�5rD c # � # � [ S:� a [ R " S[ 5 [ U 5 n [ [ X!5 5 nU( d gUv � M" 7f)a Batch data into lists of length *n*. The last batch may be shorter. >>> list(batched('ABCDEFG', 3)) [['A', 'B', 'C'], ['D', 'E', 'F'], ['G']] This recipe is from the ``itertools`` docs. This library also provides :func:`chunked`, which has a different implementation. i� zzbatched will be removed in a future version of more-itertools. Use the standard library itertools.batched function insteadN)r �warnings�warn�DeprecationWarningrO r? r )rB rA r� �batchs rC r r _ sQ � � � �Y� �� � �5� � � �h� �B� ��V�B�]�#��� �� � �s �AAc � � [ U 6 $ )z�Swap the rows and columns of the input. >>> list(transpose([(1, 2, 3), (11, 22, 33)])) [(1, 11), (2, 22), (3, 33)] The caller should ensure that the dimensions of the input are compatible. )rk )r� s rC r: r: z s � � ��8�OrD c �x � [ US 5 n[ [ [ [ U [ U5 5 5 U5 $ )z�Multiply two matrices. >>> list(matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)])) [[49, 80], [41, 60]] The caller should ensure that the dimensions of the input matrices are compatible with each other. r )rN r r r r r: )�m1�m2rA s rC r" r" � s0 � � �B�q�E� �A� �7�:�w�r�9�R�=�'A�B�A� F�FrD c # �� # � [ [ SS 5 n[ U" U 5 S- 5 H( n [ X5 u p4U( a M Uv � Un U S:X a gM& U S:� a U v � gg7f)zGYield the prime factors of n. >>> list(factor(360)) [2, 2, 2, 3, 3, 5] r c �@ � [ [ R " U 5 5 $ rq r r� s rC r� �factor.<locals>.<lambda>� r rD r� Nr� )r r r4 �divmod)rA r �prime�quotient� remainders rC r r � so � � � �D�'�#>� ?�E��u�Q�x�!�|�$���"(��"2� �H����K��A��A�v�� � %� �A�v��� �s �A A!)r rq )r� N)NN)P�__doc__r r` r � collectionsr �collections.abcr � functoolsr � itertoolsr r r r r r r r r r r r �randomr r r �sysr �__all__�objectr� r9 r7 r8 r r$ r r� r- r' r& r# r r r2 rn r( rr � ImportErrorr� rt r� r� r r3 r) r+ r< r= r r r1 r0 r/ r. r% r, r r r; r5 r6 r* r! r4 r r: r" r r~ rD rC �<module>r/ st ��� � � � � !� � � � � � -� ,� �) ��V �(�� %� '�$3�$%+�P 4� 0� !� $� )� ��;�.� ,�.�6 � )�8� 0� !�(�(�H�� �J� ��/�(%=�P2�. �>N�.* �Z J� �>1�( "#� 1�("�$ +� +�"'�T $� 5�( /�B� �, 6� � �: 6� �6 � G���K � ��H��s � D �D$�#D$