%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/python3/dist-packages/more_itertools/__pycache__/
Upload File :
Create Path :
Current File : //lib/python3/dist-packages/more_itertools/__pycache__/recipes.cpython-312.pyc

�

�ݷe�k����dZddlZddlZddlmZddlmZddlmZm	Z	ddl
mZmZm
Z
mZmZmZmZmZmZmZmZmZddlmZmZmZddlmZgd	�Ze�Z	e d
��ee d
��Z!e#edd
��Z$d�Z%dFd�Z&d�Z'dGd�Z(dGd�Z)d�Z*e+fd�Z,d�Z-e-Z.d�Z/d�Z0d�Z1dGd�Z2d�Z3	ddl
m4Z5d�Z4e3je4_Gd�de7�Z8d�Z9d �Z:dHd!�Z;d"�Z<d#�Z=d$�Z>dGd%�Z?dGd&�Z@dGd'�ZAdId(�ZBd)d*�d+�ZCdGd,�ZDd-�ZEd.�ZFd/�ZGd0�ZHd1�ZId2�ZJd3�ZKd4�ZLd5�ZMd6�ZNdJd7�ZOd8�ZPd9d�d:�ZQed;k\r
dd<l
mRZSd9d�d=�ZRneQZReQjeR_d>�ZTd?�ZUd@�ZVdA�ZWdB�ZXdC�ZYdD�ZZdE�Z[y#e"$re Z!Y��wxYw#e6$re3Z4Y��wxYw)KaImported 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)�partial�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_eval�polynomial_from_roots�polynomial_derivative�powerset�prepend�quantify�reshape�#random_combination_with_replacement�random_combination�random_permutation�random_product�
repeatfunc�
roundrobin�sieve�sliding_window�	subslices�sum_of_squares�tabulate�tail�take�totient�	transpose�
triplewise�unique_everseen�unique_justseenT��strict�sumprodc��t||�S�N)r)�x�ys  �8/usr/lib/python3/dist-packages/more_itertools/recipes.py�<lambda>rL]s
���A�q�1A��c�,�tt||��S)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  rKr>r>`s����x��#�$�$rMc�,�t|t|��S)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  rKr<r<ps���x��u��&�&rMc	#��K�t|t�r,t|tdt	|�|z
�d�Ed{���ytt
||���Ed{���y7�$7��w)z�Return an iterator over the last *n* items of *iterable*.

    >>> t = tail(3, 'ABCDEFG')
    >>> list(t)
    ['E', 'F', 'G']

    rN��maxlen)�
isinstancerr
�max�len�iterrrPs  rKr=r=�sS�����(�E�"��(�C��3�x�=�1�+<�$=�t�D�D�D���h�q�1�2�2�2�	E��2�s!�7A"�A�A"�A �A"� A"c�R�|�t|d��ytt|||�d�y)aXAdvance *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

    NrrX)r�nextr
)�iteratorrQs  rKrr�s)��@	�y�
�h�q�!�	
�V�H�a��
#�T�*rMc�0�tt||d�|�S)z�Returns the nth item or a default value.

    >>> l = range(10)
    >>> nth(l, 3)
    3
    >>> nth(l, 20, "zebra")
    'zebra'

    N)r_r
)rRrQ�defaults   rKr%r%�s����x��D�)�7�3�3rMc�N�t|�}t|d�xr
t|d�S)z�
    Returns ``True`` if all the elements are equal to each other.

        >>> all_equal('aaaa')
        True
        >>> all_equal('aaab')
        False

    TF)rr_)rR�gs  rKrr�s(��	���A���4�=�/��a���/�/rMc�,�tt||��S)zcReturn the how many times the predicate is true.

    >>> quantify([True, False, True])
    2

    )�sumrT)rR�preds  rKr0r0�s���s�4��"�#�#rMc�,�t|td��S)aReturns 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)rr�rRs rKr(r(�s����6�$�<�(�(rMc�R�tjtt|�|��S)zvReturns the sequence elements *n* times

    >>> list(ncycles(["a", "b"], 3))
    ['a', 'b', 'a', 'b', 'a', 'b']

    )r�
from_iterabler�tuple)rRrQs  rKr$r$�s �����v�e�H�o�q�9�:�:rMc�J�tttj||��S)zcReturns the dot product of the two iterables.

    >>> dotproduct([10, 10], [20, 20])
    400

    )rfrT�operator�mul)�vec1�vec2s  rKrr�s���s�8�<�<��t�,�-�-rMc�,�tj|�S)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.

    )rrk)�listOfListss rKrrs�����{�+�+rMc�\�|�t|t|��St|t||��S)aGCall *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]

    )rr)�func�times�argss   rKr6r6s.��,
�}��t�V�D�\�*�*��4���e�,�-�-rMc�N�t|�\}}t|d�t||�S)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)rr_�zip)rR�a�bs   rK�	_pairwiser|-s&���x�=�D�A�q���D�M��q�!�9�rM�r)c��t|�SrH)�itertools_pairwiseris rKr)r)As
��!�(�+�+rMc� ��eZdZd�fd�	Z�xZS)�UnequalIterablesErrorc�P��d}|�|dj|�z
}t�|�	|�y)Nz Iterables have different lengthsz/: index 0 has length {}; index {} has length {})�format�super�__init__)�self�details�msg�	__class__s   �rKr�zUnequalIterablesError.__init__Hs;���0�����M�E�M�M���
�C�	����rMrH)�__name__�
__module__�__qualname__r��
__classcell__)r�s@rKr�r�Gs
����rMr�c#�nK�t|dti�D]}|D]}|tus�t��|���!y�w)N�	fillvalue)r�_markerr�)�	iterables�combo�vals   rK�_zip_equal_generatorr�RsE�����i�;�7�;����	.�C��g�~�+�-�-�	.���	�s� 5�5c���	t|d�}t|ddd�D]$\}}t|�}||k7s�t|||f���t|�S#t$rt|�cYSwxYw)Nr�)r�)r\�	enumerater�ry�	TypeErrorr�)r��
first_size�i�it�sizes     rK�
_zip_equalr�Zs���/���1��&�
��y���}�a�0�	K�E�A�r��r�7�D��z�!�+�Z��D�4I�J�J�	K�
�I�����/�#�I�.�.�/�s�3A�A�A%�$A%c��t|�g|z}|dk(rt|d|i�S|dk(rt|�S|dk(rt|�St	d��)a�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�rE�ignorez Expected fill, strict, or ignore)r]rr�ry�
ValueError)rRrQ�
incompleter�rws     rKr r js^��:
��N��a��D��V���D�6�I�6�6��X���4� � ��X���D�z���;�<�<rMc'��K�t|�}td�|D��}|r	|D]}|����
	|r�yy#t$r|dz}tt||��}Y�*wxYw�w)aJYields 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).

    c3�FK�|]}t|�j���y�wrH)r]�__next__)�.0r�s  rK�	<genexpr>zroundrobin.<locals>.<genexpr>�s����8��$�r�(�#�#�8�s�!r�N)r\r�
StopIterationr
)r��pending�nextsr_s    rKr7r7�sn�����)�n�G��8�i�8�8�E�
�	2��
���f��
����	2��q�L�G��&���0�1�E�	2�s*� A"�9�A"�A"�#A�A"�A�A"c���|�t}t|d�\}}}tt||��\}}t|ttj
|��t||�fS)a�
    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, ' '])

    �)�boolrrTr	rn�not_)rgrR�t1�t2�p�p1�p2s       rKr*r*�sX��(�|����H�a� �I�B��A�
��T�1��
�F�B���R��X�]�]�B�/�0�(�2�r�2B�C�CrMc���t|��tj�fd�tt	��dz�D��S)a�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)]

    c3�6�K�|]}t�|����y�wrH)r)r��r�ss  �rKr�zpowerset.<locals>.<genexpr>�s�����M�a�|�A�q�1�M�s�r�)rOrrk�ranger\)rRr�s @rKr.r.�s2���&	
�X��A����M�5��Q��!��;L�M�M�MrMc#��K�t�}|j}g}|j}|du}|D]}|r||�n|}	||vr||�|���!y#t$r||vr||�|��Y�>wxYw�w)a�
    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]]

    Similarly, 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�)	rR�key�seenset�seenset_add�seenlist�seenlist_add�use_key�element�ks	         rKrBrB�s�����6�e�G��+�+�K��H��?�?�L���o�G��	��#�C��L���	�����A���
��	���	��� ��Q���
��	�s(�:A/�A�
A/�A,�)A/�+A,�,A/c
���|�(ttjd�t|��Sttttjd�t||���S)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']

    rr�)rTrn�
itemgetterrr_)rRr�s  rKrCrC	sL���{��8�&�&�q�)�7�8�+<�=�=��t�S��,�,�Q�/���3�1G�H�I�IrMc#�NK�	|�	|���	|����
#|$rYywxYw�w)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)))
        []

    N�)ru�	exception�firsts   rKr!r!s8����,
����'�M���&�L����
��
�s�%��"�%�"�%c�.�tt||�|�S)a�
    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'

    )r_�filter)rRrbrgs   rKrr7s��"��t�X�&��0�0rMr�)rc�h�|D�cgc]
}t|���c}|z}td�|D��Scc}w)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)``.

    c3�2K�|]}t|����y�wrH)r)r��pools  rKr�z!random_product.<locals>.<genexpr>\s����0�$����0�s�)rl)rrwr��poolss    rKr5r5Ks3�� &*�*�T�U�4�[�*�V�3�E��0�%�0�0�0��
+s�/c�`�t|�}|�t|�n|}tt||��S)abReturn 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)``.

    )rlr\r)rRr�r�s   rKr4r4_s-����?�D��Y��D�	�A�A����a��!�!rMc���t|��t��}ttt	|�|��}t�fd�|D��S)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)``.

    c3�(�K�|]	}�|���y�wrHr��r�r�r�s  �rKr�z%random_combination.<locals>.<genexpr>~������*�Q��a��*���)rlr\�sortedrr�)rRr�rQ�indicesr�s    @rKr3r3qs=�����?�D��D�	�A��V�E�!�H�a�(�)�G��*�'�*�*�*rMc����t|��t���t�fd�t|�D��}t�fd�|D��S)aSReturn 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)``.

    c3�4�K�|]}t�����y�wrH)r)r�r�rQs  �rKr�z6random_combination_with_replacement.<locals>.<genexpr>�s�����4�a�Y�q�\�4�s�c3�(�K�|]	}�|���y�wrHr�r�s  �rKr�z6random_combination_with_replacement.<locals>.<genexpr>�r�r�)rlr\r�r�)rRr�r�rQr�s   @@rKr2r2�s<�����?�D��D�	�A��4�5��8�4�4�G��*�'�*�*�*rMc��t|�}t|�}|dks||kDrt�d}t|||z
