OpenQuizz
Une application de gestion des contenus pédagogiques
setuptools._vendor.more_itertools.more Namespace Reference

Data Structures

class  AbortThread
 
class  bucket
 
class  callback_iter
 
class  countable
 
class  islice_extended
 
class  numeric_range
 
class  peekable
 
class  run_length
 
class  seekable
 
class  SequenceView
 
class  time_limited
 
class  UnequalIterablesError
 

Functions

def chunked (iterable, n, strict=False)
 
def first (iterable, default=_marker)
 
def last (iterable, default=_marker)
 
def nth_or_last (iterable, n, default=_marker)
 
def collate (*iterables, **kwargs)
 
def consumer (func)
 
def ilen (iterable)
 
def iterate (func, start)
 
def with_iter (context_manager)
 
def one (iterable, too_short=None, too_long=None)
 
def distinct_permutations (iterable, r=None)
 
def intersperse (e, iterable, n=1)
 
def unique_to_each (*iterables)
 
def windowed (seq, n, fillvalue=None, step=1)
 
def substrings (iterable)
 
def substrings_indexes (seq, reverse=False)
 
def spy (iterable, n=1)
 
def interleave (*iterables)
 
def interleave_longest (*iterables)
 
def collapse (iterable, base_type=None, levels=None)
 
def side_effect (func, iterable, chunk_size=None, before=None, after=None)
 
def sliced (seq, n, strict=False)
 
def split_at (iterable, pred, maxsplit=-1, keep_separator=False)
 
def split_before (iterable, pred, maxsplit=-1)
 
def split_after (iterable, pred, maxsplit=-1)
 
def split_when (iterable, pred, maxsplit=-1)
 
def split_into (iterable, sizes)
 
def padded (iterable, fillvalue=None, n=None, next_multiple=False)
 
def repeat_last (iterable, default=None)
 
def distribute (n, iterable)
 
def stagger (iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None)
 
def zip_equal (*iterables)
 
def zip_offset (*iterables, offsets, longest=False, fillvalue=None)
 
def sort_together (iterables, key_list=(0,), key=None, reverse=False)
 
def unzip (iterable)
 
def divide (n, iterable)
 
def always_iterable (obj, base_type=(str, bytes))
 
def adjacent (predicate, iterable, distance=1)
 
def groupby_transform (iterable, keyfunc=None, valuefunc=None, reducefunc=None)
 
def count_cycle (iterable, n=None)
 
def mark_ends (iterable)
 
def locate (iterable, pred=bool, window_size=None)
 
def lstrip (iterable, pred)
 
def rstrip (iterable, pred)
 
def strip (iterable, pred)
 
def always_reversible (iterable)
 
def consecutive_groups (iterable, ordering=lambda x:x)
 
def difference (iterable, func=sub, *initial=None)
 
def exactly_n (iterable, n, predicate=bool)
 
def circular_shifts (iterable)
 
def make_decorator (wrapping_func, result_index=0)
 
def map_reduce (iterable, keyfunc, valuefunc=None, reducefunc=None)
 
def rlocate (iterable, pred=bool, window_size=None)
 
def replace (iterable, pred, substitutes, count=None, window_size=1)
 
def partitions (iterable)
 
def set_partitions (iterable, k=None)
 
def only (iterable, default=None, too_long=None)
 
def ichunked (iterable, n)
 
def distinct_combinations (iterable, r)
 
def filter_except (validator, iterable, *exceptions)
 
def map_except (function, iterable, *exceptions)
 
def sample (iterable, k, weights=None)
 
def is_sorted (iterable, key=None, reverse=False)
 
def windowed_complete (iterable, n)
 
def all_unique (iterable, key=None)
 
def nth_product (index, *args)
 
def nth_permutation (iterable, r, index)
 
def value_chain (*args)
 
def product_index (element, *args)
 
def combination_index (element, iterable)
 
def permutation_index (element, iterable)
 

Function Documentation

◆ adjacent()

def setuptools._vendor.more_itertools.more.adjacent (   predicate,
  iterable,
  distance = 1 
)
Return 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.

◆ all_unique()

def setuptools._vendor.more_itertools.more.all_unique (   iterable,
  key = None 
)
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.

◆ always_iterable()

def setuptools._vendor.more_itertools.more.always_iterable (   obj,
  base_type = (str, bytes) 
)
If *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']

◆ always_reversible()

def setuptools._vendor.more_itertools.more.always_reversible (   iterable)
An extension of :func:`reversed` that supports all iterables, not
just those which implement the ``Reversible`` or ``Sequence`` protocols.

    >>> 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.

◆ chunked()

def setuptools._vendor.more_itertools.more.chunked (   iterable,
  n,
  strict = False 
)
Break *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.

◆ circular_shifts()

def setuptools._vendor.more_itertools.more.circular_shifts (   iterable)
Return 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)]

◆ collapse()

def setuptools._vendor.more_itertools.more.collapse (   iterable,
  base_type = None,
  levels = None 
)
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']]

◆ collate()

