U

�[p:�@s�
dZd
dl
mZ
d
dlmZmZmZmZmZm	Z	m
Z
mZmZ
d
dl
Z
d
dlmZmZmZ
d
dlmZ
d
dlmZmZmZmZmZmZ
dd	d
ddd
ddddddddddddddddddd d!d"d#gZe
jf
d$d�
Zd%d!�ZdAd&d�
Zd'd �Z dBd(d
�
Z!dCd)d�
Z"d*d	�Z#e$f
d+d�
Z%d,d�Z&d-d�Z'd.d�Z(d/d
�Z)dDd0d�
Z*d1d�Z+dEd2d�
Z,d3d�Z-d4d�Z.d5d�Z/dFd6d"�
Z0dGd7d#�
Z1dHd8d�
Z2dId:d�
Z3d;d�Z4dJd<d�
Z5d=d�Z6d>d�Z7d?d�Z8d@d�Z9dS)Ka
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

�)
�deque)	�chain�combinations�count�cycle�groupby�islice�repeat�starmap�teeN)�	randrange�sample�choice)
�PY2)�filter�filterfalse�map�range�zip�zip_longest�
accumulate�	all_equal�consume�
dotproduct�
first_true�flatten�grouper�iter_except�ncycles�nth�nth_combination�padnone�pairwise�	partition�powerset�prepend�quantify�#random_combination_with_replacement�random_combination�random_permutation�random_product�
repeatfunc�
roundrobin�tabulate�tail�take�unique_everseen�unique_justseenccsPt|�
}zt
|�
}Wntk
r*


Yd
SX|V
|D]}|
||�}|V
q6d
S)a_
    Return an iterator whose items are the accumulated results of a function
    (specified by the optional *func* argument) that takes two arguments.
    By default, returns accumulated sums with :func:`operator.add`.

        >>> list(accumulate([1, 2, 3, 4, 5]))  # Running sum
        [1, 3, 6, 10, 15]
        >>> list(accumulate([1, 2, 3], func=operator.mul))  # Running product
        [1, 2, 6]
        >>> list(accumulate([0, 1, -1, 2, 3, 2], func=max))  # Running maximum
        [0, 1, 1, 2, 3, 3]

    This function is available in the ``itertools`` module for Python 3.2 and
    greater.

    N)�iter�next�
StopIteration)�iterable�func�itZtotal�element�r9�8/usr/lib/python3/dist-packages/more_itertools/recipes.pyr4s






cCstt
|
|��
S)
a.
Return first *n* items of the iterable as a list.

        >>> take(3, range(10))
        [0, 1, 2]
        >>> take(5, range(3))
        [0, 1, 2]

    Effectively a short replacement for ``next`` based iterator consumption
    when you want more than one item, but less than the whole iterator.

    )�listr��
nr5r9r9r:r/RscCst|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]

    )rr)Zfunction�startr9r9r:r-ascCstt
|
|d
��
S)z�Return an iterator over the last *n* items of *iterable*.

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

    �
�maxlen)r2rr<r9r9r:r.sscCs,|
d
krt|dd�
nt
t||
|
�d
�
d
S)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

    Nr
r?)rr3r)�iteratorr=r9r9r:r~s cCstt
||
d
�|�S)z�Returns the nth item or a default value.

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

    N)r3r)r5r=�defaultr9r9r:r�s
c
Cst|�
}
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)rr3)r5�
gr9r9r:r�s

cCstt
|
|��
S)
zkReturn the how many times the predicate is true.

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

    )�sumr)r5�predr9r9r:r&�sc

Cst|t
d
�
�S)z�Returns the sequence of elements and then returns ``None`` indefinitely.

        >>> take(5, padnone(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	�
r5r9r9r:r!�scCst�
tt|�
|
��
S)
z~Returns the sequence elements *n* times

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

    )r�
from_iterabler	�tuple)r5r=r9r9r:r�scCstt
tj||
��
S)
zkReturns the dot product of the two iterables.

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

    )rDr�operator�mul)Zvec1Zvec2r9r9r:r�sc

Cs
t�
|�
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.

    )rrG)
ZlistOfListsr9r9r:r�s	cGs&|
d
krt|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]

    N)r
r	)r6�times�argsr9r9r:r+�s

c
Cs 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)]

    N)rr3r)r5�
a�
br9r9r:r"
s


cCst|
�
g
|}t
|d
|i
�
S)z�Collect data into fixed-length chunks or blocks.

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

    �	fillvalue)r2r)r=r5rOrLr9r9r:r 