�}t	d|dz�D]}|||z
|zz|z}�|dkr||z
}|dks||k\rt
�g}|rL||z|z|dz
|dz
}}}||k\r||z}|||z
z|z|dz
}}||k\r�|j
|d|z
�|r�Lt|�S)aEquivalent 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.
    rr����)rlr\r��minr��
IndexErrorr�)	rRr��indexr�rQ�cr�r��results	         rKr&r&�s����?�D��D�	�A�	�A��1�q�5���	�A��A�q�1�u�
�A�
�1�a�!�e�_�!��
��Q����O�q� ��!�
�q�y�
��
��
��	�u��z���
�F�
��a�%�1�*�a�!�e�Q��U�a�1���q�j��Q�J�E���A��;�!�#�Q��U�q�A��q�j�	�
�
�d�2��6�l�#����=�rMc��t|g|�S)aYield *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)�valuer`s  rKr/r/�s���%��(�#�#rMc#��K�t|�ddd�}t|�}tdg|��|z}t|t	d|dz
��D]!}|j|�t
||����#y�w)aBConvolve 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�rrXr�)rlr\rrrr��_sumprod)�signal�kernelrQ�windowrIs     rKrr�sp�����6�]�4�R�4�
 �F��F��A�
�A�3�q�
!�A�
%�F�
�6�6�!�Q��U�+�
,�'���
�
�a���v�v�&�&�'�s�A,A.c�Z����t���g����fd�}t���}|�|fS)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.
    c3�Z�K��D]!}�|�r|����j|�yy�wrH)r�)�elemr��	predicate�
transitions ���rK�
true_iteratorz'before_and_after.<locals>.true_iterator�s3������	�D�����
��!�!�$�'��	�s�(+)r]r)r�r�r��remainder_iteratorr�s``  @rKrr�s5���
�b��B��J���z�2�.���?�.�.�.rMc#�^K�tt|��D]\\}}\}}|||f���y�w)z�Return overlapping triplets from *iterable*.

    >>> list(triplewise('ABCDE'))
    [('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')]

    Nr})rRrz�_r{r�s     rKrArAs8����#�8�H�#5�6�����A���A���A�g�
��s�+-c#�K�t|�}tt||dz
�|��}|D] }|j|�t	|����"y�w)aYReturn 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`.
    r�rXN)r]rr
r�rl)rRrQr�r�rIs     rKr9r9
sM����
�h��B�
�6�"�a�!�e�$�Q�
/�F�
����
�
�a���F�m���s�AAc
��t|�}tttt	t|�dz�d��}t
tjt|�|�S)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��)
rOr�slicerr�r\rTrn�getitemr)rR�seq�slicess   rKr:r:!sF���x�.�C�
�U�L��s�3�x�!�|�)<�a�@�
A�F��x������f�5�5rMc��ttd�ttj|��}tt
t|dg��S)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]
    r�)ryrrTrn�negrOrr)�roots�factorss  rKr,r,/s5���&��)�S����u�5�6�G���x��1�#�.�/�/rMc#�K�t|dd�}|�0t|||�}t||�D]\}}||us||k(s�|���y|�t|�n|}|dz
}		|||dz|�x}���#t$rYywxYw�w)a�Yield the index of each place in *iterable* that *value* occurs,
    beginning with index *start* and ending before index *stop*.

    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]
    >>> list(iter_index('AABCADEAF', 'A', 1))  # start index is inclusive
    [1, 4, 7]
    >>> list(iter_index('AABCADEAF', 'A', 1, 7))  # stop index is not inclusive
    [1, 4]
    r�Nr�)�getattrr
