403Webshell
Server IP : 54.37.205.81  /  Your IP : 216.73.216.76
Web Server : nginx/1.22.1
System : Linux vps-249481fa 6.1.0-50-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.176-1 (2026-07-02) x86_64
User : debian ( 1000)
PHP Version : 8.2.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/more_itertools/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/more_itertools/__pycache__/recipes.cpython-311.pyc
�

�B;aA���dZddlZddlmZddlmZmZmZmZm	Z	m
Z
mZmZm
Z
mZddlZddlmZmZmZgd�Zd�Zd'd�Zd	�Zd(d
�Zd(d�Zd�Zefd
�Zd�ZeZd�Zd�Z d�Z!d(d�Z"d�Z#	ddlm$Z%d�Z$e#je$_n
#e&$re#Z$YnwxYwd(d�Z'd�Z(d�Z)d�Z*d(d�Z+d(d�Z,d(d�Z-d)d�Z.dd�d �Z/d(d!�Z0d"�Z1d#�Z2d$�Z3d%�Z4d&�Z5dS)*aImported 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)
�chain�combinations�count�cycle�groupby�islice�repeat�starmap�tee�zip_longest)�	randrange�sample�choice)�	all_equal�consume�convolve�
dotproduct�
first_true�flatten�grouper�iter_except�ncycles�nth�nth_combination�padnone�pad_none�pairwise�	partition�powerset�prepend�quantify�#random_combination_with_replacement�random_combination�random_permutation�random_product�
repeatfunc�
roundrobin�tabulate�tail�take�unique_everseen�unique_justseenc�<�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  �8/usr/lib/python3/dist-packages/more_itertools/recipes.pyr+r+<s����x��#�#�$�$�$�c�<�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  r3r)r)Ls���x��u���&�&�&r4c�>�tt||�����S)z�Return an iterator over the last *n* items of *iterable*.

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

    ��maxlen)�iterrr0s  r3r*r*^s����h�q�)�)�)�*�*�*r4c�n�|�t|d���dStt|||��d��dS)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

    Nrr:)r�nextr	)�iteratorr1s  r3rrisG��@	�y�
�h�q�!�!�!�!�!�!�	
�V�H�a��
#�
#�T�*�*�*�*�*r4c�@�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	)r2r1�defaults   r3rr�s ����x��D�)�)�7�3�3�3r4c�b�t|��}t|d��ot|d��S)z�
    Returns ``True`` if all the elements are equal to each other.

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

    TF)rr>)r2�gs  r3rr�s/��	����A���4�=�=�/��a����/�/r4c�<�tt||����S)zcReturn the how many times the predicate is true.

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

    )�sumr6)r2�preds  r3r"r"�s���s�4��"�"�#�#�#r4c�<�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