s
cgs~t|�
}
t
r td
d�|D�
�
}ntdd�|D�
�
}|
rzz|D]}|�V
q<Wq2tk
rv


|
d8}
tt||
��
}Yq2Xq2dS)aJ
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
ss|]}
t|
�
j
V
qdS�
N)r2r3��.0r7r9r9r:�	<genexpr>9
szroundrobin.<locals>.<genexpr>c
ss|]}
t|
�
j
V
qdSrP)r2�__next__rQr9r9r:rS;
s�
N)�lenrrr4r)�	iterables�pendingZnextsr3r9r9r:r,+
s








cCs t|
�
\}}t
||�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])

    )rrr)rEr5�t1�t2r9r9r:r#E
s
c

s,t|�
�t
��f
d
d�tt��
d�
D�
�
S)z�Yields all possible subsets of the iterable.

        >>> list(powerset([1,2,3]))
        [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

    c
3s|]}
t�|
�V
qdSrP)
r)rR�
r�
�
sr9r:rS_
szpowerset.<locals>.<genexpr>rU)r;rrGrrVrFr9r\r:r$W
s
c	cs�t�}|j
}g}|j}|
d
krp|D]J}z||kr>||�

|V
Wq"tk
rj


||krf||�

|V
Yq"Xq"nX|D]R}|
|�
}z||kr�||�

|V
Wqttk
r�


||kr�||�

|V
YqtXqtd
S)aj

    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.

    N)�set�add�append�	TypeError)r5�keyZseensetZseenset_addZseenlistZseenlist_addr8�
kr9r9r:r0b
s0
























cCstt
tt�d
�
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']

    rU)rr3rI�
itemgetterr)r5rbr9r9r:r1�
s	ccs8z|d
k	r|�V
|�V
qWn|
k
r2


YnXd
S)aX
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]

    Nr9)r6Z	exception�firstr9r9r:r�
s



FcCstt
||�|
�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'

    )r3r)r5rBrEr9r9r:r�
scOs,d
d�|D�
|
�dd�}t
dd�|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
Ssg|]}
t|
�
�qSr9)
rH�rR�poolr9r9r:�
<listcomp>�
sz"random_product.<locals>.<listcomp>r	rUc
ss|]}
t|
�
V
qdSrP)
rrfr9r9r:rS�
sz!random_product.<locals>.<genexpr>)�getrH)rL�kwdsZpoolsr9r9r:r*�
s
cCs*t|�
}|
d
krt
|�
n|
}
tt||
��
S)ab
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)``.

    N)rHrVr
)r5r[rgr9r9r:r)�
s


cs8t|�
�t
��
}ttt|�
|
��
}t�f
d
d�|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)``.

    c
3s|]}
�|
V
qdSrPr9�rR�
i�
rgr9r:rS�
sz%random_combination.<locals>.<genexpr>)rHrV�sortedr
r)r5r[r=�indicesr9rmr:r(�
s



cs@t|�
�
t
�
�
�t�f
d
d�t|
�
D�
�
}t�
f
dd�|D�
�
S)aS
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
3s|]}
t��
V
qdSrP)
rrk)
r=r9r:rSsz6random_combination_with_replacement.<locals>.<genexpr>c
3s|]}
�|
V
qdSrPr9rkrmr9r:rSs)rHrVrnr)r5r[ror9)r=rgr:r'�
s


c	Cs�t|�
}t
|�
}|
d
ks |
|kr$t�
d}t|
||
�}td|d�D]}|||||}qD|d
krn||7}|d
ks~||kr�t�
g}|
r�||
||d|
d}}}
||kr�||8}|||
||d}}q�|�|d|�

q�t|�
S)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.

    r
rU���)rHrV�
ValueError�minr�
IndexErrorr`)	r5r[�indexrgr=�
crcrl�resultr9r9r:r s(	









 



cCst|g
|
�S)
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`.

    )
r)�valuerAr9r9r:r%*s)
r
)
N)
N)
N)
N)
N)
N)
N)FN)
N):�__doc__�collectionsr�	itertoolsrrrrrrr	r
rrIZrandomrr
rZsixrZ	six.movesrrrrrr�__all__r_rr/r-r.rrr�boolr&r!rrrr+r"rr,r#r$r0r1rrr*r)r(r'r r%r9r9r9r:�<module>
s~	
,

 


























� 

(







(



$