def setuptools._vendor.more_itertools.more.collate ( iterables,
**  kwargs 
)
Return a sorted merge of the items from each of several already-sorted
*iterables*.

    >>> list(collate('ACDZ', 'AZ', 'JKL'))
    ['A', 'A', 'C', 'D', 'J', 'K', 'L', 'Z', 'Z']

Works lazily, keeping only the next value from each iterable in memory. Use
:func:`collate` to, for example, perform a n-way mergesort of items that
don't fit in memory.

If a *key* function is specified, the iterables will be sorted according
to its result:

    >>> key = lambda s: int(s)  # Sort by numeric value, not by string
    >>> list(collate(['1', '10'], ['2', '11'], key=key))
    ['1', '2', '10', '11']


If the *iterables* are sorted in descending order, set *reverse* to
``True``:

    >>> list(collate([5, 3, 1], [4, 2, 0], reverse=True))
    [5, 4, 3, 2, 1, 0]

If the elements of the passed-in iterables are out of order, you might get
unexpected results.

On Python 3.5+, this function is an alias for :func:`heapq.merge`.

◆ combination_index()

def setuptools._vendor.more_itertools.more.combination_index (   element,
  iterable 
)
Equivalent 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*.

◆ consecutive_groups()

def setuptools._vendor.more_itertools.more.consecutive_groups (   iterable,
  ordering = lambda x: x 
)
Yield 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]]

◆ consumer()

def setuptools._vendor.more_itertools.more.consumer (   func)
Decorator 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.

◆ count_cycle()

def setuptools._vendor.more_itertools.more.count_cycle (   iterable,
  n = None 
)
Cycle 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')]

◆ difference()

def setuptools._vendor.more_itertools.more.difference (   iterable,
  func = sub,
initial = None 
)
This 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]

◆ distinct_combinations()

def setuptools._vendor.more_itertools.more.distinct_combinations (   iterable,
  r 
)
Yield 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.

◆ distinct_permutations()

def setuptools._vendor.more_itertools.more.distinct_permutations (   iterable,
  r = None 
)
Yield 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)]

◆ distribute()

def setuptools._vendor.more_itertools.more.distribute (   n,
  iterable 
)
Distribute 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`.

◆ divide()

def setuptools._vendor.more_itertools.more.divide (   n,
  iterable 
)
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 and may require
significant storage. If order is not important, see :func:`distribute`,
which does not first pull the iterable into memory.

◆ exactly_n()

def setuptools._vendor.more_itertools.more.exactly_n (   iterable,
  n,
  predicate = bool 
)
Return ``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.

◆ filter_except()

def setuptools._vendor.more_itertools.more.filter_except (   validator,
  iterable,
exceptions 
)
Yield 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.

◆ first()

def setuptools._vendor.more_itertools.more.first (   iterable,
  default = _marker 
)
Return 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)``.

◆ groupby_transform()

def setuptools._vendor.more_itertools.more.groupby_transform (   iterable,
  keyfunc = None,
  valuefunc = None,
  reducefunc = None 
)
An 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.

◆ ichunked()

def setuptools._vendor.more_itertools.more.ichunked (   iterable,
  n 
)
Break *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]

◆ ilen()

def setuptools._vendor.more_itertools.more.ilen (   iterable)
Return 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.

◆ interleave()

def setuptools._vendor.more_itertools.more.interleave ( iterables)
Return 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`.

◆ interleave_longest()

def setuptools._vendor.more_itertools.more.interleave_longest ( iterables)
Return 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).

◆ intersperse()

def setuptools._vendor.more_itertools.more.intersperse (   e,
  iterable,
  n = 1 
)
Intersperse 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]

◆ is_sorted()

def setuptools._vendor.more_itertools.more.is_sorted (   iterable,
  key = None,
  reverse = False 
)
Returns ``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

The function returns ``False`` after encountering the first out-of-order
item. If there are no out-of-order items, the iterable is exhausted.

◆ iterate()

def setuptools._vendor.more_itertools.more.iterate (   func,
  start 
)
Return ``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]

◆ last()

def setuptools._vendor.more_itertools.more.last (   iterable,
  default = _marker 
)
Return 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``.

◆ locate()

def setuptools._vendor.more_itertools.more.locate (   iterable,
  pred = bool,
  window_size = None 
)
Yield 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

◆ lstrip()