�r2s r3rr�s����6�$�<�<�(�(�(r4c�`�tjtt|��|����S)zvReturns the sequence elements *n* times

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

    )r�
from_iterabler
�tuple)r2r1s  r3rr�s%����v�e�H�o�o�q�9�9�:�:�:r4c�R�tttj||����S)zcReturns the dot product of the two iterables.

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

    )rEr6�operator�mul)�vec1�vec2s  r3rr�s ���s�8�<��t�,�,�-�-�-r4c�*�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.

    )rrJ)�listOfListss r3rr�s����{�+�+�+r4c�|�|�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   r3r'r'�s9��,
�}��t�V�D�\�\�*�*�*��4���e�,�,�-�-�-r4c#�zK�t|��\}}t|d��t||��Ed{V��dS)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r>�zip)r2�a�bs   r3�	_pairwiser[sJ�����x�=�=�D�A�q���D�M�M�M��1�a�y�y���������r4)rc#�4K�t|��Ed{V��dS�N)�itertools_pairwiserHs r3rrs,����%�h�/�/�/�/�/�/�/�/�/�/�/r4c��t|t��rtjdt��||}}t|��g|z}t
|d|i�S)z�Collect data into fixed-length chunks or blocks.

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

    z+grouper expects iterable as first parameter�	fillvalue)�
isinstance�int�warnings�warn�DeprecationWarningr<r
)r2r1r`rVs    r3rrsa���(�C� � �"��
�9�;M�	
�	
�	
���8����N�N��a��D��T�2��2�2�2r4c'��K�t|��}td�|D����}|rI	|D]}|��V��n2#t$r%|dz}tt||����}YnwxYw|�GdSdS)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�>K�|]}t|��jV��dSr])r<�__next__)�.0�its  r3�	<genexpr>zroundrobin.<locals>.<genexpr>9s+����8�8��$�r�(�(�#�8�8�8�8�8�8r4�N)�lenr�
StopIterationr	)�	iterables�pending�nextsr>s    r3r(r(,s������)�n�n�G��8�8�i�8�8�8�8�8�E�
�2�	2��
�
���d�f�f�����
���	2�	2�	2��q�L�G��&���0�0�1�1�E�E�E�	2����	�2�2�2�2�2s�A�,A/�.A/c�����t��fd�|D��}t|��\}}d�|D��d�|D��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, ' '])

    Nc3�2�K�|]}�|��|fV��dSr]�)ri�xrFs  �r3rkzpartition.<locals>.<genexpr>Zs/�����2�2�A�D�D��G�G�Q�<�2�2�2�2�2�2r4c3�$K�|]\}}|�|V��dSr]rt�ri�condrus   r3rkzpartition.<locals>.<genexpr>]s+����+�+�y��a�d�+��+�+�+�+�+�+r4c3�$K�|]\}}|�|V��dSr]rtrws   r3rkzpartition.<locals>.<genexpr>^s+����'�'�y��a�$�'��'�'�'�'�'�'r4)�boolr)rFr2�evaluations�t1�t2s`    r3rrCse���(�|���2�2�2�2��2�2�2�K�
��
�
�F�B��+�+�B�+�+�+�'�'�B�'�'�'��r4c���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�8�K�|]}t�|��V��dSr])r)ri�r�ss  �r3rkzpowerset.<locals>.<genexpr>vs-�����M�M�a�|�A�q�1�1�M�M�M�M�M�Mr4rl)r/rrJ�rangerm)r2r�s @r3r r bsH���&	
�X���A���M�M�M�M�5��Q���!��;L�;L�M�M�M�M�M�Mr4c#��K�t��}|j}g}|j}|du}|D]H}|r||��n|}	||vr||��|V��&#t$r||vr||��|V�Y�EwxYwdS)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]]

    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�append�	TypeError)	r2�key�seenset�seenset_add�seenlist�seenlist_add�use_key�element�ks	         r3r,r,ys�����6�e�e�G��+�K��H��?�L���o�G��	�	��#�0�C�C��L�L�L���	�������A�����
�
�
����	�	�	��� � ���Q�����
�
�
���	����
	�	s�A
�
A-�,A-c
��ttttjd��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']

    rl)r6r>rM�
itemgetterr)r2r�s  r3r-r-�s3���t�S��,�Q�/�/���3�1G�1G�H�H�I�I�Ir4c#�XK�	|�|��V�	|��V��
#|$rYdSwxYw)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)))
        []

    Nrt)rT�	exception�firsts   r3rr�s[����,
����%�'�'�M�M�M�	��$�&�&�L�L�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)r2rArFs   r3rr�s��"��t�X�&�&��0�0�0r4rl)r
c�R�d�|D��|z}td�|D����S)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�,�g|]}t|����Srt�rK�ri�pools  r3�
<listcomp>z"random_product.<locals>.<listcomp>�s��*�*�*�T�U�4�[�[�*�*�*r4c3�4K�|]}t|��V��dSr])rr�s  r3rkz!random_product.<locals>.<genexpr>�s(����0�0�$�����0�0�0�0�0�0r4r�)r
rV�poolss   r3r&r&�s9�� 
+�*�T�*�*�*�V�3�E��0�0�%�0�0�0�0�0�0r4c��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)``.

    )rKrmr)r2r�r�s   r3r%r%�s8����?�?�D��Y��D�	�	�	�A�A����a���!�!�!r4c����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�|]}�|V��
dSr]rt�ri�ir�s  �r3rkz%random_combination.<locals>.<genexpr>�'�����*�*�Q��a��*�*�*�*�*�*r4)rKrm�sortedrr�)r2r�r1�indicesr�s    @r3r$r$s[�����?�?�D��D�	�	�A��V�E�!�H�H�a�(�(�)�)�G��*�*�*�*�'�*�*�*�*�*�*r4c�����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�6�K�|]}t���V��dSr])r)rir�r1s  �r3rkz6random_combination_with_replacement.<locals>.<genexpr>(s)�����4�4�a�Y�q�\�\�4�4�4�4�4�4r4c3�(�K�|]}�|V��
dSr]rtr�s  �r3rkz6random_combination_with_replacement.<locals>.<genexpr>)r�r4)rKrmr�r�)r2r�r�r1r�s   @@r3r#r#sg������?�?�D��D�	�	�A��4�4�4�4�5��8�8�4�4�4�4�4�G��*�*�*�*�'�*�*�*�*�*�*r4c���t|��}t|��}|dks||krt�d}t|||z
��}t	d|dz��D]}|||z
|zz|z}�|dkr||z
}|dks||krt
�g}|rS||z|z|dz
|dz
}}}||kr||z}|||z
z|z|dz
}}||k�|�|d|z
��|�St|��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.
    rrl���)rKrm�
ValueError�minr��
IndexErrorr�)	r2r��indexr�r1�cr�r��results	         r3rr,s8����?�?�D��D�	�	�A�	�A���1�q�5�5���	�A��A�q�1�u�
�
�A�
�1�a�!�e�_�_�!�!��
��Q����O�q� ����q�y�y�
��
��
��	�	�u��z�z���
�F�
�$��a�%�1�*�a�!�e�Q��U�a�1���q�j�j��Q�J�E���A��;�!�#�Q��U�q�A��q�j�j�	�
�
�d�2��6�l�#�#�#��$���=�=�r4c�$�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  r3r!r!Vs���%��(�#�#�#r4c#�HK�t|��ddd�}t|��}tdg|���|z}t|t	d|dz
����D]A}|�|��t
ttj	||����V��BdS)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�rr:rl)
rKrmrrr
r�rEr6rMrN)�signal�kernelr1�windowrus     r3rres������6�]�]�4�4�R�4�
 �F��F���A�
�A�3�q�
!�
!�
!�A�
%�F�
�6�6�!�Q��U�+�+�
,�
,�5�5���
�
�a�����#�h�l�F�F�3�3�4�4�4�4�4�4�5�5r4)rr])NN)6�__doc__rc�collectionsr�	itertoolsrrrrrr	r
rrr
rM�randomrrr�__all__r+r)r*rrrrzr"rrrrrr'r[rr^�ImportErrorrr(rr r,r-rrr&r%r$r#rr!rrtr4r3�<module>r�sE������������������������������������������,�,�,�,�,�,�,�,�,�,�����B
%�
%�
%� '�'�'�'�$+�+�+�%+�%+�%+�%+�P
4�
4�
4�
4�0�0�0�!�$�$�$�$�)�)�)���;�;�;�.�.�.�	,�	,�	,�.�.�.�.�6���	)�8�8�8�8�8�8�
0�0�0�!�(�H���������H�H�H�����
3�
3�
3�
3� 2�2�2�.���>N�N�N�.*�*�*�*�Z	J�	J�	J�	J�
�
�
�
�>1�1�1�1�("#�1�1�1�1�1�("�"�"�"�$
+�
+�
+� +�+�+�"'�'�'�T$�$�$�5�5�5�5�5s�'A=�=B�B

Youez - 2016 - github.com/yon3zu
LinuXploit