r�r\r�)rRr�rV�stop�	seq_indexr�r�r�s        rKr"r":s�������'�4�0�I���
�H�e�T�
*��#�B��.�	�J�A�w��%��7�e�#3���	�
!%��s�8�}�$���A�I��	��%�e�Q��U�D�9�9�q�:����	��	�s(�8A9�A9�A*�*	A6�3A9�5A6�6A9c#�jK�|dkDrd��d}td�|dzz}tj|�dz}t|d||�D]Q}t|d|||z�Ed{���t	tt
||z|||z���|||z|||z�<||z}�St|d|�Ed{���y7�R7��w)zdYield the primes less than n.

    >>> list(sieve(30))
    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
    r�r�)rr�r�N)�	bytearray�math�isqrtr"�bytesr\r�)rQrV�data�limitr�s     rKr8r8Zs�����	�1�u���
�E��V���Q��'�D��J�J�q�M�A��E�
��a���
.����d�A�u�a�!�e�4�4�4�"'��E�!�a�%��A��E�,B�(C�"D��Q��U�Q��Q��
���A�����$��5�)�)�)�	5��*�s%�AB3�B/�AB3�)B1�*B3�1B3Fc#��K�|dkrtd��t|�}tt||��x}r8|rt	|�|k7rtd��|��tt||��x}r�7yy�w)a�Batch data into tuples of length *n*. If the number of items in
    *iterable* is not divisible by *n*:
    * The last batch will be shorter if *strict* is ``False``.
    * :exc:`ValueError` will be raised if *strict* is ``True``.

    >>> list(batched('ABCDEFG', 3))
    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]

    On Python 3.13 and above, this is an alias for :func:`itertools.batched`.
    r�zn must be at least onezbatched(): incomplete batchN)r�r]rlr