def setuptools._vendor.more_itertools.more.lstrip (   iterable,
  pred 
)
Yield 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`.

◆ make_decorator()

def setuptools._vendor.more_itertools.more.make_decorator (   wrapping_func,
  result_index = 0 
)
Return 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'

◆ map_except()

def setuptools._vendor.more_itertools.more.map_except (   function,
  iterable,
exceptions 
)
Transform 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 be a 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.

◆ map_reduce()

def setuptools._vendor.more_itertools.more.map_reduce (   iterable,
  keyfunc,
  valuefunc = None,
  reducefunc = None 
)
Return 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.

◆ mark_ends()

def setuptools._vendor.more_itertools.more.mark_ends (   iterable)
Yield 3-tuples of the form ``(is_first, is_last, item)``.

>>> 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

◆ nth_or_last()

def setuptools._vendor.more_itertools.more.nth_or_last (   iterable,
  n,
  default = _marker 
)
Return 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``.

◆ nth_permutation()

def setuptools._vendor.more_itertools.more.nth_permutation (   iterable,
  r,
  index 
)
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.

◆ nth_product()

def setuptools._vendor.more_itertools.more.nth_product (   index,
args 
)
Equivalent 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.

◆ one()

def setuptools._vendor.more_itertools.more.one (   iterable,
  too_short = None,
  too_long = None 
)
Return 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.

◆ only()

def setuptools._vendor.more_itertools.more.only (   iterable,
  default = None,
  too_long = None 
)
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.

◆ padded()

def setuptools._vendor.more_itertools.more.padded (   iterable,
  fillvalue = None,
  n = None,
  next_multiple = False 
)
Yield 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.

◆ partitions()

def setuptools._vendor.more_itertools.more.partitions (   iterable)
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`.

◆ permutation_index()

def setuptools._vendor.more_itertools.more.permutation_index (   element,
  iterable 
)
Equivalent 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*.

◆ product_index()

def setuptools._vendor.more_itertools.more.product_index (   element,
args 
)
Equivalent 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*.

◆ repeat_last()

def setuptools._vendor.more_itertools.more.repeat_last (   iterable,
  default = None 
)
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]

◆ replace()

def setuptools._vendor.more_itertools.more.replace (   iterable,
  pred,
  substitutes,
  count = None,
  window_size = 1 
)
Yield 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]

◆ rlocate()

def setuptools._vendor.more_itertools.more.rlocate (   iterable,
  pred = bool,
  window_size = None 
)
Yield 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.

◆ rstrip()

def setuptools._vendor.more_itertools.more.rstrip (   iterable,
  pred 
)
Yield 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`.

◆ sample()

def setuptools._vendor.more_itertools.more.sample (   iterable,
  k,
  weights = None 
)
Return 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']

◆ set_partitions()

def setuptools._vendor.more_itertools.more.set_partitions (   iterable,
  k = None 
)
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']

◆ side_effect()

def setuptools._vendor.more_itertools.more.side_effect (   func,
  iterable,
  chunk_size = None,
  before = None,
  after = None 
)
Invoke *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

◆ sliced()

def setuptools._vendor.more_itertools.more.sliced (   seq,
  n,
  strict = False 
)
Yield 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`.

◆ sort_together()

def setuptools._vendor.more_itertools.more.sort_together (   iterables,
  key_list = (0,),
  key = None,
  reverse = False 
)
Return 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')]

◆ split_after()

def setuptools._vendor.more_itertools.more.split_after (   iterable,
  pred,
  maxsplit = -1 
)
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]]

◆ split_at()

def setuptools._vendor.more_itertools.more.split_at (   iterable,
  pred,
  maxsplit = -1,
  keep_separator = False 
)
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.
The 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']]

◆ split_before()

def setuptools._vendor.more_itertools.more.split_before (   iterable,
  pred,
  maxsplit = -1 
)
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]]

◆ split_into()

def setuptools._vendor.more_itertools.more.split_into (   iterable,
  sizes 
)
Yield 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.

◆ split_when()

def setuptools._vendor.more_itertools.more.split_when (   iterable,
  pred,
  maxsplit = -1 
)
Split *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]]

◆ spy()

def setuptools._vendor.more_itertools.more.spy (   iterable,
  n = 1 
)
Return 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]

◆ stagger()

def setuptools._vendor.more_itertools.more.stagger (   iterable,
  offsets = (-1, 0, 1),
  longest = False,
  fillvalue = None 
)
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.

◆ strip()

def setuptools._vendor.more_itertools.more.strip (   iterable,
  pred 
)
Yield 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`.

◆ substrings()

def setuptools._vendor.more_itertools.more.substrings (   iterable)
Yield 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)]

◆ substrings_indexes()

def setuptools._vendor.more_itertools.more.substrings_indexes (   seq,
  reverse = False 
)
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.

◆ unique_to_each()

def setuptools._vendor.more_itertools.more.unique_to_each ( iterables)
Return 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.

◆ unzip()

def setuptools._vendor.more_itertools.more.unzip (   iterable)
The 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 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.

◆ value_chain()

def setuptools._vendor.more_itertools.more.value_chain ( args)
Yield 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']


Multiple levels of nesting are not flattened.

◆ windowed()

def setuptools._vendor.more_itertools.more.windowed (   seq,
  n,
  fillvalue = None,
  step = 1 
)
Return 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)]

◆ windowed_complete()

def setuptools._vendor.more_itertools.more.windowed_complete (   iterable,
  n 
)
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.

◆ with_iter()

def setuptools._vendor.more_itertools.more.with_iter (   context_manager)
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``.

◆ zip_equal()

def setuptools._vendor.more_itertools.more.zip_equal ( iterables)
``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

◆ zip_offset()

def setuptools._vendor.more_itertools.more.zip_offset ( iterables,
  offsets,
  longest = False,
  fillvalue = None 
)
``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.