r\)rRrQrEr��batchs     rK�_batchedrlsp����	�1�u��1�2�2�	
�h��B����A��'�
'�%�
'��c�%�j�A�o��:�;�;������A��'�
'�%�
'�s�A)A.�,A.i�
)rc��t|||��S)NrD)�itertools_batched)rRrQrEs   rKrr�s�� ��1�V�<�<rMc��t|�S)a
Swap the rows and columns of the input matrix.

    >>> 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.
    If the input is empty, no output will be produced.
    )�_zip_strict�r�s rKr@r@�s�����rMc�@�ttj|�|�S)z�Reshape the 2-D input *matrix* to have a column count given by *cols*.

    >>> matrix = [(0, 1), (2, 3), (4, 5)]
    >>> cols = 3
    >>> list(reshape(matrix, cols))
    [(0, 1, 2), (3, 4, 5)]
    )rrrk)�matrix�colss  rKr1r1�s���5�&�&�v�.��5�5rMc�x�t|d�}tttt	|t|���|�S)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)r\rrr�rr@)�m1�m2rQs   rKr#r#�s0��	�B�q�E�
�A��7�8�W�R��2��%?�@�!�D�DrMc#�K�ttj|�dz�D]}||zr�	|��||z}|dk(ry||zs�� |dkDr|��yy�w)zTYield the prime factors of n.

    >>> list(factor(360))
    [2, 2, 2, 3, 3, 5]
    r�N)r8rr)rQ�primes  rKrr�sd�����t�z�z�!�}�q�(�)����e�)��K�
�%�K�A��A�v��	�e�)��	�1�u���
�s�*A�A�
Ac	��t|�}|dk(r|dzSttt|�t	t|���}t
||�S)z�Evaluate a polynomial at a specific value.

    Example: evaluating x^3 - 4 * x^2 - 17 * x + 60 at x = 2.5:

    >>> coefficients = [1, -4, -17, 60]
    >>> x = 2.5
    >>> polynomial_eval(coefficients, x)
    8.125
    r)r\rT�powr�reversedr�r�)�coefficientsrIrQ�powerss    rKr+r+�sF��	�L��A��A�v��1�u��
��f�Q�i��%��(�!3�
4�F��L�&�)�)rMc�$�tt|��S)zfReturn the sum of the squares of the input values.

    >>> sum_of_squares([10, 20, 30])
    1400
    )r�rrs rKr;r;�s���S��W��rMc��t|�}ttd|��}tt	t
j||��S)aCompute the first derivative of a polynomial.

    Example: evaluating the derivative of x^3 - 4 * x^2 - 17 * x + 60

    >>> coefficients = [1, -4, -17, 60]
    >>> derivative_coefficients = polynomial_derivative(coefficients)
    >>> derivative_coefficients
    [3, -8, -17]
    r�)r\rr�rOrTrnro)rrQrs   rKr-r-�s6��	�L��A�
�e�A�q�k�
"�F���H�L�L�,��7�8�8rMc�N�tt|��D]
}||z|dz
z}�|S)z�Return the count of natural numbers up to *n* that are coprime with *n*.

    >>> totient(9)
    6
    >>> totient(12)
    4
    r�)rCr)rQr�s  rKr?r?�s5���V�A�Y�
'���
��F�a�!�e����
�HrM)rrH)r�N)NN)rN)\�__doc__rrn�collectionsr�collections.abcr�	functoolsrr�	itertoolsrrr	r
rrr
rrrrr�randomrrr�sysr�__all__�objectr�ryrr�r�r�r>r<r=rr%rr�r0r(r'r$rrr6r|r)r�ImportErrorr�r�r�r�r r7r*r.rBrCr!rr5r4r3r2r&r/rrrAr9r:r,r"r8rrr
r@r1r#rr+r;r-r?r�rMrK�<module>r+s�������!�%�
�
�
�
�-�,��.��`�(��,��t���#�d�+�K��4��$A�B��
%� '�$3�$%+�P
4�0�!�$�)���;�.�	,�.�6�	)�8�
,�!�(�(�H���J���
/� %=�P2�.D�8N�.*�ZJ�
�>1�("#�1�("�$
+� +�"'�T$�'�,/�B��(6�0��@*�$%*��(���6�',�=��G��&�&�G�O�	�6�
E�
� *�"�9�
��e���K���L���H��s$�	E �%E-� E*�)E*�-E7�6E7

Zerion Mini Shell 1.0