开源软件构建与测试

_service:tar_scm:python-more-itertools.spec Changed

_service Changed

_service:tar_scm:more-itertools-8.12.0.tar.gz/.gitattributes Added

_service:tar_scm:more-itertools-8.12.0.tar.gz/.github Added

_service:tar_scm:more-itertools-8.12.0.tar.gz/.github/ISSUE_TEMPLATE Added

_service:tar_scm:more-itertools-8.12.0.tar.gz/.github/ISSUE_TEMPLATE/other-issues.md Added

_service:tar_scm:more-itertools-8.12.0.tar.gz/.github/ISSUE_TEMPLATE/propose-a-new-itertool.md Added

_service:tar_scm:more-itertools-8.12.0.tar.gz/.github/PULL_REQUEST_TEMPLATE.md Added

_service:tar_scm:more-itertools-8.12.0.tar.gz/.github/workflows Added

_service:tar_scm:more-itertools-8.12.0.tar.gz/.github/workflows/python-app.yml Added

@@ -0,0 +1,59 @@
+name: Python package
+
+on: push, pull_request
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: 3.6, 3.7, 3.8, 3.9.0, 3.10.0, pypy3
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .
+        pip install -U coverage flake8 wheel
+    - name: Run tests
+      run: |
+        coverage run --include="more_itertools/*.py" -m unittest
+    - name: Check coverage
+      run: |
+        coverage report --show-missing --fail-under=99
+    - name: Lint with flake8
+      run: |
+        flake8 .
+    - name: Check formatting with black
+      if: "matrix.python-version == '3.6'"
+      run: |
+        pip install -U black
+        black --check .
+    - name: Check type stubs with mypy
+      if: "matrix.python-version != 'pypy3'"
+      run: |
+        pip install -U mypy
+        stubtest more_itertools.more more_itertools.recipes
+    - name: Build docs with sphinx
+      if: "matrix.python-version == '3.6'"
+      run: |
+        pip install -U sphinx sphinx_rtd_theme
+        sphinx-build -W -b html docs docs/_build/html
+    - name: Build packages
+      if: "matrix.python-version == '3.6'"
+      run: |
+        pip install -U twine wheel
+        python setup.py sdist bdist_wheel
+        twine check dist/*
+    - name: Upload packages
+      if: "matrix.python-version == '3.6'"
+      uses: actions/upload-artifact@v2
+      with:
+        name: more-itertools-packages
+        path: dist/*

_service:tar_scm:more-itertools-8.12.0.tar.gz/.gitignore Added

_service:tar_scm:more-itertools-8.5.0.tar.gz/README.rst -> _service:tar_scm:more-itertools-8.12.0.tar.gz/README.rst Changed

@@ -10,114 +10,134 @@
 we collect additional building blocks, recipes, and routines for working with
 Python iterables.
 
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Grouping               | `chunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.chunked>`_,                                                                                                                        |
-|                        | `ichunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ichunked>`_,                                                                                                                      |
-|                        | `sliced <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sliced>`_,                                                                                                                          |
-|                        | `distribute <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distribute>`_,                                                                                                                  |
-|                        | `divide <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.divide>`_,                                                                                                                          |
-|                        | `split_at <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_at>`_,                                                                                                                      |
-|                        | `split_before <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_before>`_,                                                                                                              |
-|                        | `split_after <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_after>`_,                                                                                                                |
-|                        | `split_into <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_into>`_,                                                                                                                  |
-|                        | `split_when <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_when>`_,                                                                                                                  |
-|                        | `bucket <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.bucket>`_,                                                                                                                          |
-|                        | `unzip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unzip>`_,                                                                                                                            |
-|                        | `grouper <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.grouper>`_,                                                                                                                        |
-|                        | `partition <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partition>`_                                                                                                                     |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Lookahead and lookback | `spy <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.spy>`_,                                                                                                                                |
-|                        | `peekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.peekable>`_,                                                                                                                      |
-|                        | `seekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.seekable>`_                                                                                                                       |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Windowing              | `windowed <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.windowed>`_,                                                                                                                      |
-|                        | `substrings <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings>`_,                                                                                                                  |
-|                        | `substrings_indexes <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings_indexes>`_,                                                                                                  |
-|                        | `stagger <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.stagger>`_,                                                                                                                        |
-|                        | `pairwise <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.pairwise>`_                                                                                                                       |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Augmenting             | `count_cycle <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.count_cycle>`_,                                                                                                                |
-|                        | `intersperse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.intersperse>`_,                                                                                                                |
-|                        | `padded <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padded>`_,                                                                                                                          |
-|                        | `mark_ends <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.mark_ends>`_,                                                                                                                    |
-|                        | `repeat_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeat_last>`_,                                                                                                                |
-|                        | `adjacent <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.adjacent>`_,                                                                                                                      |
-|                        | `groupby_transform <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.groupby_transform>`_,                                                                                                    |
-|                        | `padnone <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padnone>`_,                                                                                                                        |
-|                        | `ncycles <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ncycles>`_                                                                                                                         |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Combining              | `collapse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.collapse>`_,                                                                                                                      |
-|                        | `sort_together <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sort_together>`_,                                                                                                            |
-|                        | `interleave <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave>`_,                                                                                                                  |
-|                        | `interleave_longest <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave_longest>`_,                                                                                                  |
-|                        | `zip_offset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_offset>`_,                                                                                                                  |
-|                        | `zip_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_equal>`_,                                                                                                                    |
-|                        | `dotproduct <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.dotproduct>`_,                                                                                                                  |
-|                        | `flatten <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.flatten>`_,                                                                                                                        |
-|                        | `roundrobin <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.roundrobin>`_,                                                                                                                  |
-|                        | `prepend <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.prepend>`_                                                                                                                         |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Summarizing            | `ilen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ilen>`_,                                                                                                                              |
-|                        | `unique_to_each <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_to_each>`_,                                                                                                          |
-|                        | `sample <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sample>`_,                                                                                                                          |
-|                        | `consecutive_groups <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consecutive_groups>`_,                                                                                                  |
-|                        | `run_length <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.run_length>`_,                                                                                                                  |
-|                        | `map_reduce <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_reduce>`_,                                                                                                                  |
-|                        | `exactly_n <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.exactly_n>`_,                                                                                                                    |
-|                        | `is_sorted <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.is_sorted>`_,                                                                                                                    |
-|                        | `all_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.all_equal>`_,                                                                                                                    |
-|                        | `first_true <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first_true>`_,                                                                                                                  |
-|                        | `quantify <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.quantify>`_                                                                                                                       |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Selecting              | `islice_extended <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.islice_extended>`_,                                                                                                        |
-|                        | `first <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first>`_,                                                                                                                            |
-|                        | `last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.last>`_,                                                                                                                              |
-|                        | `one <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.one>`_,                                                                                                                                |
-|                        | `only <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.only>`_,                                                                                                                              |
-|                        | `strip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.strip>`_,                                                                                                                            |
-|                        | `lstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.lstrip>`_,                                                                                                                          |
-|                        | `rstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rstrip>`_,                                                                                                                          |
-|                        | `filter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.filter_except>`_                                                                                                             |
-|                        | `map_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_except>`_                                                                                                                   |
-|                        | `nth_or_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_or_last>`_,                                                                                                                |
-|                        | `nth <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth>`_,                                                                                                                                |
-|                        | `take <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.take>`_,                                                                                                                              |
-|                        | `tail <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tail>`_,                                                                                                                              |
-|                        | `unique_everseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertoo ls.unique_everseen>`_,                                                                                                       |
-|                        | `unique_justseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_justseen>`_                                                                                                         |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Combinatorics          | `distinct_permutations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_permutations>`_,                                                                                            |
-|                        | `distinct_combinations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_combinations>`_,                                                                                            |
-|                        | `circular_shifts <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.circular_shifts>`_,                                                                                                        |
-|                        | `partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partitions>`_,                                                                                                                  |
-|                        | `set_partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.set_partitions>`_,                                                                                                          |
-|                        | `powerset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.powerset>`_,                                                                                                                      |
-|                        | `random_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_product>`_,                                                                                                          |
-|                        | `random_permutation <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_permutation>`_,                                                                                                  |
-|                        | `random_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination>`_,                                                                                                  |
-|                        | `random_combination_with_replacement <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination_with_replacement>`_,                                                                |
-|                        | `nth_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_combination>`_                                                                                                         |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Wrapping               | `always_iterable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_iterable>`_,                                                                                                        |
-|                        | `always_reversible <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_reversible>`_,                                                                                                    |
-|                        | `consumer <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consumer>`_,                                                                                                                      |
-|                        | `with_iter <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.with_iter>`_,                                                                                                                    |
-|                        | `iter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iter_except>`_                                                                                                                 |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| Others                 | `locate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.locate>`_,                                                                                                                          |
-|                        | `rlocate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rlocate>`_,                                                                                                                        |
-|                        | `replace <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.replace>`_,                                                                                                                        |
-|                        | `numeric_range <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.numeric_range>`_,                                                                                                            |
-|                        | `side_effect <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.side_effect>`_,                                                                                                                |
-|                        | `iterate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iterate>`_,                                                                                                                        |
-|                        | `difference <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.difference>`_,                                                                                                                  |
-|                        | `make_decorator <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.make_decorator>`_,                                                                                                          |
-|                        | `SequenceView <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.SequenceView>`_,                                                                                                              |
-|                        | `time_limited <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.time_limited>`_,                                                                                                              |
-|                        | `consume <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consume>`_,                                                                                                                        |
-|                        | `tabulate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tabulate>`_,                                                                                                                      |
-|                        | `repeatfunc <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeatfunc>`_                                                                                                                   |
-+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Grouping               | `chunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.chunked>`_,                                                                               |
+|                        | `ichunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ichunked>`_,                                                                             |
+|                        | `sliced <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sliced>`_,                                                                                 |
+|                        | `distribute <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distribute>`_,                                                                         |
+|                        | `divide <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.divide>`_,                                                                                 |
+|                        | `split_at <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_at>`_,                                                                             |
+|                        | `split_before <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_before>`_,                                                                     |
+|                        | `split_after <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_after>`_,                                                                       |
+|                        | `split_into <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_into>`_,                                                                         |
+|                        | `split_when <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_when>`_,                                                                         |
+|                        | `bucket <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.bucket>`_,                                                                                 |
+|                        | `unzip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unzip>`_,                                                                                   |
+|                        | `grouper <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.grouper>`_,                                                                               |
+|                        | `partition <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partition>`_                                                                            |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Lookahead and lookback | `spy <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.spy>`_,                                                                                       |
+|                        | `peekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.peekable>`_,                                                                             |
+|                        | `seekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.seekable>`_                                                                              |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Windowing              | `windowed <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.windowed>`_,                                                                             |
+|                        | `substrings <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings>`_,                                                                         |
+|                        | `substrings_indexes <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings_indexes>`_,                                                         |
+|                        | `stagger <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.stagger>`_,                                                                               |
+|                        | `windowed_complete <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.windowed_complete>`_,                                                           |
+|                        | `pairwise <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.pairwise>`_,                                                                             |
+|                        | `triplewise <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.triplewise>`_,                                                                         |
+|                        | `sliding_window <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sliding_window>`_                                                                  |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Augmenting             | `count_cycle <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.count_cycle>`_,                                                                       |
+|                        | `intersperse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.intersperse>`_,                                                                       |
+|                        | `padded <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padded>`_,                                                                                 |
+|                        | `mark_ends <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.mark_ends>`_,                                                                           |
+|                        | `repeat_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeat_last>`_,                                                                       |
+|                        | `adjacent <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.adjacent>`_,                                                                             |
+|                        | `groupby_transform <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.groupby_transform>`_,                                                           |
+|                        | `pad_none <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.pad_none>`_,                                                                             |
+|                        | `ncycles <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ncycles>`_                                                                                |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Combining              | `collapse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.collapse>`_,                                                                             |
+|                        | `sort_together <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sort_together>`_,                                                                   |
+|                        | `interleave <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave>`_,                                                                         |
+|                        | `interleave_longest <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave_longest>`_,                                                         |
+|                        | `interleave_evenly <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave_evenly>`_,                                                           |
+|                        | `zip_offset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_offset>`_,                                                                         |
+|                        | `zip_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_equal>`_,                                                                           |
+|                        | `zip_broadcast <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_broadcast>`_,                                                                   |
+|                        | `dotproduct <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.dotproduct>`_,                                                                         |
+|                        | `convolve <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.convolve>`_,                                                                             |
+|                        | `flatten <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.flatten>`_,                                                                               |
+|                        | `roundrobin <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.roundrobin>`_,                                                                         |
+|                        | `prepend <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.prepend>`_,                                                                               |
+|                        | `value_chain <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.value_chain>`_                                                                        |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Summarizing            | `ilen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ilen>`_,                                                                                     |
+|                        | `unique_to_each <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_to_each>`_,                                                                 |
+|                        | `sample <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sample>`_,                                                                                 |
+|                        | `consecutive_groups <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consecutive_groups>`_,                                                         |
+|                        | `run_length <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.run_length>`_,                                                                         |
+|                        | `map_reduce <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_reduce>`_,                                                                         |
+|                        | `exactly_n <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.exactly_n>`_,                                                                           |
+|                        | `is_sorted <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.is_sorted>`_,                                                                           |
+|                        | `all_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.all_equal>`_,                                                                           |
+|                        | `all_unique <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.all_unique>`_,                                                                         |
+|                        | `minmax <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.minmax>`_,                                                                                 |
+|                        | `first_true <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first_true>`_,                                                                         |
+|                        | `quantify <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.quantify>`_                                                                              |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Selecting              | `islice_extended <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.islice_extended>`_,                                                               |
+|                        | `first <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first>`_,                                                                                   |
+|                        | `last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.last>`_,                                                                                     |
+|                        | `one <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.one>`_,                                                                                       |
+|                        | `only <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.only>`_,                                                                                     |
+|                        | `strictly_n <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.strictly_n>`_,                                                                         |
+|                        | `strip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.strip>`_,                                                                                   |
+|                        | `lstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.lstrip>`_,                                                                                 |
+|                        | `rstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rstrip>`_,                                                                                 |
+|                        | `filter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.filter_except>`_,                                                                   |
+|                        | `map_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_except>`_,                                                                         |
+|                        | `nth_or_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_or_last>`_,                                                                       |
+|                        | `unique_in_window <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_in_window>`_,                                                             |
+|                        | `before_and_after <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.before_and_after>`_,                                                             |
+|                        | `nth <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth>`_,                                                                                       |
+|                        | `take <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.take>`_,                                                                                     |
+|                        | `tail <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tail>`_,                                                                                     |
+|                        | `unique_everseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertoo ls.unique_everseen>`_,                                                              |
+|                        | `unique_justseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_justseen>`_,                                                               |
+|                        | `duplicates_everseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.duplicates_everseen>`_,                                                       |
+|                        | `duplicates_justseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.duplicates_justseen>`_                                                        |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Combinatorics          | `distinct_permutations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_permutations>`_,                                                   |
+|                        | `distinct_combinations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_combinations>`_,                                                   |
+|                        | `circular_shifts <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.circular_shifts>`_,                                                               |
+|                        | `partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partitions>`_,                                                                         |
+|                        | `set_partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.set_partitions>`_,                                                                 |
+|                        | `product_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.product_index>`_,                                                                   |
+|                        | `combination_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.combination_index>`_,                                                           |
+|                        | `permutation_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.permutation_index>`_,                                                           |
+|                        | `powerset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.powerset>`_,                                                                             |
+|                        | `random_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_product>`_,                                                                 |
+|                        | `random_permutation <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_permutation>`_,                                                         |
+|                        | `random_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination>`_,                                                         |
+|                        | `random_combination_with_replacement <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination_with_replacement>`_,                       |
+|                        | `nth_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_product>`_,                                                                       |
+|                        | `nth_permutation <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_permutation>`_,                                                               |
+|                        | `nth_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_combination>`_                                                                |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Wrapping               | `always_iterable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_iterable>`_,                                                               |
+|                        | `always_reversible <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_reversible>`_,                                                           |
+|                        | `countable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.countable>`_,                                                                           |
+|                        | `consumer <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consumer>`_,                                                                             |
+|                        | `with_iter <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.with_iter>`_,                                                                           |
+|                        | `iter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iter_except>`_                                                                        |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Others                 | `locate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.locate>`_,                                                                                 |
+|                        | `rlocate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rlocate>`_,                                                                               |
+|                        | `replace <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.replace>`_,                                                                               |
+|                        | `numeric_range <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.numeric_range>`_,                                                                   |
+|                        | `side_effect <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.side_effect>`_,                                                                       |
+|                        | `iterate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iterate>`_,                                                                               |
+|                        | `difference <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.difference>`_,                                                                         |
+|                        | `make_decorator <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.make_decorator>`_,                                                                 |
+|                        | `SequenceView <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.SequenceView>`_,                                                                     |
+|                        | `time_limited <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.time_limited>`_,                                                                     |
+|                        | `consume <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consume>`_,                                                                               |
+|                        | `tabulate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tabulate>`_,                                                                             |
+|                        | `repeatfunc <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeatfunc>`_                                                                          |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 
 Getting started
@@ -167,7 +187,8 @@
 Blog posts about ``more-itertools``:
 
 * `Yo, I heard you like decorators <https://www.bbayles.com/index/decorator_factory>`__
-* `Tour of Python Itertools <https://martinheinz.dev/blog/16>`__
+* `Tour of Python Itertools <https://martinheinz.dev/blog/16>`__ (`Alternate <https://dev.to/martinheinz/tour-of-python-itertools-4122>`__)
+* `Real-World Python More Itertools <https://www.gidware.com/real-world-more-itertools/>`_
 
 
 Development

_service:tar_scm:more-itertools-8.5.0.tar.gz/docs/api.rst -> _service:tar_scm:more-itertools-8.12.0.tar.gz/docs/api.rst Changed

@@ -15,6 +15,7 @@
 
 .. autofunction:: chunked
 .. autofunction:: ichunked
+.. autofunction:: chunked_even
 .. autofunction:: sliced
 .. autofunction:: distribute
 .. autofunction:: divide
@@ -69,6 +70,8 @@
 **Itertools recipes**
 
 .. autofunction:: pairwise
+.. autofunction:: triplewise
+.. autofunction:: sliding_window
 
 
 Augmenting
@@ -84,6 +87,7 @@
 .. autofunction:: intersperse
 .. autofunction:: padded
 .. autofunction:: mark_ends
+.. autofunction:: repeat_each
 .. autofunction:: repeat_last
 .. autofunction:: adjacent
 .. autofunction:: groupby_transform
@@ -92,10 +96,11 @@
 
 **Itertools recipes**
 
-.. autofunction:: padnone
+.. function:: padnone
+  :noindex:
+.. autofunction:: pad_none
 .. autofunction:: ncycles
 
-
 Combining
 =========
 
@@ -106,17 +111,21 @@
 **New itertools**
 
 .. autofunction:: collapse
-.. autofunction:: sort_together
 .. autofunction:: interleave
 .. autofunction:: interleave_longest
+.. autofunction:: interleave_evenly
+.. autofunction:: sort_together
+.. autofunction:: value_chain
 .. autofunction:: zip_offset(*iterables, offsets, longest=False, fillvalue=None)
 .. autofunction:: zip_equal
+.. autofunction:: zip_broadcast(*objects, scalar_types=(str, bytes), strict=False)
 
 ----
 
 **Itertools recipes**
 
 .. autofunction:: dotproduct
+.. autofunction:: convolve
 .. autofunction:: flatten
 .. autofunction:: roundrobin
 .. autofunction:: prepend
@@ -139,6 +148,10 @@
 .. autofunction:: map_reduce
 .. autofunction:: exactly_n(iterable, n, predicate=bool)
 .. autofunction:: is_sorted
+.. autofunction:: all_unique
+.. function:: minmax(iterable, *, key, default)
+.. autofunction:: minmax(arg1, arg2, *args, key)
+  :noindex:
 
 ----
 
@@ -166,18 +179,23 @@
 .. autofunction:: last(iterable, default)
 .. autofunction:: one(iterable, too_short=ValueError, too_long=ValueError)
 .. autofunction:: only(iterable, default=None, too_long=ValueError)
+.. autofunction:: strictly_n(iterable, too_short=None, too_long=None)
 .. autofunction:: strip
 .. autofunction:: lstrip
 .. autofunction:: rstrip
 .. autofunction:: filter_except
 .. autofunction:: map_except
 .. autofunction:: nth_or_last(iterable, n, default)
+.. autofunction:: unique_in_window
+.. autofunction:: duplicates_everseen
+.. autofunction:: duplicates_justseen
 
 ----
 
 **Itertools recipes**
 
 .. autofunction:: nth
+.. autofunction:: before_and_after
 .. autofunction:: take
 .. autofunction:: tail
 .. autofunction:: unique_everseen
@@ -198,6 +216,9 @@
 .. autofunction:: circular_shifts
 .. autofunction:: partitions
 .. autofunction:: set_partitions
+.. autofunction:: product_index
+.. autofunction:: combination_index
+.. autofunction:: permutation_index
 
 ----
 
@@ -208,6 +229,8 @@
 .. autofunction:: random_permutation
 .. autofunction:: random_combination
 .. autofunction:: random_combination_with_replacement
+.. autofunction:: nth_product
+.. autofunction:: nth_permutation
 .. autofunction:: nth_combination
 
 
@@ -223,6 +246,7 @@
 
 .. autofunction:: always_iterable
 .. autofunction:: always_reversible
+.. autofunction:: countable
 .. autofunction:: consumer
 .. autofunction:: with_iter
 .. autoclass:: callback_iter
@@ -251,6 +275,7 @@
 .. autofunction:: make_decorator
 .. autoclass:: SequenceView
 .. autofunction:: time_limited
+.. autofunction:: map_if(iterable, pred, func, func_else=lambda x: x)
 
 ----

_service:tar_scm:more-itertools-8.5.0.tar.gz/docs/conf.py -> _service:tar_scm:more-itertools-8.12.0.tar.gz/docs/conf.py Changed

@@ -14,13 +14,37 @@
 
 import sphinx_rtd_theme
 
-import more_itertools
-
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 sys.path.insert(0, os.path.abspath('..'))
 
+import more_itertools
+
+# -- Preprocess README.rst -----------------------------------------------------
+# We include README.rst from the root directory. It has absolute links
+# to readthedocs.io for display on github.com, but those links can be
+# relative when being built for Sphinx.
+
+with open('../README.rst', 'rt') as source:
+    readme_file = source.readlines()
+
+build_dir = '_build'
+os.makedirs(build_dir, exist_ok=True)
+
+rtd_path = 'https://more-itertools.readthedocs.io/en/stable/'
+table_width = 200
+in_table = False
+with open(os.path.join('.', build_dir, 'README.pprst'), 'wt') as target:
+    for line in readme_file:
+        old_len = len(line)
+        if line.startswith('|') and line.endswith('|\n'):  # Inside table
+            line = line.replace(rtd_path, '').rstrip(' |\n')
+            spaces = ' ' * (table_width - len(line) - 1)
+            line = f'{line}{spaces}|\n'
+
+        target.write(line)
+
 # -- General configuration -----------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
@@ -67,7 +91,7 @@
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = '_build'
+exclude_patterns = build_dir
 
 # The reST default role (used for this markup: `text`) to use for all documents.
 # default_role = None

_service:tar_scm:more-itertools-8.5.0.tar.gz/docs/index.rst -> _service:tar_scm:more-itertools-8.12.0.tar.gz/docs/index.rst Changed

_service:tar_scm:more-itertools-8.12.0.tar.gz/docs/requirements.txt Added

_service:tar_scm:more-itertools-8.5.0.tar.gz/docs/versions.rst -> _service:tar_scm:more-itertools-8.12.0.tar.gz/docs/versions.rst Changed

@@ -5,9 +5,101 @@
 .. automodule:: more_itertools
    :noindex:
 
-8.5.0
+8.12.0
+------
+
+* Bug fixes
+    * Some documentation issues were fixed (thanks to Masynchin, spookylukey, astrojuanlu, and stephengmatthews)
+    * Python 3.5 support was temporarily restored (thanks to mattbonnell)
+
+8.11.0
+------
+
+* New functions
+    * The :func:`before_and_after`, :func:`sliding_window`, and :func:`triplewise` recipes from the Python 3.10 docs were added
+    * :func:`duplicates_everseen` and :func:`duplicates_justseen` (thanks to OrBin and DavidPratt512)
+    * :func:`minmax` (thanks to Ricocotam, MSeifert04, and ruancomelli)
+    * :func:`strictly_n` (thanks to hwalinga and NotWearingPants)
+    * :func:`unique_in_window`
+
+* Changes to existing functions
+    * :func:`groupby_transform` had its type stub improved (thanks to mjk4 and ruancomelli)
+    * :func:`is_sorted` now accepts a ``strict`` parameter (thanks to Dutcho and ruancomelli)
+    * :func:`zip_broadcast` was updated to fix a bug (thanks to kalekundert)
+
+8.10.0
+------
+
+* Changes to existing functions
+    * The type stub for :func:`iter_except` was improved (thanks to  MarcinKonowalczyk)
+
+* Other changes:
+    *  Type stubs now ship with the source release (thanks to saaketp)
+    *  The Sphinx docs were improved (thanks to MarcinKonowalczyk)
+
+8.9.0
+-----
+
+* New functions
+    * :func:`interleave_evenly` (thanks to mbugert)
+    * :func:`repeat_each` (thanks to FinalSh4re)
+    * :func:`chunked_even` (thanks to valtron)
+    * :func:`map_if` (thanks to sassbalint)
+    * :func:`zip_broadcast` (thanks to kalekundert)
+
+* Changes to existing functions
+    * The type stub for :func:`chunked` was improved (thanks to  PhilMacKay)
+    * The type stubs for :func:`zip_equal` and `zip_offset` were improved (thanks to maffoo)
+    * Building Sphinx docs locally was improved (thanks to MarcinKonowalczyk)
+
+8.8.0
+-----
+
+* New functions
+    * :func:`countable` (thanks to krzysieq)
+
+* Changes to existing functions
+    * :func:`split_before` was updated to handle empy collections (thanks to TiunovNN)
+    * :func:`unique_everseen` got a performance boost (thanks to Numerlor)
+    * The type hint for :func:`value_chain` was corrected (thanks to vr2262)
+
+8.7.0
+-----
+
+* New functions
+    * :func:`convolve` (from the Python itertools docs)
+    * :func:`product_index`, :func:`combination_index`, and :func:`permutation_index` (thanks to N8Brooks)
+    * :func:`value_chain` (thanks to jenstroeger)
+
+* Changes to existing functions
+    * :func:`distinct_combinations` now uses a non-recursive algorithm (thanks to  knutdrand)
+    * :func:`pad_none` is now the preferred name for :func:`padnone`, though the latter remains available.
+    * :func:`pairwise` will now use the Python standard library implementation on Python 3.10+
+    * :func:`sort_together` now accepts a ``key`` argument (thanks to brianmaissy)
+    * :func:`seekable` now has a ``peek`` method, and can indicate whether the iterator it's wrapping is exhausted (thanks to gsakkis)
+    * :func:`time_limited` can now indicate whether its iterator has expired (thanks to roysmith)
+    * The implementation of :func:`unique_everseen` was improved (thanks to plammens)
+
+* Other changes:
+    * Various documentation updates (thanks to cthoyt, Evantm, and cyphase)
+
+8.6.0
 -----
 
+* New itertools
+    * :func:`all_unique` (thanks to brianmaissy)
+    * :func:`nth_product` and :func:`nth_permutation` (thanks to N8Brooks)
+
+* Changes to existing itertools
+    * :func:`chunked` and :func:`sliced` now accept a ``strict`` parameter (thanks to shlomif and jtwool)
+
+* Other changes
+    * Python 3.5 has reached its end of life and is no longer supported.
+    * Python 3.9 is officially supported.
+    * Various documentation fixes (thanks to timgates42)
+
+8.5.0
+-----
 
 * New itertools
     * :func:`windowed_complete` (thanks to MarcinKonowalczyk)
@@ -61,7 +153,7 @@
     * The :func:`spy` implementation was improved (thanks to has2k1)
 
 * Other changes
-    * Type stubs are now tested with ``stubtest`` (thankjs to ilai-deutel)
+    * Type stubs are now tested with ``stubtest`` (thanks to ilai-deutel)
     * Tests now run with ``python -m unittest`` instead of ``python setup.py test`` (thanks to jdufresne)
 
 8.2.0

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools/__init__.py -> _service:tar_scm:more-itertools-8.12.0.tar.gz/more_itertools/__init__.py Changed

_service:tar_scm:more-itertools-8.12.0.tar.gz/more_itertools/__init__.pyi Added

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools/more.py -> _service:tar_scm:more-itertools-8.12.0.tar.gz/more_itertools/more.py Changed

@@ -3,7 +3,7 @@
 from collections import Counter, defaultdict, deque, abc
 from collections.abc import Sequence
 from concurrent.futures import ThreadPoolExecutor
-from functools import partial, wraps
+from functools import partial, reduce, wraps
 from heapq import merge, heapify, heapreplace, heappop
 from itertools import (
     chain,
@@ -19,10 +19,10 @@
     tee,
     zip_longest,
 )
-from math import exp, floor, log
+from math import exp, factorial, floor, log
 from queue import Empty, Queue
 from random import random, randrange, uniform
-from operator import itemgetter, sub, gt, lt
+from operator import itemgetter, mul, sub, gt, lt, ge, le
 from sys import hexversion, maxsize
 from time import monotonic
 
@@ -37,50 +37,66 @@
 
 __all__ = 
     'AbortThread',
+    'SequenceView',
+    'UnequalIterablesError',
     'adjacent',
+    'all_unique',
     'always_iterable',
     'always_reversible',
     'bucket',
     'callback_iter',
     'chunked',
+    'chunked_even',
     'circular_shifts',
     'collapse',
     'collate',
+    'combination_index',
     'consecutive_groups',
     'consumer',
     'count_cycle',
-    'mark_ends',
+    'countable',
     'difference',
     'distinct_combinations',
     'distinct_permutations',
     'distribute',
     'divide',
+    'duplicates_everseen',
+    'duplicates_justseen',
     'exactly_n',
     'filter_except',
     'first',
     'groupby_transform',
+    'ichunked',
     'ilen',
-    'interleave_longest',
     'interleave',
+    'interleave_evenly',
+    'interleave_longest',
     'intersperse',
+    'is_sorted',
     'islice_extended',
     'iterate',
-    'ichunked',
-    'is_sorted',
     'last',
     'locate',
     'lstrip',
     'make_decorator',
     'map_except',
+    'map_if',
     'map_reduce',
+    'mark_ends',
+    'minmax',
     'nth_or_last',
+    'nth_permutation',
+    'nth_product',
     'numeric_range',
     'one',
     'only',
     'padded',
     'partitions',
-    'set_partitions',
     'peekable',
+    'permutation_index',
+    'product_index',
+    'raise_',
+    'repeat_each',
     'repeat_last',
     'replace',
     'rlocate',
@@ -88,56 +104,71 @@
     'run_length',
     'sample',
     'seekable',
-    'SequenceView',
+    'set_partitions',
     'side_effect',
     'sliced',
     'sort_together',
-    'split_at',
     'split_after',
+    'split_at',
     'split_before',
-    'split_when',
     'split_into',
+    'split_when',
     'spy',
     'stagger',
     'strip',
+    'strictly_n',
     'substrings',
     'substrings_indexes',
     'time_limited',
+    'unique_in_window',
     'unique_to_each',
     'unzip',
+    'value_chain',
     'windowed',
+    'windowed_complete',
     'with_iter',
-    'UnequalIterablesError',
+    'zip_broadcast',
     'zip_equal',
     'zip_offset',
-    'windowed_complete',
 
 
+
 _marker = object()
 
 
-def chunked(iterable, n):
+def 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
 
-    If the length of *iterable* is not evenly divisible by *n*, the last
-    returned list will be shorter:
+    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.
 
-    :func:`chunked` is useful for splitting up a computation on a large number
-    of keys into batches, to be pickled and sent off to worker processes. One
-    example is operations on rows in MySQL, which does not implement
-    server-side cursors properly and would otherwise load the entire dataset
-    into RAM on the client.
+    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.
+
+    """
+    iterator = iter(partial(take, n, iter(iterable)), )
+    if strict:
+        if n is None:
+            raise ValueError('n must not be None when using strict mode.')
+
+        def ret():
+            for chunk in iterator:
+                if len(chunk) != n:
+                    raise ValueError('iterable is not divisible by n.')
+                yield chunk
 
-    """
-    return iter(partial(take, n, iter(iterable)), )
+        return iter(ret())
+    else:
+        return iterator
 
 
 def first(iterable, default=_marker):
@@ -561,6 +592,84 @@
     return first_value
 
 
+def raise_(exception, *args):
+    raise exception(*args)
+
+
+def strictly_n(iterable, n, too_short=None, too_long=None):
+    """Validate that *iterable* has exactly *n* items and return them if
+    it does. If it has fewer than *n* items, call function *too_short*
+    with those items. If it has more than *n* items, call function
+    *too_long* with the first ``n + 1`` items.
+
+        >>> iterable = 'a', 'b', 'c', 'd'
+        >>> n = 4
+        >>> list(strictly_n(iterable, n))
+        'a', 'b', 'c', 'd'
+
+    By default, *too_short* and *too_long* are functions that raise
+    ``ValueError``.
+
+        >>> list(strictly_n('ab', 3))  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        ValueError: too few items in iterable (got 2)
+
+        >>> list(strictly_n('abc', 2))  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        ValueError: too many items in iterable (got at least 3)
+
+    You can instead supply functions that do something else.
+    *too_short* will be called with the number of items in *iterable*.
+    *too_long* will be called with `n + 1`.
+
+        >>> def too_short(item_count):
+        ...     raise RuntimeError
+        >>> it = strictly_n('abcd', 6, too_short=too_short)
+        >>> list(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        RuntimeError
+
+        >>> def too_long(item_count):
+        ...     print('The boss is going to hear about this')
+        >>> it = strictly_n('abcdef', 4, too_long=too_long)
+        >>> list(it)
+        The boss is going to hear about this
+        'a', 'b', 'c', 'd'
+
+    """
+    if too_short is None:
+        too_short = lambda item_count: raise_(
+            ValueError,
+            'Too few items in iterable (got {})'.format(item_count),
+        )
+
+    if too_long is None:
+        too_long = lambda item_count: raise_(
+            ValueError,
+            'Too many items in iterable (got at least {})'.format(item_count),
+        )
+
+    it = iter(iterable)
+    for i in range(n):
+        try:
+            item = next(it)
+        except StopIteration:
+            too_short(i)
+            return
+        else:
+            yield item
+
+    try:
+        next(it)
+    except StopIteration:
+        pass
+    else:
+        too_long(n + 1)
+
+
 def distinct_permutations(iterable, r=None):
     """Yield successive distinct permutations of the elements in *iterable*.
 
@@ -675,8 +784,8 @@
     if n == 0:
         raise ValueError('n must be > 0')
     elif n == 1:
-        # interleave(repeat(e), iterable) -> e, x_0, e, e, x_1, e, x_2...
-        # islice(..., 1, None) -> x_0, e, e, x_1, e, x_2...
+        # interleave(repeat(e), iterable) -> e, x_0, e, x_1, e, x_2...
+        # islice(..., 1, None) -> x_0, e, x_1, e, x_2...
         return islice(interleave(repeat(e), iterable), 1, None)
     else:
         # interleave(filler, chunks) -> e, x_0, x_1, e, x_2, x_3...
@@ -1000,6 +1109,72 @@
     return (x for x in i if x is not _marker)
 
 
+def interleave_evenly(iterables, lengths=None):
+    """
+    Interleave multiple iterables so that their elements are evenly distributed
+    throughout the output sequence.
+
+    >>> iterables = 1, 2, 3, 4, 5, 'a', 'b'
+    >>> list(interleave_evenly(iterables))
+    1, 2, 'a', 3, 4, 'b', 5
+
+    >>> iterables = 1, 2, 3, 4, 5, 6, 7, 8
+    >>> list(interleave_evenly(iterables))
+    1, 6, 4, 2, 7, 3, 8, 5
+
+    This function requires iterables of known length. Iterables without
+    ``__len__()`` can be used by manually specifying lengths with *lengths*:
+
+    >>> from itertools import combinations, repeat
+    >>> iterables = combinations(range(4), 2), 'a', 'b', 'c'
+    >>> lengths = 4 * (4 - 1) // 2, 3
+    >>> list(interleave_evenly(iterables, lengths=lengths))
+    (0, 1), (0, 2), 'a', (0, 3), (1, 2), 'b', (1, 3), (2, 3), 'c'
+
+    Based on Bresenham's algorithm.
+    """
+    if lengths is None:
+        try:
+            lengths = len(it) for it in iterables
+        except TypeError:
+            raise ValueError(
+                'Iterable lengths could not be determined automatically. '
+                'Specify them with the lengths keyword.'
+            )
+    elif len(iterables) != len(lengths):
+        raise ValueError('Mismatching number of iterables and lengths.')
+
+    dims = len(lengths)
+
+    # sort iterables by length, descending
+    lengths_permute = sorted(
+        range(dims), key=lambda i: lengthsi, reverse=True
+    )
+    lengths_desc = lengthsi for i in lengths_permute
+    iters_desc = iter(iterablesi) for i in lengths_permute
+
+    # the longest iterable is the primary one (Bresenham: the longest
+    # distance along an axis)
+    delta_primary, deltas_secondary = lengths_desc0, lengths_desc1:
+    iter_primary, iters_secondary = iters_desc0, iters_desc1:
+    errors = delta_primary // dims * len(deltas_secondary)
+
+    to_yield = sum(lengths)
+    while to_yield:
+        yield next(iter_primary)
+        to_yield -= 1
+        # update errors for each secondary iterable
+        errors = e - delta for e, delta in zip(errors, deltas_secondary)
+
+        # those iterables for which the error is negative are yielded
+        # ("diagonal step" in Bresenham)
+        for i, e in enumerate(errors):
+            if e < 0:
+                yield next(iters_secondaryi)
+                to_yield -= 1
+                errorsi += delta_primary
+
+
 def 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.
@@ -1109,23 +1284,38 @@
             after()
 
 
-def sliced(seq, n):
+def 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)
+    >>> list(sliced((1, 2, 3, 4, 5, 6), 3))
+    (1, 2, 3), (4, 5, 6)
 
-    If the length of the sequence is not divisible by the requested slice
-    length, the last slice will be shorter.
+    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)
+    >>> 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`.
 
     """
-    return takewhile(len, (seqi : i + n for i in count(0, n)))
+    iterator = takewhile(len, (seqi : i + n for i in count(0, n)))
+    if strict:
+
+        def ret():
+            for _slice in iterator:
+                if len(_slice) != n:
+                    raise ValueError("seq is not divisible by n.")
+                yield _slice
+
+        return iter(ret())
+    else:
+        return iterator
 
 
 def split_at(iterable, pred, maxsplit=-1, keep_separator=False):
@@ -1203,7 +1393,8 @@
             buf = 
             maxsplit -= 1
         buf.append(item)
-    yield buf
+    if buf:
+        yield buf
 
 
 def split_after(iterable, pred, maxsplit=-1):
@@ -1364,6 +1555,15 @@
             yield fillvalue
 
 
+def repeat_each(iterable, n=2):
+    """Repeat each element in *iterable* *n* times.
+
+    >>> list(repeat_each('ABC', 3))
+    'A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C'
+    """
+    return chain.from_iterable(map(repeat, iterable, repeat(n)))
+
+
 def repeat_last(iterable, default=None):
     """After the *iterable* is exhausted, keep yielding its last element.
 
@@ -1457,24 +1657,15 @@
         super().__init__(msg)
 
 
-def 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')
+def _zip_equal_generator(iterables):
+    for combo in zip_longest(*iterables, fillvalue=_marker):
+        for val in combo:
+            if val is _marker:
+                raise UnequalIterablesError()
+        yield combo
 
-        >>> 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
 
-    """
+def _zip_equal(*iterables):
     # Check whether the iterables are all the same size.
     try:
         first_size = len(iterables0)
@@ -1494,12 +1685,35 @@
         return _zip_equal_generator(iterables)
 
 
-def _zip_equal_generator(iterables):
-    for combo in zip_longest(*iterables, fillvalue=_marker):
-        for val in combo:
-            if val is _marker:
-                raise UnequalIterablesError()
-        yield combo
+def 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
+
+    """
+    if hexversion >= 0x30A00A6:
+        warnings.warn(
+            (
+                'zip_equal will be removed in a future version of '
+                'more-itertools. Use the builtin zip function with '
+                'strict=True instead.'
+            ),
+            DeprecationWarning,
+        )
+
+    return _zip_equal(*iterables)
 
 
 def zip_offset(*iterables, offsets, longest=False, fillvalue=None):
@@ -1541,7 +1755,7 @@
     return zip(*staggered)
 
 
-def sort_together(iterables, key_list=(0,), reverse=False):
+def 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.
@@ -1563,18 +1777,47 @@
         >>> 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')
 
     """
-    return list(
-        zip(
-            *sorted(
-                zip(*iterables), key=itemgetter(*key_list), reverse=reverse
+    if key is None:
+        # if there is no key function, the key argument to sorted is an
+        # itemgetter
+        key_argument = itemgetter(*key_list)
+    else:
+        # if there is a key function, call it with the items at the offsets
+        # specified by the key function as arguments
+        key_list = list(key_list)
+        if len(key_list) == 1:
+            # if key_list contains a single item, pass the item at that offset
+            # as the only argument to the key function
+            key_offset = key_list0
+            key_argument = lambda zipped_items: key(zipped_itemskey_offset)
+        else:
+            # if key_list contains multiple items, use itemgetter to return a
+            # tuple of items, which we pass as *args to the key function
+            get_key_items = itemgetter(*key_list)
+            key_argument = lambda zipped_items: key(
+                *get_key_items(zipped_items)
             )
-        )
+
+    return list(
+        zip(*sorted(zip(*iterables), key=key_argument, reverse=reverse))
     )
 
 
@@ -2403,41 +2646,32 @@
 
 
 def difference(iterable, func=sub, *, initial=None):
-    """By default, compute the first difference of *iterable* using
-    :func:`operator.sub`.
-
-        >>> iterable = 0, 1, 3, 6, 10
-        >>> list(difference(iterable))
-        0, 1, 2, 3, 4
-
-    This is the opposite of :func:`itertools.accumulate`'s default behavior:
+    """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 = 0, 1, 2, 3, 4
-        >>> list(accumulate(iterable))
-        0, 1, 3, 6, 10
-        >>> list(difference(accumulate(iterable)))
+        >>> iterable = accumulate(0, 1, 2, 3, 4)  # produces 0, 1, 3, 6, 10
+        >>> list(difference(iterable))
         0, 1, 2, 3, 4
 
-    By default *func* is :func:`operator.sub`, but other functions can be
+    *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  # Factorial sequence
+        >>> iterable = 1, 2, 6, 24, 120
         >>> func = lambda x, y: x // y
         >>> list(difference(iterable, func))
         1, 2, 3, 4, 5
 
-    Since Python 3.8, :func:`itertools.accumulate` can be supplied with an
-    *initial* keyword argument. If :func:`difference` is called with *initial*
-    set to something other than ``None``, it will skip the first element when
+    If the *initial* keyword is set, the first element will be skipped when
     computing successive differences.
 
-        >>> iterable = 100, 101, 103, 106  # accumate(1, 2, 3, initial=100)
-        >>> list(difference(iterable, initial=100))
+        >>> it = 10, 11, 13, 16  # from accumulate(1, 2, 3, initial=10)
+        >>> list(difference(it, initial=10))
         1, 2, 3
 
     """
@@ -2531,6 +2765,27 @@
         >>> next(it), next(it), next(it)
         ('0', '1', '2')
 
+    Call :meth:`peek` to look ahead one item without advancing the iterator:
+
+        >>> it = seekable('1234')
+        >>> it.peek()
+        '1'
+        >>> list(it)
+        '1', '2', '3', '4'
+        >>> it.peek(default='empty')
+        'empty'
+
+    Before the iterator is at its end, calling :func:`bool` on it will return
+    ``True``. After it will return ``False``:
+
+        >>> it = seekable('5678')
+        >>> bool(it)
+        True
+        >>> list(it)
+        '5', '6', '7', '8'
+        >>> bool(it)
+        False
+
     You may view the contents of the cache with the :meth:`elements` method.
     That returns a :class:`SequenceView`, a view that updates automatically:
 
@@ -2588,6 +2843,25 @@
         self._cache.append(item)
         return item
 
+    def __bool__(self):
+        try:
+            self.peek()
+        except StopIteration:
+            return False
+        return True
+
+    def peek(self, default=_marker):
+        try:
+            peeked = next(self)
+        except StopIteration:
+            if default is _marker:
+                raise
+            return default
+        if self._index is None:
+            self._index = len(self._cache)
+        self._index -= 1
+        return peeked
+
     def elements(self):
         return SequenceView(self._cache)
 
@@ -2967,9 +3241,11 @@
         yield from set_partitions_helper(L, k)
 
 
-def time_limited(limit_seconds, iterable):
+class time_limited:
     """
     Yield items from *iterable* until *limit_seconds* have passed.
+    If the time limit expires before all items have been yielded, the
+    ``timed_out`` parameter will be set to ``True``.
 
     >>> from time import sleep
     >>> def generator():
@@ -2977,9 +3253,11 @@
     ...     yield 2
     ...     sleep(0.2)
     ...     yield 3
-    >>> iterable = generator()
-    >>> list(time_limited(0.1, iterable))
+    >>> iterable = time_limited(0.1, generator())
+    >>> list(iterable)
     1, 2
+    >>> iterable.timed_out
+    True
 
     Note that the time is checked before each item is yielded, and iteration
     stops if  the time elapsed is greater than *limit_seconds*. If your time
@@ -2987,14 +3265,25 @@
     the iterable, the function will run for 2 seconds and not yield anything.
 
     """
-    if limit_seconds < 0:
-        raise ValueError('limit_seconds must be positive')
 
-    start_time = monotonic()
-    for item in iterable:
-        if monotonic() - start_time > limit_seconds:
-            break
-        yield item
+    def __init__(self, limit_seconds, iterable):
+        if limit_seconds < 0:
+            raise ValueError('limit_seconds must be positive')
+        self.limit_seconds = limit_seconds
+        self._iterable = iter(iterable)
+        self._start_time = monotonic()
+        self.timed_out = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        item = next(self._iterable)
+        if monotonic() - self._start_time > self.limit_seconds:
+            self.timed_out = True
+            raise StopIteration
+
+        return item
 
 
 def only(iterable, default=None, too_long=None):
@@ -3090,11 +3379,29 @@
         raise ValueError('r must be non-negative')
     elif r == 0:
         yield ()
-    else:
-        pool = tuple(iterable)
-        for i, prefix in unique_everseen(enumerate(pool), key=itemgetter(1)):
-            for suffix in distinct_combinations(pooli + 1 :, r - 1):
-                yield (prefix,) + suffix
+        return
+    pool = tuple(iterable)
+    generators = unique_everseen(enumerate(pool), key=itemgetter(1))
+    current_combo = None * r
+    level = 0
+    while generators:
+        try:
+            cur_idx, p = next(generators-1)
+        except StopIteration:
+            generators.pop()
+            level -= 1
+            continue
+        current_combolevel = p
+        if level + 1 == r:
+            yield tuple(current_combo)
+        else:
+            generators.append(
+                unique_everseen(
+                    enumerate(poolcur_idx + 1 :, cur_idx + 1),
+                    key=itemgetter(1),
+                )
+            )
+            level += 1
 
 
 def filter_except(validator, iterable, *exceptions):
@@ -3126,7 +3433,7 @@
     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.
+    It should accept one argument.
 
     >>> iterable = '1', '2', 'three', '4', None
     >>> list(map_except(int, iterable, ValueError, TypeError))
@@ -3142,6 +3449,28 @@
             pass
 
 
+def map_if(iterable, pred, func, func_else=lambda x: x):
+    """Evaluate each item from *iterable* using *pred*. If the result is
+    equivalent to ``True``, transform the item with *func* and yield it.
+    Otherwise, transform the item with *func_else* and yield it.
+
+    *pred*, *func*, and *func_else* should each be functions that accept
+    one argument. By default, *func_else* is the identity function.
+
+    >>> from math import sqrt
+    >>> iterable = list(range(-5, 5))
+    >>> iterable
+    -5, -4, -3, -2, -1, 0, 1, 2, 3, 4
+    >>> list(map_if(iterable, lambda x: x > 3, lambda x: 'toobig'))
+    -5, -4, -3, -2, -1, 0, 1, 2, 3, 'toobig'
+    >>> list(map_if(iterable, lambda x: x >= 0,
+    ... lambda x: f'{sqrt(x):.2f}', lambda x: None))
+    None, None, None, None, None, '0.00', '1.00', '1.41', '1.73', '2.00'
+    """
+    for item in iterable:
+        yield func(item) if pred(item) else func_else(item)
+
+
 def _sample_unweighted(iterable, k):
     # Implementation of "Algorithm L" from the 1994 paper by Kim-Hung Li:
     # "Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))".
@@ -3212,7 +3541,7 @@
     >>> sample(iterable, 5)  # doctest: +SKIP
     81, 60, 96, 16, 4
 
-     An iterable with *weights* may also be given:
+    An iterable with *weights* may also be given:
 
     >>> iterable = range(100)
     >>> weights = (i * i + 1 for i in range(100))
@@ -3239,7 +3568,7 @@
         return _sample_weighted(iterable, k, weights)
 
 
-def is_sorted(iterable, key=None, reverse=False):
+def is_sorted(iterable, key=None, reverse=False, strict=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.
@@ -3249,12 +3578,20 @@
     >>> is_sorted(5, 4, 3, 1, 2, reverse=True)
     False
 
+    If *strict*, tests for strict sorting, that is, returns ``False`` if equal
+    elements are found:
+
+    >>> is_sorted(1, 2, 2)
+    True
+    >>> is_sorted(1, 2, 2, strict=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.
     """
 
-    compare = lt if reverse else gt
-    it = iterable if (key is None) else map(key, iterable)
+    compare = (le if reverse else ge) if strict else (lt if reverse else gt)
+    it = iterable if key is None else map(key, iterable)
     return not any(starmap(compare, pairwise(it)))
 
 
@@ -3404,10 +3741,11 @@
     (0, 1, 2) (3, 4, 5) (6,)
     (0, 1, 2, 3) (4, 5, 6) ()
 
-    Notes:
-       * *n* must be at least 0 and most equal to the length of *iterable*.
-       * This function will exhaust *iterable* and store all its items.
+    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.
     """
     if n < 0:
         raise ValueError('n must be >= 0')
@@ -3423,3 +3761,557 @@
         middle = seqi : i + n
         end = seqi + n :
         yield beginning, middle, end
+
+
+def 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.
+    """
+    seenset = set()
+    seenset_add = seenset.add
+    seenlist = 
+    seenlist_add = seenlist.append
+    for element in map(key, iterable) if key else iterable:
+        try:
+            if element in seenset:
+                return False
+            seenset_add(element)
+        except TypeError:
+            if element in seenlist:
+                return False
+            seenlist_add(element)
+    return True
+
+
+def 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.
+    """
+    pools = list(map(tuple, reversed(args)))
+    ns = list(map(len, pools))
+
+    c = reduce(mul, ns)
+
+    if index < 0:
+        index += c
+
+    if not 0 <= index < c:
+        raise IndexError
+
+    result = 
+    for pool, n in zip(pools, ns):
+        result.append(poolindex % n)
+        index //= n
+
+    return tuple(reversed(result))
+
+
+def 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.
+    """
+    pool = list(iterable)
+    n = len(pool)
+
+    if r is None or r == n:
+        r, c = n, factorial(n)
+    elif not 0 <= r < n:
+        raise ValueError
+    else:
+        c = factorial(n) // factorial(n - r)
+
+    if index < 0:
+        index += c
+
+    if not 0 <= index < c:
+        raise IndexError
+
+    if c == 0:
+        return tuple()
+
+    result = 0 * r
+    q = index * factorial(n) // c if r < n else index
+    for d in range(1, n + 1):
+        q, i = divmod(q, d)
+        if 0 <= n - d < r:
+            resultn - d = i
+        if q == 0:
+            break
+
+    return tuple(map(pool.pop, result))
+
+
+def 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.
+
+    """
+    for value in args:
+        if isinstance(value, (str, bytes)):
+            yield value
+            continue
+        try:
+            yield from value
+        except TypeError:
+            yield value
+
+
+def 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*.
+    """
+    index = 0
+
+    for x, pool in zip_longest(element, args, fillvalue=_marker):
+        if x is _marker or pool is _marker:
+            raise ValueError('element is not a product of args')
+
+        pool = tuple(pool)
+        index = index * len(pool) + pool.index(x)
+
+    return index
+
+
+def 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*.
+    """
+    element = enumerate(element)
+    k, y = next(element, (None, None))
+    if k is None:
+        return 0
+
+    indexes = 
+    pool = enumerate(iterable)
+    for n, x in pool:
+        if x == y:
+            indexes.append(n)
+            tmp, y = next(element, (None, None))
+            if tmp is None:
+                break
+            else:
+                k = tmp
+    else:
+        raise ValueError('element is not a combination of iterable')
+
+    n, _ = last(pool, default=(n, None))
+
+    # Python versiosn below 3.8 don't have math.comb
+    index = 1
+    for i, j in enumerate(reversed(indexes), start=1):
+        j = n - j
+        if i <= j:
+            index += factorial(j) // (factorial(i) * factorial(j - i))
+
+    return factorial(n + 1) // (factorial(k + 1) * factorial(n - k)) - index
+
+
+def 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*.
+    """
+    index = 0
+    pool = list(iterable)
+    for i, x in zip(range(len(pool), -1, -1), element):
+        r = pool.index(x)
+        index = index * i + r
+        del poolr
+
+    return index
+
+
+class countable:
+    """Wrap *iterable* and keep a count of how many items have been consumed.
+
+    The ``items_seen`` attribute starts at ``0`` and increments as the iterable
+    is consumed:
+
+        >>> iterable = map(str, range(10))
+        >>> it = countable(iterable)
+        >>> it.items_seen
+        0
+        >>> next(it), next(it)
+        ('0', '1')
+        >>> list(it)
+        '2', '3', '4', '5', '6', '7', '8', '9'
+        >>> it.items_seen
+        10
+    """
+
+    def __init__(self, iterable):
+        self._it = iter(iterable)
+        self.items_seen = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        item = next(self._it)
+        self.items_seen += 1
+
+        return item
+
+
+def chunked_even(iterable, n):
+    """Break *iterable* into lists of approximately length *n*.
+    Items are distributed such the lengths of the lists differ by at most
+    1 item.
+
+    >>> iterable = 1, 2, 3, 4, 5, 6, 7
+    >>> n = 3
+    >>> list(chunked_even(iterable, n))  # List lengths: 3, 2, 2
+    1, 2, 3, 4, 5, 6, 7
+    >>> list(chunked(iterable, n))  # List lengths: 3, 3, 1
+    1, 2, 3, 4, 5, 6, 7
+
+    """
+
+    len_method = getattr(iterable, '__len__', None)
+
+    if len_method is None:
+        return _chunked_even_online(iterable, n)
+    else:
+        return _chunked_even_finite(iterable, len_method(), n)
+
+
+def _chunked_even_online(iterable, n):
+    buffer = 
+    maxbuf = n + (n - 2) * (n - 1)
+    for x in iterable:
+        buffer.append(x)
+        if len(buffer) == maxbuf:
+            yield buffer:n
+            buffer = buffern:
+    yield from _chunked_even_finite(buffer, len(buffer), n)
+
+
+def _chunked_even_finite(iterable, N, n):
+    if N < 1:
+        return
+
+    # Lists are either size `full_size <= n` or `partial_size = full_size - 1`
+    q, r = divmod(N, n)
+    num_lists = q + (1 if r > 0 else 0)
+    q, r = divmod(N, num_lists)
+    full_size = q + (1 if r > 0 else 0)
+    partial_size = full_size - 1
+    num_full = N - partial_size * num_lists
+    num_partial = num_lists - num_full
+
+    buffer = 
+    iterator = iter(iterable)
+
+    # Yield num_full lists of full_size
+    for x in iterator:
+        buffer.append(x)
+        if len(buffer) == full_size:
+            yield buffer
+            buffer = 
+            num_full -= 1
+            if num_full <= 0:
+                break
+
+    # Yield num_partial lists of partial_size
+    for x in iterator:
+        buffer.append(x)
+        if len(buffer) == partial_size:
+            yield buffer
+            buffer = 
+            num_partial -= 1
+
+
+def zip_broadcast(*objects, scalar_types=(str, bytes), strict=False):
+    """A version of :func:`zip` that "broadcasts" any scalar
+    (i.e., non-iterable) items into output tuples.
+
+    >>> iterable_1 = 1, 2, 3
+    >>> iterable_2 = 'a', 'b', 'c'
+    >>> scalar = '_'
+    >>> list(zip_broadcast(iterable_1, iterable_2, scalar))
+    (1, 'a', '_'), (2, 'b', '_'), (3, 'c', '_')
+
+    The *scalar_types* keyword argument determines what types are considered
+    scalar. It is set to ``(str, bytes)`` by default. Set it to ``None`` to
+    treat strings and byte strings as iterable:
+
+    >>> list(zip_broadcast('abc', 0, 'xyz', scalar_types=None))
+    ('a', 0, 'x'), ('b', 0, 'y'), ('c', 0, 'z')
+
+    If the *strict* keyword argument is ``True``, then
+    ``UnequalIterablesError`` will be raised if any of the iterables have
+    different lengthss.
+    """
+
+    def is_scalar(obj):
+        if scalar_types and isinstance(obj, scalar_types):
+            return True
+        try:
+            iter(obj)
+        except TypeError:
+            return True
+        else:
+            return False
+
+    size = len(objects)
+    if not size:
+        return
+
+    iterables, iterable_positions = , 
+    scalars, scalar_positions = , 
+    for i, obj in enumerate(objects):
+        if is_scalar(obj):
+            scalars.append(obj)
+            scalar_positions.append(i)
+        else:
+            iterables.append(iter(obj))
+            iterable_positions.append(i)
+
+    if len(scalars) == size:
+        yield tuple(objects)
+        return
+
+    zipper = _zip_equal if strict else zip
+    for item in zipper(*iterables):
+        new_item = None * size
+
+        for i, elem in zip(iterable_positions, item):
+            new_itemi = elem
+
+        for i, elem in zip(scalar_positions, scalars):
+            new_itemi = elem
+
+        yield tuple(new_item)
+
+
+def unique_in_window(iterable, n, key=None):
+    """Yield the items from *iterable* that haven't been seen recently.
+    *n* is the size of the lookback window.
+
+        >>> iterable = 0, 1, 0, 2, 3, 0
+        >>> n = 3
+        >>> list(unique_in_window(iterable, n))
+        0, 1, 2, 3, 0
+
+    The *key* function, if provided, will be used to determine uniqueness:
+
+        >>> list(unique_in_window('abAcda', 3, key=lambda x: x.lower()))
+        'a', 'b', 'c', 'd', 'a'
+
+    The items in *iterable* must be hashable.
+
+    """
+    if n <= 0:
+        raise ValueError('n must be greater than 0')
+
+    window = deque(maxlen=n)
+    uniques = set()
+    use_key = key is not None
+
+    for item in iterable:
+        k = key(item) if use_key else item
+        if k in uniques:
+            continue
+
+        if len(uniques) == n:
+            uniques.discard(window0)
+
+        uniques.add(k)
+        window.append(k)
+
+        yield item
+
+
+def duplicates_everseen(iterable, key=None):
+    """Yield duplicate elements after their first appearance.
+
+    >>> list(duplicates_everseen('mississippi'))
+    's', 'i', 's', 's', 'i', 'p', 'i'
+    >>> list(duplicates_everseen('AaaBbbCccAaa', str.lower))
+    'a', 'a', 'b', 'b', 'c', 'c', 'A', 'a', 'a'
+
+    This function is analagous to :func:`unique_everseen` and is subject to
+    the same performance considerations.
+
+    """
+    seen_set = set()
+    seen_list = 
+    use_key = key is not None
+
+    for element in iterable:
+        k = key(element) if use_key else element
+        try:
+            if k not in seen_set:
+                seen_set.add(k)
+            else:
+                yield element
+        except TypeError:
+            if k not in seen_list:
+                seen_list.append(k)
+            else:
+                yield element
+
+
+def duplicates_justseen(iterable, key=None):
+    """Yields serially-duplicate elements after their first appearance.
+
+    >>> list(duplicates_justseen('mississippi'))
+    's', 's', 'p'
+    >>> list(duplicates_justseen('AaaBbbCccAaa', str.lower))
+    'a', 'a', 'b', 'b', 'c', 'c', 'a', 'a'
+
+    This function is analagous to :func:`unique_justseen`.
+
+    """
+    return flatten(
+        map(
+            lambda group_tuple: islice_extended(group_tuple1)1:,
+            groupby(iterable, key),
+        )
+    )
+
+
+def minmax(iterable_or_value, *others, key=None, default=_marker):
+    """Returns both the smallest and largest items in an iterable
+    or the largest of two or more arguments.
+
+        >>> minmax(3, 1, 5)
+        (1, 5)
+
+        >>> minmax(4, 2, 6)
+        (2, 6)
+
+    If a *key* function is provided, it will be used to transform the input
+    items for comparison.
+
+        >>> minmax(5, 30, key=str)  # '30' sorts before '5'
+        (30, 5)
+
+    If a *default* value is provided, it will be returned if there are no
+    input items.
+
+        >>> minmax(, default=(0, 0))
+        (0, 0)
+
+    Otherwise ``ValueError`` is raised.
+
+    This function is based on the
+    `recipe <http://code.activestate.com/recipes/577916/>`__ by
+    Raymond Hettinger and takes care to minimize the number of comparisons
+    performed.
+    """
+    iterable = (iterable_or_value, *others) if others else iterable_or_value
+
+    it = iter(iterable)
+
+    try:
+        lo = hi = next(it)
+    except StopIteration as e:
+        if default is _marker:
+            raise ValueError(
+                '`minmax()` argument is an empty iterable. '
+                'Provide a `default` value to suppress this error.'
+            ) from e
+        return default
+
+    # Different branches depending on the presence of key. This saves a lot
+    # of unimportant copies which would slow the "key=None" branch
+    # significantly down.
+    if key is None:
+        for x, y in zip_longest(it, it, fillvalue=lo):
+            if y < x:
+                x, y = y, x
+            if x < lo:
+                lo = x
+            if hi < y:
+                hi = y
+
+    else:
+        lo_key = hi_key = key(lo)
+
+        for x, y in zip_longest(it, it, fillvalue=lo):
+
+            x_key, y_key = key(x), key(y)
+
+            if y_key < x_key:
+                x, y, x_key, y_key = y, x, y_key, x_key
+            if x_key < lo_key:
+                lo, lo_key = x, x_key
+            if hi_key < y_key:
+                hi, hi_key = y, y_key
+
+    return lo, hi

_service:tar_scm:more-itertools-8.12.0.tar.gz/more_itertools/more.pyi Added

@@ -0,0 +1,664 @@
+"""Stubs for more_itertools.more"""
+
+from typing import (
+    Any,
+    Callable,
+    Container,
+    Dict,
+    Generic,
+    Hashable,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Reversible,
+    Sequence,
+    Sized,
+    Tuple,
+    Union,
+    TypeVar,
+    type_check_only,
+)
+from types import TracebackType
+from typing_extensions import ContextManager, Protocol, Type, overload
+
+# Type and type variable definitions
+_T = TypeVar('_T')
+_T1 = TypeVar('_T1')
+_T2 = TypeVar('_T2')
+_U = TypeVar('_U')
+_V = TypeVar('_V')
+_W = TypeVar('_W')
+_T_co = TypeVar('_T_co', covariant=True)
+_GenFn = TypeVar('_GenFn', bound=Callable..., Iteratorobject)
+_Raisable = UnionBaseException, 'TypeBaseException'
+
+@type_check_only
+class _SizedIterable(Protocol_T_co, Sized, Iterable_T_co): ...
+
+@type_check_only
+class _SizedReversible(Protocol_T_co, Sized, Reversible_T_co): ...
+
+def chunked(
+    iterable: Iterable_T, n: Optionalint, strict: bool = ...
+) -> IteratorList_T: ...
+@overload
+def first(iterable: Iterable_T) -> _T: ...
+@overload
+def first(iterable: Iterable_T, default: _U) -> Union_T, _U: ...
+@overload
+def last(iterable: Iterable_T) -> _T: ...
+@overload
+def last(iterable: Iterable_T, default: _U) -> Union_T, _U: ...
+@overload
+def nth_or_last(iterable: Iterable_T, n: int) -> _T: ...
+@overload
+def nth_or_last(
+    iterable: Iterable_T, n: int, default: _U
+) -> Union_T, _U: ...
+
+class peekable(Generic_T, Iterator_T):
+    def __init__(self, iterable: Iterable_T) -> None: ...
+    def __iter__(self) -> peekable_T: ...
+    def __bool__(self) -> bool: ...
+    @overload
+    def peek(self) -> _T: ...
+    @overload
+    def peek(self, default: _U) -> Union_T, _U: ...
+    def prepend(self, *items: _T) -> None: ...
+    def __next__(self) -> _T: ...
+    @overload
+    def __getitem__(self, index: int) -> _T: ...
+    @overload
+    def __getitem__(self, index: slice) -> List_T: ...
+
+def collate(*iterables: Iterable_T, **kwargs: Any) -> Iterable_T: ...
+def consumer(func: _GenFn) -> _GenFn: ...
+def ilen(iterable: Iterableobject) -> int: ...
+def iterate(func: Callable_T, _T, start: _T) -> Iterator_T: ...
+def with_iter(
+    context_manager: ContextManagerIterable_T,
+) -> Iterator_T: ...
+def one(
+    iterable: Iterable_T,
+    too_short: Optional_Raisable = ...,
+    too_long: Optional_Raisable = ...,
+) -> _T: ...
+def raise_(exception: _Raisable, *args: Any) -> None: ...
+def strictly_n(
+    iterable: Iterable_T,
+    n: int,
+    too_short: Optional_GenFn = ...,
+    too_long: Optional_GenFn = ...,
+) -> List_T: ...
+def distinct_permutations(
+    iterable: Iterable_T, r: Optionalint = ...
+) -> IteratorTuple_T, ...: ...
+def intersperse(
+    e: _U, iterable: Iterable_T, n: int = ...
+) -> IteratorUnion_T, _U: ...
+def unique_to_each(*iterables: Iterable_T) -> ListList_T: ...
+@overload
+def windowed(
+    seq: Iterable_T, n: int, *, step: int = ...
+) -> IteratorTupleOptional_T, ...: ...
+@overload
+def windowed(
+    seq: Iterable_T, n: int, fillvalue: _U, step: int = ...
+) -> IteratorTupleUnion_T, _U, ...: ...
+def substrings(iterable: Iterable_T) -> IteratorTuple_T, ...: ...
+def substrings_indexes(
+    seq: Sequence_T, reverse: bool = ...
+) -> IteratorTupleSequence_T, int, int: ...
+
+class bucket(Generic_T, _U, Container_U):
+    def __init__(
+        self,
+        iterable: Iterable_T,
+        key: Callable_T, _U,
+        validator: OptionalCallableobject, object = ...,
+    ) -> None: ...
+    def __contains__(self, value: object) -> bool: ...
+    def __iter__(self) -> Iterator_U: ...
+    def __getitem__(self, value: object) -> Iterator_T: ...
+
+def spy(
+    iterable: Iterable_T, n: int = ...
+) -> TupleList_T, Iterator_T: ...
+def interleave(*iterables: Iterable_T) -> Iterator_T: ...
+def interleave_longest(*iterables: Iterable_T) -> Iterator_T: ...
+def interleave_evenly(
+    iterables: ListIterable_T, lengths: OptionalListint = ...
+) -> Iterator_T: ...
+def collapse(
+    iterable: IterableAny,
+    base_type: Optionaltype = ...,
+    levels: Optionalint = ...,
+) -> IteratorAny: ...
+@overload
+def side_effect(
+    func: Callable_T, object,
+    iterable: Iterable_T,
+    chunk_size: None = ...,
+    before: OptionalCallable, object = ...,
+    after: OptionalCallable, object = ...,
+) -> Iterator_T: ...
+@overload
+def side_effect(
+    func: CallableList_T, object,
+    iterable: Iterable_T,
+    chunk_size: int,
+    before: OptionalCallable, object = ...,
+    after: OptionalCallable, object = ...,
+) -> Iterator_T: ...
+def sliced(
+    seq: Sequence_T, n: int, strict: bool = ...
+) -> IteratorSequence_T: ...
+def split_at(
+    iterable: Iterable_T,
+    pred: Callable_T, object,
+    maxsplit: int = ...,
+    keep_separator: bool = ...,
+) -> IteratorList_T: ...
+def split_before(
+    iterable: Iterable_T, pred: Callable_T, object, maxsplit: int = ...
+) -> IteratorList_T: ...
+def split_after(
+    iterable: Iterable_T, pred: Callable_T, object, maxsplit: int = ...
+) -> IteratorList_T: ...
+def split_when(
+    iterable: Iterable_T,
+    pred: Callable_T, _T, object,
+    maxsplit: int = ...,
+) -> IteratorList_T: ...
+def split_into(
+    iterable: Iterable_T, sizes: IterableOptionalint
+) -> IteratorList_T: ...
+@overload
+def padded(
+    iterable: Iterable_T,
+    *,
+    n: Optionalint = ...,
+    next_multiple: bool = ...
+) -> IteratorOptional_T: ...
+@overload
+def padded(
+    iterable: Iterable_T,
+    fillvalue: _U,
+    n: Optionalint = ...,
+    next_multiple: bool = ...,
+) -> IteratorUnion_T, _U: ...
+@overload
+def repeat_last(iterable: Iterable_T) -> Iterator_T: ...
+@overload
+def repeat_last(
+    iterable: Iterable_T, default: _U
+) -> IteratorUnion_T, _U: ...
+def distribute(n: int, iterable: Iterable_T) -> ListIterator_T: ...
+@overload
+def stagger(
+    iterable: Iterable_T,
+    offsets: _SizedIterableint = ...,
+    longest: bool = ...,
+) -> IteratorTupleOptional_T, ...: ...
+@overload
+def stagger(
+    iterable: Iterable_T,
+    offsets: _SizedIterableint = ...,
+    longest: bool = ...,
+    fillvalue: _U = ...,
+) -> IteratorTupleUnion_T, _U, ...: ...
+
+class UnequalIterablesError(ValueError):
+    def __init__(
+        self, details: OptionalTupleint, int, int = ...
+    ) -> None: ...
+
+@overload
+def zip_equal(__iter1: Iterable_T1) -> IteratorTuple_T1: ...
+@overload
+def zip_equal(
+    __iter1: Iterable_T1, __iter2: Iterable_T2
+) -> IteratorTuple_T1, _T2: ...
+@overload
+def zip_equal(
+    __iter1: Iterable_T,
+    __iter2: Iterable_T,
+    __iter3: Iterable_T,
+    *iterables: Iterable_T
+) -> IteratorTuple_T, ...: ...
+@overload
+def zip_offset(
+    __iter1: Iterable_T1,
+    *,
+    offsets: _SizedIterableint,
+    longest: bool = ...,
+    fillvalue: None = None
+) -> IteratorTupleOptional_T1: ...
+@overload
+def zip_offset(
+    __iter1: Iterable_T1,
+    __iter2: Iterable_T2,
+    *,
+    offsets: _SizedIterableint,
+    longest: bool = ...,
+    fillvalue: None = None
+) -> IteratorTupleOptional_T1, Optional_T2: ...
+@overload
+def zip_offset(
+    __iter1: Iterable_T,
+    __iter2: Iterable_T,
+    __iter3: Iterable_T,
+    *iterables: Iterable_T,
+    offsets: _SizedIterableint,
+    longest: bool = ...,
+    fillvalue: None = None
+) -> IteratorTupleOptional_T, ...: ...
+@overload
+def zip_offset(
+    __iter1: Iterable_T1,
+    *,
+    offsets: _SizedIterableint,
+    longest: bool = ...,
+    fillvalue: _U,
+) -> IteratorTupleUnion_T1, _U: ...
+@overload
+def zip_offset(
+    __iter1: Iterable_T1,
+    __iter2: Iterable_T2,
+    *,
+    offsets: _SizedIterableint,
+    longest: bool = ...,
+    fillvalue: _U,
+) -> IteratorTupleUnion_T1, _U, Union_T2, _U: ...
+@overload
+def zip_offset(
+    __iter1: Iterable_T,
+    __iter2: Iterable_T,
+    __iter3: Iterable_T,
+    *iterables: Iterable_T,
+    offsets: _SizedIterableint,
+    longest: bool = ...,
+    fillvalue: _U,
+) -> IteratorTupleUnion_T, _U, ...: ...
+def sort_together(
+    iterables: IterableIterable_T,
+    key_list: Iterableint = ...,
+    key: OptionalCallable..., Any = ...,
+    reverse: bool = ...,
+) -> ListTuple_T, ...: ...
+def unzip(iterable: IterableSequence_T) -> TupleIterator_T, ...: ...
+def divide(n: int, iterable: Iterable_T) -> ListIterator_T: ...
+def always_iterable(
+    obj: object,
+    base_type: Union
+        type, TupleUniontype, TupleAny, ..., ..., None
+     = ...,
+) -> IteratorAny: ...
+def adjacent(
+    predicate: Callable_T, bool,
+    iterable: Iterable_T,
+    distance: int = ...,
+) -> IteratorTuplebool, _T: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: None = None,
+    valuefunc: None = None,
+    reducefunc: None = None,
+) -> IteratorTuple_T, Iterator_T: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: None,
+    reducefunc: None,
+) -> IteratorTuple_U, Iterator_T: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: None,
+    valuefunc: Callable_T, _V,
+    reducefunc: None,
+) -> IterableTuple_T, Iterable_V: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: Callable_T, _V,
+    reducefunc: None,
+) -> IterableTuple_U, Iterator_V: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: None,
+    valuefunc: None,
+    reducefunc: CallableIterator_T, _W,
+) -> IterableTuple_T, _W: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: None,
+    reducefunc: CallableIterator_T, _W,
+) -> IterableTuple_U, _W: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: None,
+    valuefunc: Callable_T, _V,
+    reducefunc: CallableIterable_V, _W,
+) -> IterableTuple_T, _W: ...
+@overload
+def groupby_transform(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: Callable_T, _V,
+    reducefunc: CallableIterable_V, _W,
+) -> IterableTuple_U, _W: ...
+
+class numeric_range(Generic_T, _U, Sequence_T, Hashable, Reversible_T):
+    @overload
+    def __init__(self, __stop: _T) -> None: ...
+    @overload
+    def __init__(self, __start: _T, __stop: _T) -> None: ...
+    @overload
+    def __init__(self, __start: _T, __stop: _T, __step: _U) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __contains__(self, elem: object) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+    @overload
+    def __getitem__(self, key: int) -> _T: ...
+    @overload
+    def __getitem__(self, key: slice) -> numeric_range_T, _U: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> Iterator_T: ...
+    def __len__(self) -> int: ...
+    def __reduce__(
+        self,
+    ) -> TupleTypenumeric_range_T, _U, Tuple_T, _T, _U: ...
+    def __repr__(self) -> str: ...
+    def __reversed__(self) -> Iterator_T: ...
+    def count(self, value: _T) -> int: ...
+    def index(self, value: _T) -> int: ...  # type: ignore
+
+def count_cycle(
+    iterable: Iterable_T, n: Optionalint = ...
+) -> IterableTupleint, _T: ...
+def mark_ends(
+    iterable: Iterable_T,
+) -> IterableTuplebool, bool, _T: ...
+def locate(
+    iterable: Iterableobject,
+    pred: Callable..., Any = ...,
+    window_size: Optionalint = ...,
+) -> Iteratorint: ...
+def lstrip(
+    iterable: Iterable_T, pred: Callable_T, object
+) -> Iterator_T: ...
+def rstrip(
+    iterable: Iterable_T, pred: Callable_T, object
+) -> Iterator_T: ...
+def strip(
+    iterable: Iterable_T, pred: Callable_T, object
+) -> Iterator_T: ...
+
+class islice_extended(Generic_T, Iterator_T):
+    def __init__(
+        self, iterable: Iterable_T, *args: Optionalint
+    ) -> None: ...
+    def __iter__(self) -> islice_extended_T: ...
+    def __next__(self) -> _T: ...
+    def __getitem__(self, index: slice) -> islice_extended_T: ...
+
+def always_reversible(iterable: Iterable_T) -> Iterator_T: ...
+def consecutive_groups(
+    iterable: Iterable_T, ordering: Callable_T, int = ...
+) -> IteratorIterator_T: ...
+@overload
+def difference(
+    iterable: Iterable_T,
+    func: Callable_T, _T, _U = ...,
+    *,
+    initial: None = ...
+) -> IteratorUnion_T, _U: ...
+@overload
+def difference(
+    iterable: Iterable_T, func: Callable_T, _T, _U = ..., *, initial: _U
+) -> Iterator_U: ...
+
+class SequenceView(Generic_T, Sequence_T):
+    def __init__(self, target: Sequence_T) -> None: ...
+    @overload
+    def __getitem__(self, index: int) -> _T: ...
+    @overload
+    def __getitem__(self, index: slice) -> Sequence_T: ...
+    def __len__(self) -> int: ...
+
+class seekable(Generic_T, Iterator_T):
+    def __init__(
+        self, iterable: Iterable_T, maxlen: Optionalint = ...
+    ) -> None: ...
+    def __iter__(self) -> seekable_T: ...
+    def __next__(self) -> _T: ...
+    def __bool__(self) -> bool: ...
+    @overload
+    def peek(self) -> _T: ...
+    @overload
+    def peek(self, default: _U) -> Union_T, _U: ...
+    def elements(self) -> SequenceView_T: ...
+    def seek(self, index: int) -> None: ...
+
+class run_length:
+    @staticmethod
+    def encode(iterable: Iterable_T) -> IteratorTuple_T, int: ...
+    @staticmethod
+    def decode(iterable: IterableTuple_T, int) -> Iterator_T: ...
+
+def exactly_n(
+    iterable: Iterable_T, n: int, predicate: Callable_T, object = ...
+) -> bool: ...
+def circular_shifts(iterable: Iterable_T) -> ListTuple_T, ...: ...
+def make_decorator(
+    wrapping_func: Callable..., _U, result_index: int = ...
+) -> Callable..., CallableCallable..., Any, Callable..., _U: ...
+@overload
+def map_reduce(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: None = ...,
+    reducefunc: None = ...,
+) -> Dict_U, List_T: ...
+@overload
+def map_reduce(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: Callable_T, _V,
+    reducefunc: None = ...,
+) -> Dict_U, List_V: ...
+@overload
+def map_reduce(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: None = ...,
+    reducefunc: CallableList_T, _W = ...,
+) -> Dict_U, _W: ...
+@overload
+def map_reduce(
+    iterable: Iterable_T,
+    keyfunc: Callable_T, _U,
+    valuefunc: Callable_T, _V,
+    reducefunc: CallableList_V, _W,
+) -> Dict_U, _W: ...
+def rlocate(
+    iterable: Iterable_T,
+    pred: Callable..., object = ...,
+    window_size: Optionalint = ...,
+) -> Iteratorint: ...
+def replace(
+    iterable: Iterable_T,
+    pred: Callable..., object,
+    substitutes: Iterable_U,
+    count: Optionalint = ...,
+    window_size: int = ...,
+) -> IteratorUnion_T, _U: ...
+def partitions(iterable: Iterable_T) -> IteratorListList_T: ...
+def set_partitions(
+    iterable: Iterable_T, k: Optionalint = ...
+) -> IteratorListList_T: ...
+
+class time_limited(Generic_T, Iterator_T):
+    def __init__(
+        self, limit_seconds: float, iterable: Iterable_T
+    ) -> None: ...
+    def __iter__(self) -> islice_extended_T: ...
+    def __next__(self) -> _T: ...
+
+@overload
+def only(
+    iterable: Iterable_T, *, too_long: Optional_Raisable = ...
+) -> Optional_T: ...
+@overload
+def only(
+    iterable: Iterable_T, default: _U, too_long: Optional_Raisable = ...
+) -> Union_T, _U: ...
+def ichunked(iterable: Iterable_T, n: int) -> IteratorIterator_T: ...
+def distinct_combinations(
+    iterable: Iterable_T, r: int
+) -> IteratorTuple_T, ...: ...
+def filter_except(
+    validator: CallableAny, object,
+    iterable: Iterable_T,
+    *exceptions: TypeBaseException
+) -> Iterator_T: ...
+def map_except(
+    function: CallableAny, _U,
+    iterable: Iterable_T,
+    *exceptions: TypeBaseException
+) -> Iterator_U: ...
+def map_if(
+    iterable: IterableAny,
+    pred: CallableAny, bool,
+    func: CallableAny, Any,
+    func_else: OptionalCallableAny, Any = ...,
+) -> IteratorAny: ...
+def sample(
+    iterable: Iterable_T,
+    k: int,
+    weights: OptionalIterablefloat = ...,
+) -> List_T: ...
+def is_sorted(
+    iterable: Iterable_T,
+    key: OptionalCallable_T, _U = ...,
+    reverse: bool = False,
+    strict: bool = False,
+) -> bool: ...
+
+class AbortThread(BaseException):
+    pass
+
+class callback_iter(Generic_T, Iterator_T):
+    def __init__(
+        self,
+        func: Callable..., Any,
+        callback_kwd: str = ...,
+        wait_seconds: float = ...,
+    ) -> None: ...
+    def __enter__(self) -> callback_iter_T: ...
+    def __exit__(
+        self,
+        exc_type: OptionalTypeBaseException,
+        exc_value: OptionalBaseException,
+        traceback: OptionalTracebackType,
+    ) -> Optionalbool: ...
+    def __iter__(self) -> callback_iter_T: ...
+    def __next__(self) -> _T: ...
+    def _reader(self) -> Iterator_T: ...
+    @property
+    def done(self) -> bool: ...
+    @property
+    def result(self) -> Any: ...
+
+def windowed_complete(
+    iterable: Iterable_T, n: int
+) -> IteratorTuple_T, ...: ...
+def all_unique(
+    iterable: Iterable_T, key: OptionalCallable_T, _U = ...
+) -> bool: ...
+def nth_product(index: int, *args: Iterable_T) -> Tuple_T, ...: ...
+def nth_permutation(
+    iterable: Iterable_T, r: int, index: int
+) -> Tuple_T, ...: ...
+def value_chain(*args: Union_T, Iterable_T) -> Iterable_T: ...
+def product_index(element: Iterable_T, *args: Iterable_T) -> int: ...
+def combination_index(
+    element: Iterable_T, iterable: Iterable_T
+) -> int: ...
+def permutation_index(
+    element: Iterable_T, iterable: Iterable_T
+) -> int: ...
+def repeat_each(iterable: Iterable_T, n: int = ...) -> Iterator_T: ...
+
+class countable(Generic_T, Iterator_T):
+    def __init__(self, iterable: Iterable_T) -> None: ...
+    def __iter__(self) -> countable_T: ...
+    def __next__(self) -> _T: ...
+
+def chunked_even(iterable: Iterable_T, n: int) -> IteratorList_T: ...
+def zip_broadcast(
+    *objects: Union_T, Iterable_T,
+    scalar_types: Union
+        type, TupleUniontype, TupleAny, ..., ..., None
+     = ...,
+    strict: bool = ...
+) -> IterableTuple_T, ...: ...
+def unique_in_window(
+    iterable: Iterable_T, n: int, key: OptionalCallable_T, _U = ...
+) -> Iterator_T: ...
+def duplicates_everseen(
+    iterable: Iterable_T, key: OptionalCallable_T, _U = ...
+) -> Iterator_T: ...
+def duplicates_justseen(
+    iterable: Iterable_T, key: OptionalCallable_T, _U = ...
+) -> Iterator_T: ...
+
+class _SupportsLessThan(Protocol):
+    def __lt__(self, __other: Any) -> bool: ...
+
+_SupportsLessThanT = TypeVar("_SupportsLessThanT", bound=_SupportsLessThan)
+
+@overload
+def minmax(
+    iterable_or_value: Iterable_SupportsLessThanT, *, key: None = None
+) -> Tuple_SupportsLessThanT, _SupportsLessThanT: ...
+@overload
+def minmax(
+    iterable_or_value: Iterable_T, *, key: Callable_T, _SupportsLessThan
+) -> Tuple_T, _T: ...
+@overload
+def minmax(
+    iterable_or_value: Iterable_SupportsLessThanT,
+    *,
+    key: None = None,
+    default: _U
+) -> Union_U, Tuple_SupportsLessThanT, _SupportsLessThanT: ...
+@overload
+def minmax(
+    iterable_or_value: Iterable_T,
+    *,
+    key: Callable_T, _SupportsLessThan,
+    default: _U,
+) -> Union_U, Tuple_T, _T: ...
+@overload
+def minmax(
+    iterable_or_value: _SupportsLessThanT,
+    __other: _SupportsLessThanT,
+    *others: _SupportsLessThanT
+) -> Tuple_SupportsLessThanT, _SupportsLessThanT: ...
+@overload
+def minmax(
+    iterable_or_value: _T,
+    __other: _T,
+    *others: _T,
+    key: Callable_T, _SupportsLessThan
+) -> Tuple_T, _T: ...

_service:tar_scm:more-itertools-8.12.0.tar.gz/more_itertools/py.typed Added

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools/recipes.py -> _service:tar_scm:more-itertools-8.12.0.tar.gz/more_itertools/recipes.py Changed

@@ -26,7 +26,9 @@
 
 __all__ = 
     'all_equal',
+    'before_and_after',
     'consume',
+    'convolve',
     'dotproduct',
     'first_true',
     'flatten',
@@ -36,6 +38,7 @@
     'nth',
     'nth_combination',
     'padnone',
+    'pad_none',
     'pairwise',
     'partition',
     'powerset',
@@ -47,9 +50,11 @@
     'random_product',
     'repeatfunc',
     'roundrobin',
+    'sliding_window',
     'tabulate',
     'tail',
     'take',
+    'triplewise',
     'unique_everseen',
     'unique_justseen',
 
@@ -177,10 +182,10 @@
     return sum(map(pred, iterable))
 
 
-def padnone(iterable):
+def pad_none(iterable):
     """Returns the sequence of elements and then returns ``None`` indefinitely.
 
-        >>> take(5, padnone(range(3)))
+        >>> take(5, pad_none(range(3)))
         0, 1, 2, None, None
 
     Useful for emulating the behavior of the built-in :func:`map` function.
@@ -191,6 +196,9 @@
     return chain(iterable, repeat(None))
 
 
+padnone = pad_none
+
+
 def ncycles(iterable, n):
     """Returns the sequence elements *n* times
 
@@ -250,16 +258,30 @@
     return starmap(func, repeat(args, times))
 
 
-def pairwise(iterable):
+def _pairwise(iterable):
     """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`.
+
     """
     a, b = tee(iterable)
     next(b, None)
-    return zip(a, b)
+    yield from zip(a, b)
+
+
+try:
+    from itertools import pairwise as itertools_pairwise
+except ImportError:
+    pairwise = _pairwise
+else:
+
+    def pairwise(iterable):
+        yield from itertools_pairwise(iterable)
+
+    pairwise.__doc__ = _pairwise.__doc__
 
 
 def grouper(iterable, n, fillvalue=None):
@@ -386,8 +408,10 @@
     seenset_add = seenset.add
     seenlist = 
     seenlist_add = seenlist.append
-    iterable, keys = tee(iterable)
-    for element, k in zip(iterable, map(key, keys) if key else keys):
+    use_key = key is not None
+
+    for element in iterable:
+        k = key(element) if use_key else element
         try:
             if k not in seenset:
                 seenset_add(k)
@@ -421,6 +445,16 @@
         >>> 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)))
+        
+
     """
     try:
         if first is not None:
@@ -530,6 +564,12 @@
     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.
     """
     pool = tuple(iterable)
     n = len(pool)
@@ -566,7 +606,93 @@
         >>> list(prepend(value, iterator))
         '0', '1', '2', '3'
 
-    To prepend multiple values, see :func:`itertools.chain`.
+    To prepend multiple values, see :func:`itertools.chain`
+    or :func:`value_chain`.
 
     """
     return chain(value, iterator)
+
+
+def convolve(signal, kernel):
+    """Convolve the iterable *signal* with the iterable *kernel*.
+
+        >>> signal = (1, 2, 3, 4, 5)
+        >>> kernel = 3, 2, 1
+        >>> list(convolve(signal, kernel))
+        3, 8, 14, 20, 26, 14, 5
+
+    Note: the input arguments are not interchangeable, as the *kernel*
+    is immediately consumed and stored.
+
+    """
+    kernel = tuple(kernel)::-1
+    n = len(kernel)
+    window = deque(0, maxlen=n) * n
+    for x in chain(signal, repeat(0, n - 1)):
+        window.append(x)
+        yield sum(map(operator.mul, kernel, window))
+
+
+def before_and_after(predicate, it):
+    """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.
+    """
+    it = iter(it)
+    transition = 
+
+    def true_iterator():
+        for elem in it:
+            if predicate(elem):
+                yield elem
+            else:
+                transition.append(elem)
+                return
+
+    def remainder_iterator():
+        yield from transition
+        yield from it
+
+    return true_iterator(), remainder_iterator()
+
+
+def triplewise(iterable):
+    """Return overlapping triplets from *iterable*.
+
+    >>> list(triplewise('ABCDE'))
+    ('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')
+
+    """
+    for (a, _), (b, c) in pairwise(pairwise(iterable)):
+        yield a, b, c
+
+
+def sliding_window(iterable, n):
+    """Return a sliding window of width *n* over *iterable*.
+
+        >>> list(sliding_window(range(6), 4))
+        (0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)
+
+    If *iterable* has fewer than *n* items, then nothing is yielded:
+
+        >>> list(sliding_window(range(3), 4))
+        
+
+    For a variant with more features, see :func:`windowed`.
+    """
+    it = iter(iterable)
+    window = deque(islice(it, n), maxlen=n)
+    if len(window) == n:
+        yield tuple(window)
+    for x in it:
+        window.append(x)
+        yield tuple(window)

_service:tar_scm:more-itertools-8.12.0.tar.gz/more_itertools/recipes.pyi Added

@@ -0,0 +1,112 @@
+"""Stubs for more_itertools.recipes"""
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+)
+from typing_extensions import overload, Type
+
+# Type and type variable definitions
+_T = TypeVar('_T')
+_U = TypeVar('_U')
+
+def take(n: int, iterable: Iterable_T) -> List_T: ...
+def tabulate(
+    function: Callableint, _T, start: int = ...
+) -> Iterator_T: ...
+def tail(n: int, iterable: Iterable_T) -> Iterator_T: ...
+def consume(iterator: Iterableobject, n: Optionalint = ...) -> None: ...
+@overload
+def nth(iterable: Iterable_T, n: int) -> Optional_T: ...
+@overload
+def nth(iterable: Iterable_T, n: int, default: _U) -> Union_T, _U: ...
+def all_equal(iterable: Iterableobject) -> bool: ...
+def quantify(
+    iterable: Iterable_T, pred: Callable_T, bool = ...
+) -> int: ...
+def pad_none(iterable: Iterable_T) -> IteratorOptional_T: ...
+def padnone(iterable: Iterable_T) -> IteratorOptional_T: ...
+def ncycles(iterable: Iterable_T, n: int) -> Iterator_T: ...
+def dotproduct(vec1: Iterableobject, vec2: Iterableobject) -> object: ...
+def flatten(listOfLists: IterableIterable_T) -> Iterator_T: ...
+def repeatfunc(
+    func: Callable..., _U, times: Optionalint = ..., *args: Any
+) -> Iterator_U: ...
+def pairwise(iterable: Iterable_T) -> IteratorTuple_T, _T: ...
+@overload
+def grouper(
+    iterable: Iterable_T, n: int
+) -> IteratorTupleOptional_T, ...: ...
+@overload
+def grouper(
+    iterable: Iterable_T, n: int, fillvalue: _U
+) -> IteratorTupleUnion_T, _U, ...: ...
+@overload
+def grouper(  # Deprecated interface
+    iterable: int, n: Iterable_T
+) -> IteratorTupleOptional_T, ...: ...
+@overload
+def grouper(  # Deprecated interface
+    iterable: int, n: Iterable_T, fillvalue: _U
+) -> IteratorTupleUnion_T, _U, ...: ...
+def roundrobin(*iterables: Iterable_T) -> Iterator_T: ...
+def partition(
+    pred: OptionalCallable_T, object, iterable: Iterable_T
+) -> TupleIterator_T, Iterator_T: ...
+def powerset(iterable: Iterable_T) -> IteratorTuple_T, ...: ...
+def unique_everseen(
+    iterable: Iterable_T, key: OptionalCallable_T, _U = ...
+) -> Iterator_T: ...
+def unique_justseen(
+    iterable: Iterable_T, key: OptionalCallable_T, object = ...
+) -> Iterator_T: ...
+@overload
+def iter_except(
+    func: Callable, _T,
+    exception: UnionTypeBaseException, TupleTypeBaseException, ...,
+    first: None = ...,
+) -> Iterator_T: ...
+@overload
+def iter_except(
+    func: Callable, _T,
+    exception: UnionTypeBaseException, TupleTypeBaseException, ...,
+    first: Callable, _U,
+) -> IteratorUnion_T, _U: ...
+@overload
+def first_true(
+    iterable: Iterable_T, *, pred: OptionalCallable_T, object = ...
+) -> Optional_T: ...
+@overload
+def first_true(
+    iterable: Iterable_T,
+    default: _U,
+    pred: OptionalCallable_T, object = ...,
+) -> Union_T, _U: ...
+def random_product(
+    *args: Iterable_T, repeat: int = ...
+) -> Tuple_T, ...: ...
+def random_permutation(
+    iterable: Iterable_T, r: Optionalint = ...
+) -> Tuple_T, ...: ...
+def random_combination(iterable: Iterable_T, r: int) -> Tuple_T, ...: ...
+def random_combination_with_replacement(
+    iterable: Iterable_T, r: int
+) -> Tuple_T, ...: ...
+def nth_combination(
+    iterable: Iterable_T, r: int, index: int
+) -> Tuple_T, ...: ...
+def prepend(value: _T, iterator: Iterable_U) -> IteratorUnion_T, _U: ...
+def convolve(signal: Iterable_T, kernel: Iterable_T) -> Iterator_T: ...
+def before_and_after(
+    predicate: Callable_T, bool, it: Iterable_T
+) -> TupleIterator_T, Iterator_T: ...
+def triplewise(iterable: Iterable_T) -> IteratorTuple_T, _T, _T: ...
+def sliding_window(
+    iterable: Iterable_T, n: int
+) -> IteratorTuple_T, ...: ...

_service:tar_scm:more-itertools-8.5.0.tar.gz/setup.cfg -> _service:tar_scm:more-itertools-8.12.0.tar.gz/setup.cfg Changed

_service:tar_scm:more-itertools-8.5.0.tar.gz/setup.py -> _service:tar_scm:more-itertools-8.12.0.tar.gz/setup.py Changed

_service:tar_scm:more-itertools-8.5.0.tar.gz/tests/test_more.py -> _service:tar_scm:more-itertools-8.12.0.tar.gz/tests/test_more.py Changed

@@ -1,3 +1,5 @@
+import warnings
+
 from collections import Counter, abc
 from collections.abc import Set
 from datetime import datetime, timedelta
@@ -12,6 +14,7 @@
     chain,
     combinations,
     count,
+    cycle,
     groupby,
     islice,
     permutations,
@@ -20,8 +23,9 @@
 )
 from operator import add, mul, itemgetter
 from pickle import loads, dumps
-from random import seed
+from random import seed, Random
 from statistics import mean
+from string import ascii_letters
 from sys import version_info
 from time import sleep
 from traceback import format_exc
@@ -99,6 +103,50 @@
             list(mi.chunked('ABCDE', 3)), 'A', 'B', 'C', 'D', 'E'
         )
 
+    def test_none(self):
+        """Test when ``n`` has the value ``None``."""
+        self.assertEqual(
+            list(mi.chunked('ABCDE', None)), 'A', 'B', 'C', 'D', 'E'
+        )
+
+    def test_strict_false(self):
+        """Test when ``n`` does not divide evenly into the length of the
+        iterable and strict is false.
+
+        """
+        self.assertEqual(
+            list(mi.chunked('ABCDE', 3, strict=False)),
+            'A', 'B', 'C', 'D', 'E',
+        )
+
+    def test_strict_being_true(self):
+        """Test when ``n`` does not divide evenly into the length of the
+        iterable and strict is True (raising an exception).
+
+        """
+
+        def f():
+            return list(mi.chunked('ABCDE', 3, strict=True))
+
+        self.assertRaisesRegex(ValueError, "iterable is not divisible by n", f)
+        self.assertEqual(
+            list(mi.chunked('ABCDEF', 3, strict=True)),
+            'A', 'B', 'C', 'D', 'E', 'F',
+        )
+
+    def test_strict_being_true_with_size_none(self):
+        """Test when ``n`` has value ``None`` and the keyword strict is True
+        (raising an exception).
+
+        """
+
+        def f():
+            return list(mi.chunked('ABCDE', None, strict=True))
+
+        self.assertRaisesRegex(
+            ValueError, "n must not be None when using strict mode.", f
+        )
+
 
 class FirstTests(TestCase):
     def test_many(self):
@@ -198,15 +246,22 @@
         self.assertRaises(ValueError, lambda: mi.nth_or_last(range(0), 0))
 
 
-class PeekableTests(TestCase):
-    """Tests for ``peekable()`` behavor not incidentally covered by testing
-    ``collate()``
+class PeekableMixinTests:
+    """Common tests for ``peekable()`` and ``seekable()`` behavior"""
 
-    """
+    cls = None
+
+    def test_passthrough(self):
+        """Iterating a peekable without using ``peek()`` or ``prepend()``
+        should just give the underlying iterable's elements (a trivial test but
+        useful to set a baseline in case something goes wrong)"""
+        expected = 1, 2, 3, 4, 5
+        actual = list(self.cls(expected))
+        self.assertEqual(actual, expected)
 
     def test_peek_default(self):
         """Make sure passing a default into ``peek()`` works."""
-        p = mi.peekable()
+        p = self.cls()
         self.assertEqual(p.peek(7), 7)
 
     def test_truthiness(self):
@@ -214,10 +269,10 @@
         the iterable.
 
         """
-        p = mi.peekable()
+        p = self.cls()
         self.assertFalse(p)
 
-        p = mi.peekable(range(3))
+        p = self.cls(range(3))
         self.assertTrue(p)
 
     def test_simple_peeking(self):
@@ -225,11 +280,21 @@
         iterator, respectively.
 
         """
-        p = mi.peekable(range(10))
+        p = self.cls(range(10))
         self.assertEqual(next(p), 0)
         self.assertEqual(p.peek(), 1)
+        self.assertEqual(p.peek(), 1)
         self.assertEqual(next(p), 1)
 
+
+class PeekableTests(PeekableMixinTests, TestCase):
+    """Tests for ``peekable()`` behavior not incidentally covered by testing
+    ``collate()``
+
+    """
+
+    cls = mi.peekable
+
     def test_indexing(self):
         """
         Indexing into the peekable shouldn't advance the iterator.
@@ -309,14 +374,6 @@
         self.assertEqual(old_cache, list(p._cache))
         self.assertEqual(list(p), list(iterable))
 
-    def test_passthrough(self):
-        """Iterating a peekable without using ``peek()`` or ``prepend()``
-        should just give the underlying iterable's elements (a trivial test but
-        useful to set a baseline in case something goes wrong)"""
-        expected = 1, 2, 3, 4, 5
-        actual = list(mi.peekable(expected))
-        self.assertEqual(actual, expected)
-
     # prepend() behavior tests
 
     def test_prepend(self):
@@ -546,6 +603,60 @@
         self.assertEqual(mi.ilen(list(range(6))), 6)
 
 
+class MinMaxTests(TestCase):
+    def test_basic(self):
+        for iterable, expected in (
+            # easy case
+            (0, 1, 2, 3, (0, 3)),
+            # min and max are not in the extremes + we have `int`s and `float`s
+            (3, 5.5, -1, 2, (-1, 5.5)),
+            # unordered collection
+            ({3, 5.5, -1, 2}, (-1, 5.5)),
+            # with repetitions
+            (3, 5.5, float('-Inf'), 5.5, (float('-Inf'), 5.5)),
+            # other collections
+            ('banana', ('a', 'n')),
+            ({0: 1, 2: 100, 1: 10}, (0, 2)),
+            (range(3, 14), (3, 13)),
+        ):
+            with self.subTest(iterable=iterable, expected=expected):
+                # check for expected results
+                self.assertTupleEqual(mi.minmax(iterable), expected)
+                # check for equality with built-in `min` and `max`
+                self.assertTupleEqual(
+                    mi.minmax(iterable), (min(iterable), max(iterable))
+                )
+
+    def test_unpacked(self):
+        self.assertTupleEqual(mi.minmax(2, 3, 1), (1, 3))
+        self.assertTupleEqual(mi.minmax(12, 3, 4, key=str), (12, 4))
+
+    def test_iterables(self):
+        self.assertTupleEqual(mi.minmax(x for x in 0, 1, 2, 3), (0, 3))
+        self.assertTupleEqual(
+            mi.minmax(map(str, 3, 5.5, 'a', 2)), ('2', 'a')
+        )
+        self.assertTupleEqual(
+            mi.minmax(filter(None, 0, 3, '', None, 10)), (3, 10)
+        )
+
+    def test_key(self):
+        self.assertTupleEqual(
+            mi.minmax({(), (1, 4, 2), 'abcde', range(4)}, key=len),
+            ((), 'abcde'),
+        )
+        self.assertTupleEqual(
+            mi.minmax((x for x in 10, 3, 25), key=str), (10, 3)
+        )
+
+    def test_default(self):
+        with self.assertRaises(ValueError):
+            mi.minmax()
+
+        self.assertIs(mi.minmax(, default=None), None)
+        self.assertListEqual(mi.minmax(, default=1, 'a'), 1, 'a')
+
+
 class WithIterTests(TestCase):
     def test_with_iter(self):
         s = StringIO('One fish\nTwo fish')
@@ -601,7 +712,7 @@
 
 
 class IntersperseTest(TestCase):
-    """ Tests for intersperse() """
+    """Tests for intersperse()"""
 
     def test_even(self):
         iterable = (x for x in '01')
@@ -977,6 +1088,110 @@
         self.assertEqual(actual, expected)
 
 
+class InterleaveEvenlyTests(TestCase):
+    def test_equal_lengths(self):
+        # when lengths are equal, the relative order shouldn't change
+        a = 1, 2, 3
+        b = 5, 6, 7
+        actual = list(mi.interleave_evenly(a, b))
+        expected = 1, 5, 2, 6, 3, 7
+        self.assertEqual(actual, expected)
+
+    def test_proportional(self):
+        # easy case where the iterables have proportional length
+        a = 1, 2, 3, 4
+        b = 5, 6
+        actual = list(mi.interleave_evenly(a, b))
+        expected = 1, 2, 5, 3, 4, 6
+        self.assertEqual(actual, expected)
+
+        # swapping a and b should yield the same result
+        actual_swapped = list(mi.interleave_evenly(b, a))
+        self.assertEqual(actual_swapped, expected)
+
+    def test_not_proportional(self):
+        a = 1, 2, 3, 4, 5, 6, 7
+        b = 8, 9, 10
+        expected = 1, 2, 8, 3, 4, 9, 5, 6, 10, 7
+        actual = list(mi.interleave_evenly(a, b))
+        self.assertEqual(actual, expected)
+
+    def test_degenerate_one(self):
+        a = 0, 1, 2, 3, 4
+        b = 5
+        expected = 0, 1, 2, 5, 3, 4
+        actual = list(mi.interleave_evenly(a, b))
+        self.assertEqual(actual, expected)
+
+    def test_degenerate_empty(self):
+        a = 1, 2, 3
+        b = 
+        expected = 1, 2, 3
+        actual = list(mi.interleave_evenly(a, b))
+        self.assertEqual(actual, expected)
+
+    def test_three_iters(self):
+        a = "a1", "a2", "a3", "a4", "a5"
+        b = "b1", "b2", "b3"
+        c = "c1"
+        actual = list(mi.interleave_evenly(a, b, c))
+        expected = "a1", "b1", "a2", "c1", "a3", "b2", "a4", "b3", "a5"
+        self.assertEqual(actual, expected)
+
+    def test_many_iters(self):
+        # smoke test with many iterables: create iterables with a random
+        # number of elements starting with a character ("a0", "a1", ...)
+        rng = Random(0)
+        iterables = 
+        for ch in ascii_letters:
+            length = rng.randint(0, 100)
+            iterable = f"{ch}{i}" for i in range(length)
+            iterables.append(iterable)
+
+        interleaved = list(mi.interleave_evenly(iterables))
+
+        # for each iterable, check that the result contains all its items
+        for iterable, ch_expect in zip(iterables, ascii_letters):
+            interleaved_actual = 
+                e for e in interleaved if e.startswith(ch_expect)
+            
+            assert len(set(interleaved_actual)) == len(iterable)
+
+    def test_manual_lengths(self):
+        a = combinations(range(4), 2)
+        len_a = 4 * (4 - 1) // 2  # == 6
+        b = combinations(range(4), 3)
+        len_b = 4
+
+        expected = 
+            (0, 1),
+            (0, 1, 2),
+            (0, 2),
+            (0, 3),
+            (0, 1, 3),
+            (1, 2),
+            (0, 2, 3),
+            (1, 3),
+            (2, 3),
+            (1, 2, 3),
+        
+        actual = list(mi.interleave_evenly(a, b, lengths=len_a, len_b))
+        self.assertEqual(expected, actual)
+
+    def test_no_length_raises(self):
+        # combinations doesn't have __len__, should trigger ValueError
+        iterables = range(5), combinations(range(5), 2)
+        with self.assertRaises(ValueError):
+            list(mi.interleave_evenly(iterables))
+
+    def test_argument_mismatch_raises(self):
+        # pass mismatching number of iterables and lengths
+        iterables = range(3)
+        lengths = 3, 4
+        with self.assertRaises(ValueError):
+            list(mi.interleave_evenly(iterables, lengths=lengths))
+
+
 class TestCollapse(TestCase):
     """Tests for ``collapse()``"""
 
@@ -1103,6 +1318,12 @@
         with self.assertRaises(TypeError):
             list(mi.sliced(seq, 3))
 
+    def test_odd_and_strict(self):
+        seq = x for x in 'ABCDEFGHI'
+
+        with self.assertRaises(ValueError):
+            list(mi.sliced(seq, 4, strict=True))
+
     def test_numpy_like_array(self):
         # Numpy arrays don't behave like Python lists - calling bool()
         # on them doesn't return False for empty lists and True for non-empty
@@ -1198,6 +1419,11 @@
         expected = 'o', 'o', 'o'
         self.assertEqual(actual, expected)
 
+    def test_empty_collection(self):
+        actual = list(mi.split_before(, lambda c: bool(c)))
+        expected = 
+        self.assertEqual(actual, expected)
+
     def test_max_split(self):
         for args, expected in 
             (
@@ -1615,6 +1841,41 @@
         )
 
 
+class RepeatEachTests(TestCase):
+    """Tests for repeat_each()"""
+
+    def test_default(self):
+        actual = list(mi.repeat_each('ABC'))
+        expected = 'A', 'A', 'B', 'B', 'C', 'C'
+        self.assertEqual(actual, expected)
+
+    def test_basic(self):
+        actual = list(mi.repeat_each('ABC', 3))
+        expected = 'A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C'
+        self.assertEqual(actual, expected)
+
+    def test_empty(self):
+        actual = list(mi.repeat_each(''))
+        expected = 
+        self.assertEqual(actual, expected)
+
+    def test_no_repeat(self):
+        actual = list(mi.repeat_each('ABC', 0))
+        expected = 
+        self.assertEqual(actual, expected)
+
+    def test_negative_repeat(self):
+        actual = list(mi.repeat_each('ABC', -1))
+        expected = 
+        self.assertEqual(actual, expected)
+
+    def test_infinite_input(self):
+        repeater = mi.repeat_each(cycle('AB'))
+        actual = mi.take(6, repeater)
+        expected = 'A', 'A', 'B', 'B', 'A', 'A'
+        self.assertEqual(actual, expected)
+
+
 class RepeatLastTests(TestCase):
     def test_empty_iterable(self):
         slice_length = 3
@@ -1703,7 +1964,16 @@
 
 
 class ZipEqualTest(TestCase):
-    """Tests for ``zip_equal()``"""
+    @skipIf(version_info:2 < (3, 10), 'zip_equal deprecated for 3.10+')
+    def test_deprecation(self):
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter('always')
+            self.assertEqual(
+                list(mi.zip_equal(1, 2, 3, 4)), (1, 3), (2, 4)
+            )
+
+        (warning,) = caught
+        assert warning.category == DeprecationWarning
 
     def test_equal(self):
         lists = 0, 1, 2, 2, 3, 4
@@ -1889,6 +2159,44 @@
             IndexError, lambda: mi.sort_together(iterables, key_list=(5,))
         )
 
+    def test_key_function(self):
+        """tests `key` function, including interaction with `key_list`"""
+        iterables = 
+            'GA', 'GA', 'GA', 'CT', 'CT', 'CT',
+            'May', 'Aug.', 'May', 'June', 'July', 'July',
+            97, 20, 100, 70, 100, 20,
+        
+        self.assertEqual(
+            mi.sort_together(iterables, key=lambda x: x),
+            
+                ('CT', 'CT', 'CT', 'GA', 'GA', 'GA'),
+                ('June', 'July', 'July', 'May', 'Aug.', 'May'),
+                (70, 100, 20, 97, 20, 100),
+            ,
+        )
+        self.assertEqual(
+            mi.sort_together(iterables, key=lambda x: x::-1),
+            
+                ('GA', 'GA', 'GA', 'CT', 'CT', 'CT'),
+                ('May', 'Aug.', 'May', 'June', 'July', 'July'),
+                (97, 20, 100, 70, 100, 20),
+            ,
+        )
+        self.assertEqual(
+            mi.sort_together(
+                iterables,
+                key_list=(0, 2),
+                key=lambda state, number: number
+                if state == 'CT'
+                else 2 * number,
+            ),
+            
+                ('CT', 'GA', 'CT', 'CT', 'GA', 'GA'),
+                ('July', 'Aug.', 'June', 'July', 'May', 'May'),
+                (20, 20, 70, 100, 97, 100),
+            ,
+        )
+
     def test_reverse(self):
         """tests `reverse` to ensure a reverse sort for `key_list` iterables"""
         iterables = 
@@ -3014,7 +3322,9 @@
         self.assertEqual(actual, original)
 
 
-class SeekableTest(TestCase):
+class SeekableTest(PeekableMixinTests, TestCase):
+    cls = mi.seekable
+
     def test_exhaustion_reset(self):
         iterable = str(n) for n in range(10)
 
@@ -3632,16 +3942,25 @@
             sleep(0.2)
             yield 3
 
-        iterable = generator()
-        actual = list(mi.time_limited(0.1, iterable))
+        iterable = mi.time_limited(0.1, generator())
+        actual = list(iterable)
         expected = 1, 2
         self.assertEqual(actual, expected)
+        self.assertTrue(iterable.timed_out)
+
+    def test_complete(self):
+        iterable = mi.time_limited(2, iter(range(10)))
+        actual = list(iterable)
+        expected = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+        self.assertEqual(actual, expected)
+        self.assertFalse(iterable.timed_out)
 
     def test_zero_limit(self):
-        iterable = count()
-        actual = list(mi.time_limited(0, iterable))
+        iterable = mi.time_limited(0, count())
+        actual = list(iterable)
         expected = 
         self.assertEqual(actual, expected)
+        self.assertTrue(iterable.timed_out)
 
     def test_invalid_limit(self):
         with self.assertRaises(ValueError):
@@ -3800,6 +4119,29 @@
         self.assertEqual(actual, expected)
 
 
+class MapIfTests(TestCase):
+    def test_without_func_else(self):
+        iterable = list(range(-5, 5))
+        actual = list(mi.map_if(iterable, lambda x: x > 3, lambda x: 'toobig'))
+        expected = -5, -4, -3, -2, -1, 0, 1, 2, 3, 'toobig'
+        self.assertEqual(actual, expected)
+
+    def test_with_func_else(self):
+        iterable = list(range(-5, 5))
+        actual = list(
+            mi.map_if(
+                iterable, lambda x: x >= 0, lambda x: 'notneg', lambda x: 'neg'
+            )
+        )
+        expected = 'neg' * 5 + 'notneg' * 5
+        self.assertEqual(actual, expected)
+
+    def test_empty(self):
+        actual = list(mi.map_if(, lambda x: len(x) > 5, lambda x: None))
+        expected = 
+        self.assertEqual(actual, expected)
+
+
 class SampleTests(TestCase):
     def test_unit_case(self):
         """Test against a fixed case by seeding the random module."""
@@ -3892,6 +4234,7 @@
     def test_basic(self):
         for iterable, kwargs, expected in 
             (, {}, True),
+            (1, {}, True),
             (1, 2, 3, {}, True),
             (1, 1, 2, 3, {}, True),
             (1, 10, 2, 3, {}, False),
@@ -3902,15 +4245,59 @@
             (1, 10, 2, 3, {'reverse': True}, False),
             ('3', '2', '10', '1', {'reverse': True}, True),
             ('3', '2', '10', '1', {'key': int, 'reverse': True}, False),
+            # strict
+            (, {'strict': True}, True),
+            (1, {'strict': True}, True),
+            (1, 1, {'strict': True}, False),
+            (1, 2, 3, {'strict': True}, True),
+            (1, 1, 2, 3, {'strict': True}, False),
+            (1, 10, 2, 3, {'strict': True}, False),
+            ('1', '10', '2', '3', {'strict': True}, True),
+            ('1', '10', '2', '3', '3', {'strict': True}, False),
+            ('1', '10', '2', '3', {'strict': True, 'key': int}, False),
+            (1, 2, 3, {'strict': True, 'reverse': True}, False),
+            (1, 1, 2, 3, {'strict': True, 'reverse': True}, False),
+            (1, 10, 2, 3, {'strict': True, 'reverse': True}, False),
+            ('3', '2', '10', '1', {'strict': True, 'reverse': True}, True),
+            (
+                '3', '2', '10', '10', '1',
+                {'strict': True, 'reverse': True},
+                False,
+            ),
+            (
+                '3', '2', '10', '1',
+                {'strict': True, 'key': int, 'reverse': True},
+                False,
+            ),
             # We'll do the same weird thing as Python here
             ('nan', 0, 'nan', 0, {'key': float}, True),
             (0, 'nan', 0, 'nan', {'key': float}, True),
             ('nan', 0, 'nan', 0, {'key': float, 'reverse': True}, True),
             (0, 'nan', 0, 'nan', {'key': float, 'reverse': True}, True),
+            (0, 'nan', 0, 'nan', {'strict': True, 'key': float}, True),
+            (
+                'nan', 0, 'nan', 0,
+                {'strict': True, 'key': float, 'reverse': True},
+                True,
+            ),
         :
-            with self.subTest(args=(iterable, kwargs)):
-                mi_result = mi.is_sorted(iter(iterable), **kwargs)
-                py_result = iterable == sorted(iterable, **kwargs)
+            key = kwargs.get('key', None)
+            reverse = kwargs.get('reverse', False)
+            strict = kwargs.get('strict', False)
+
+            with self.subTest(
+                iterable=iterable, key=key, reverse=reverse, strict=strict
+            ):
+                mi_result = mi.is_sorted(
+                    iter(iterable), key=key, reverse=reverse, strict=strict
+                )
+
+                sorted_iterable = sorted(iterable, key=key, reverse=reverse)
+                if strict:
+                    sorted_iterable = list(mi.unique_justseen(sorted_iterable))
+
+                py_result = iterable == sorted_iterable
+
                 self.assertEqual(mi_result, expected)
                 self.assertEqual(mi_result, py_result)
 
@@ -4046,3 +4433,601 @@
             (('A',), ('B', 'C'), ()),
         
         self.assertEqual(actual, expected)
+
+
+class AllUniqueTests(TestCase):
+    def test_basic(self):
+        for iterable, expected in 
+            (, True),
+            (1, 2, 3, True),
+            (1, 1, False),
+            (1, 2, 3, 1, False),
+            (1, 2, 3, '1', True),
+        :
+            with self.subTest(args=(iterable,)):
+                self.assertEqual(mi.all_unique(iterable), expected)
+
+    def test_non_hashable(self):
+        self.assertEqual(mi.all_unique(1, 2, 3, 4), True)
+        self.assertEqual(mi.all_unique(1, 2, 3, 4, 1, 2), False)
+
+    def test_partially_hashable(self):
+        self.assertEqual(mi.all_unique(1, 2, 3, 4, (5, 6)), True)
+        self.assertEqual(
+            mi.all_unique(1, 2, 3, 4, (5, 6), 1, 2), False
+        )
+        self.assertEqual(
+            mi.all_unique(1, 2, 3, 4, (5, 6), (5, 6)), False
+        )
+
+    def test_key(self):
+        iterable = 'A', 'B', 'C', 'b'
+        self.assertEqual(mi.all_unique(iterable, lambda x: x), True)
+        self.assertEqual(mi.all_unique(iterable, str.lower), False)
+
+    def test_infinite(self):
+        self.assertEqual(mi.all_unique(mi.prepend(3, count())), False)
+
+
+class NthProductTests(TestCase):
+    def test_basic(self):
+        iterables = 'ab', 'cdef', 'ghi'
+        for index, expected in enumerate(product(*iterables)):
+            actual = mi.nth_product(index, *iterables)
+            self.assertEqual(actual, expected)
+
+    def test_long(self):
+        actual = mi.nth_product(1337, range(101), range(22), range(53))
+        expected = (1, 3, 12)
+        self.assertEqual(actual, expected)
+
+    def test_negative(self):
+        iterables = 'abc', 'de', 'fghi'
+        for index, expected in enumerate(product(*iterables)):
+            actual = mi.nth_product(index - 24, *iterables)
+            self.assertEqual(actual, expected)
+
+    def test_invalid_index(self):
+        with self.assertRaises(IndexError):
+            mi.nth_product(24, 'ab', 'cde', 'fghi')
+
+
+class ValueChainTests(TestCase):
+    def test_empty(self):
+        actual = list(mi.value_chain())
+        expected = 
+        self.assertEqual(actual, expected)
+
+    def test_simple(self):
+        actual = list(mi.value_chain(1, 2.71828, False, 'foo'))
+        expected = 1, 2.71828, False, 'foo'
+        self.assertEqual(actual, expected)
+
+    def test_more(self):
+        actual = list(mi.value_chain(b'bar', 1, 2, 3, 4, {'key': 1}))
+        expected = b'bar', 1, 2, 3, 4, 'key'
+        self.assertEqual(actual, expected)
+
+    def test_empty_lists(self):
+        actual = list(mi.value_chain(1, 2, , 3, 4))
+        expected = 1, 2, 3, 4
+        self.assertEqual(actual, expected)
+
+    def test_complex(self):
+        obj = object()
+        actual = list(
+            mi.value_chain(
+                (1, (2, (3,))),
+                'foo', 'bar', 'baz', 'tic',
+                {'key': {'foo': 1}},
+                obj,
+            )
+        )
+        expected = 1, (2, (3,)), 'foo', 'bar', 'baz', 'tic', 'key', obj
+        self.assertEqual(actual, expected)
+
+
+class ProductIndexTests(TestCase):
+    def test_basic(self):
+        iterables = 'ab', 'cdef', 'ghi'
+        first_index = {}
+        for index, element in enumerate(product(*iterables)):
+            actual = mi.product_index(element, *iterables)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_multiplicity(self):
+        iterables = 'ab', 'bab', 'cab'
+        first_index = {}
+        for index, element in enumerate(product(*iterables)):
+            actual = mi.product_index(element, *iterables)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_long(self):
+        actual = mi.product_index((1, 3, 12), range(101), range(22), range(53))
+        expected = 1337
+        self.assertEqual(actual, expected)
+
+    def test_invalid_empty(self):
+        with self.assertRaises(ValueError):
+            mi.product_index('', 'ab', 'cde', 'fghi')
+
+    def test_invalid_small(self):
+        with self.assertRaises(ValueError):
+            mi.product_index('ac', 'ab', 'cde', 'fghi')
+
+    def test_invalid_large(self):
+        with self.assertRaises(ValueError):
+            mi.product_index('achi', 'ab', 'cde', 'fghi')
+
+    def test_invalid_match(self):
+        with self.assertRaises(ValueError):
+            mi.product_index('axf', 'ab', 'cde', 'fghi')
+
+
+class CombinationIndexTests(TestCase):
+    def test_r_less_than_n(self):
+        iterable = 'abcdefg'
+        r = 4
+        first_index = {}
+        for index, element in enumerate(combinations(iterable, r)):
+            actual = mi.combination_index(element, iterable)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_r_equal_to_n(self):
+        iterable = 'abcd'
+        r = len(iterable)
+        first_index = {}
+        for index, element in enumerate(combinations(iterable, r=r)):
+            actual = mi.combination_index(element, iterable)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_multiplicity(self):
+        iterable = 'abacba'
+        r = 3
+        first_index = {}
+        for index, element in enumerate(combinations(iterable, r)):
+            actual = mi.combination_index(element, iterable)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_null(self):
+        actual = mi.combination_index(tuple(), )
+        expected = 0
+        self.assertEqual(actual, expected)
+
+    def test_long(self):
+        actual = mi.combination_index((2, 12, 35, 126), range(180))
+        expected = 2000000
+        self.assertEqual(actual, expected)
+
+    def test_invalid_order(self):
+        with self.assertRaises(ValueError):
+            mi.combination_index(tuple('acb'), 'abcde')
+
+    def test_invalid_large(self):
+        with self.assertRaises(ValueError):
+            mi.combination_index(tuple('abcdefg'), 'abcdef')
+
+    def test_invalid_match(self):
+        with self.assertRaises(ValueError):
+            mi.combination_index(tuple('axe'), 'abcde')
+
+
+class PermutationIndexTests(TestCase):
+    def test_r_less_than_n(self):
+        iterable = 'abcdefg'
+        r = 4
+        first_index = {}
+        for index, element in enumerate(permutations(iterable, r)):
+            actual = mi.permutation_index(element, iterable)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_r_equal_to_n(self):
+        iterable = 'abcd'
+        first_index = {}
+        for index, element in enumerate(permutations(iterable)):
+            actual = mi.permutation_index(element, iterable)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_multiplicity(self):
+        iterable = 'abacba'
+        r = 3
+        first_index = {}
+        for index, element in enumerate(permutations(iterable, r)):
+            actual = mi.permutation_index(element, iterable)
+            expected = first_index.setdefault(element, index)
+            self.assertEqual(actual, expected)
+
+    def test_null(self):
+        actual = mi.permutation_index(tuple(), )
+        expected = 0
+        self.assertEqual(actual, expected)
+
+    def test_long(self):
+        actual = mi.permutation_index((2, 12, 35, 126), range(180))
+        expected = 11631678
+        self.assertEqual(actual, expected)
+
+    def test_invalid_large(self):
+        with self.assertRaises(ValueError):
+            mi.permutation_index(tuple('abcdefg'), 'abcdef')
+
+    def test_invalid_match(self):
+        with self.assertRaises(ValueError):
+            mi.permutation_index(tuple('axe'), 'abcde')
+
+
+class CountableTests(TestCase):
+    def test_empty(self):
+        iterable = 
+        it = mi.countable(iterable)
+        self.assertEqual(it.items_seen, 0)
+        self.assertEqual(list(it), )
+
+    def test_basic(self):
+        iterable = '0123456789'
+        it = mi.countable(iterable)
+        self.assertEqual(it.items_seen, 0)
+        self.assertEqual(next(it), '0')
+        self.assertEqual(it.items_seen, 1)
+        self.assertEqual(''.join(it), '123456789')
+        self.assertEqual(it.items_seen, 10)
+
+
+class ChunkedEvenTests(TestCase):
+    """Tests for ``chunked_even()``"""
+
+    def test_0(self):
+        self._test_finite('', 3, )
+
+    def test_1(self):
+        self._test_finite('A', 1, 'A')
+
+    def test_4(self):
+        self._test_finite('ABCD', 3, 'A', 'B', 'C', 'D')
+
+    def test_5(self):
+        self._test_finite('ABCDE', 3, 'A', 'B', 'C', 'D', 'E')
+
+    def test_6(self):
+        self._test_finite('ABCDEF', 3, 'A', 'B', 'C', 'D', 'E', 'F')
+
+    def test_7(self):
+        self._test_finite(
+            'ABCDEFG', 3, 'A', 'B', 'C', 'D', 'E', 'F', 'G'
+        )
+
+    def _test_finite(self, seq, n, expected):
+        # Check with and without `len()`
+        self.assertEqual(list(mi.chunked_even(seq, n)), expected)
+        self.assertEqual(list(mi.chunked_even(iter(seq), n)), expected)
+
+    def test_infinite(self):
+        for n in range(1, 5):
+            k = 0
+
+            def count_with_assert():
+                for i in count():
+                    # Look-ahead should be less than n^2
+                    self.assertLessEqual(i, n * k + n * n)
+                    yield i
+
+            ls = mi.chunked_even(count_with_assert(), n)
+            while k < 2:
+                self.assertEqual(next(ls), list(range(k * n, (k + 1) * n)))
+                k += 1
+
+    def test_evenness(self):
+        for N in range(1, 50):
+            for n in range(1, N + 2):
+                lengths = 
+                items = 
+                for l in mi.chunked_even(range(N), n):
+                    L = len(l)
+                    self.assertLessEqual(L, n)
+                    self.assertGreaterEqual(L, 1)
+                    lengths.append(L)
+                    items.extend(l)
+                self.assertEqual(items, list(range(N)))
+                self.assertLessEqual(max(lengths) - min(lengths), 1)
+
+
+class ZipBroadcastTests(TestCase):
+    def test_basic(self):
+        for objects, expected in 
+            # All scalar
+            (1, 2, (1, 2)),
+            # Scalar, iterable
+            (1, 2, (1, 2)),
+            # Iterable, scalar
+            (1, 2, (1, 2)),
+            # Mixed length
+            (1, 2, 3, (1, 2), (1, 3)),
+            # All iterable
+            (1, 2, 3, 4, (1, 3), (2, 4)),
+            # Infinite
+            (count(), 1, 2, (0, 1, 2)),
+            (count(), 1, 2, 3, (0, 1, 2), (1, 1, 3)),
+        :
+            with self.subTest(expected=expected):
+                actual = list(mi.zip_broadcast(*objects))
+                self.assertEqual(actual, expected)
+
+    def test_scalar_types(self):
+        # Default: str and bytes are treated as scalar
+        self.assertEqual(
+            list(mi.zip_broadcast('ab', 1, 2, 3)),
+            ('ab', 1), ('ab', 2), ('ab', 3),
+        )
+        self.assertEqual(
+            list(mi.zip_broadcast(b'ab', 1, 2, 3)),
+            (b'ab', 1), (b'ab', 2), (b'ab', 3),
+        )
+        # scalar_types=None allows str and bytes to be treated as iterable
+        self.assertEqual(
+            list(mi.zip_broadcast('abc', 1, 2, 3, scalar_types=None)),
+            ('a', 1), ('b', 2), ('c', 3),
+        )
+        # Use a custom type
+        self.assertEqual(
+            list(mi.zip_broadcast({'a': 'b'}, 1, 2, 3, scalar_types=dict)),
+            ({'a': 'b'}, 1), ({'a': 'b'}, 2), ({'a': 'b'}, 3),
+        )
+
+    def test_strict(self):
+        for objects, zipped in 
+            (, 1, ),
+            (1, , ),
+            (1, 2, 3, (1, 2)),
+            (1, 2, 3, (1, 3)),
+            (1, 2, 3, 4, (1, 3, 4)),
+            (1, 2, 3, 4, (1, 2, 4)),
+            (1, 2, 3, 4, (1, 2, 3)),
+            (1, 2, 3, 4, 5, (1, 2, 4)),
+            (1, 2, 3, 4, 5, (1, 3, 4)),
+            (1, 2, 3, 4, 5, (1, 3, 5)),
+            ('a', 1, 2, 3, 4, 5, ('a', 1, 3), ('a', 2, 4)),
+        :
+            # Truncate by default
+            with self.subTest(objects=objects, strict=False, zipped=zipped):
+                self.assertEqual(list(mi.zip_broadcast(*objects)), zipped)
+
+            # Raise an exception for strict=True
+            with self.subTest(objects=objects, strict=True):
+                with self.assertRaises(ValueError):
+                    list(mi.zip_broadcast(*objects, strict=True))
+
+    def test_empty(self):
+        self.assertEqual(list(mi.zip_broadcast()), )
+
+
+class UniqueInWindowTests(TestCase):
+    def test_invalid_n(self):
+        with self.assertRaises(ValueError):
+            list(mi.unique_in_window(, 0))
+
+    def test_basic(self):
+        for iterable, n, expected in 
+            (range(9), 10, list(range(9))),
+            (range(20), 10, list(range(20))),
+            (1, 2, 3, 4, 4, 4, 1, 1, 2, 3, 4),
+            (1, 2, 3, 4, 4, 4, 2, 1, 2, 3, 4),
+            (1, 2, 3, 4, 4, 4, 3, 1, 2, 3, 4),
+            (1, 2, 3, 4, 4, 4, 4, 1, 2, 3, 4),
+            (1, 2, 3, 4, 4, 4, 5, 1, 2, 3, 4),
+        :
+            with self.subTest(expected=expected):
+                actual = list(mi.unique_in_window(iterable, n))
+                self.assertEqual(actual, expected)
+
+    def test_key(self):
+        iterable = 0, 1, 3, 4, 5, 6, 7, 8, 9
+        n = 3
+        key = lambda x: x // 3
+        actual = list(mi.unique_in_window(iterable, n, key=key))
+        expected = 0, 3, 6, 9
+        self.assertEqual(actual, expected)
+
+
+class StrictlyNTests(TestCase):
+    def test_basic(self):
+        iterable = 'a', 'b', 'c', 'd'
+        n = 4
+        actual = list(mi.strictly_n(iter(iterable), n))
+        expected = iterable
+        self.assertEqual(actual, expected)
+
+    def test_too_short_default(self):
+        iterable = 'a', 'b', 'c', 'd'
+        n = 5
+        with self.assertRaises(ValueError) as exc:
+            list(mi.strictly_n(iter(iterable), n))
+
+        self.assertEqual(
+            'Too few items in iterable (got 4)', exc.exception.args0
+        )
+
+    def test_too_long_default(self):
+        iterable = 'a', 'b', 'c', 'd'
+        n = 3
+        with self.assertRaises(ValueError) as cm:
+            list(mi.strictly_n(iter(iterable), n))
+
+        self.assertEqual(
+            'Too many items in iterable (got at least 4)',
+            cm.exception.args0,
+        )
+
+    def test_too_short_custom(self):
+        call_count = 0
+
+        def too_short(item_count):
+            nonlocal call_count
+            call_count += 1
+
+        iterable = 'a', 'b', 'c', 'd'
+        n = 6
+        actual = 
+        for item in mi.strictly_n(iter(iterable), n, too_short=too_short):
+            actual.append(item)
+        expected = 'a', 'b', 'c', 'd'
+        self.assertEqual(actual, expected)
+        self.assertEqual(call_count, 1)
+
+    def test_too_long_custom(self):
+        import logging
+
+        iterable = 'a', 'b', 'c', 'd'
+        n = 2
+        too_long = lambda item_count: logging.warning(
+            'Picked the first %s items', n
+        )
+
+        with self.assertLogs(level='WARNING') as cm:
+            actual = list(mi.strictly_n(iter(iterable), n, too_long=too_long))
+
+        self.assertEqual(actual, 'a', 'b')
+        self.assertIn('Picked the first 2 items', cm.output0)
+
+
+class DuplicatesEverSeenTests(TestCase):
+    def test_basic(self):
+        for iterable, expected in 
+            (, ),
+            (1, 2, 3, ),
+            (1, 1, 1),
+            (1, 2, 1, 2, 1, 2),
+            (1, 2, 3, '1', ),
+        :
+            with self.subTest(args=(iterable,)):
+                self.assertEqual(
+                    list(mi.duplicates_everseen(iterable)), expected
+                )
+
+    def test_non_hashable(self):
+        self.assertEqual(list(mi.duplicates_everseen(1, 2, 3, 4)), )
+        self.assertEqual(
+            list(mi.duplicates_everseen(1, 2, 3, 4, 1, 2)), 1, 2
+        )
+
+    def test_partially_hashable(self):
+        self.assertEqual(
+            list(mi.duplicates_everseen(1, 2, 3, 4, (5, 6))), 
+        )
+        self.assertEqual(
+            list(mi.duplicates_everseen(1, 2, 3, 4, (5, 6), 1, 2)),
+            1, 2,
+        )
+        self.assertEqual(
+            list(mi.duplicates_everseen(1, 2, 3, 4, (5, 6), (5, 6))),
+            (5, 6),
+        )
+
+    def test_key_hashable(self):
+        iterable = 'HEheHEhe'
+        self.assertEqual(list(mi.duplicates_everseen(iterable)), list('HEhe'))
+        self.assertEqual(
+            list(mi.duplicates_everseen(iterable, str.lower)),
+            list('heHEhe'),
+        )
+
+    def test_key_non_hashable(self):
+        iterable = 1, 2, 3, 0, 5, -2, 5, 6
+        self.assertEqual(
+            list(mi.duplicates_everseen(iterable, lambda x: x)), 
+        )
+        self.assertEqual(
+            list(mi.duplicates_everseen(iterable, sum)), 3, 0, 5, -2
+        )
+
+    def test_key_partially_hashable(self):
+        iterable = 1, 2, (1, 2), 1, 2, 5, 6
+        self.assertEqual(
+            list(mi.duplicates_everseen(iterable, lambda x: x)), 1, 2
+        )
+        self.assertEqual(
+            list(mi.duplicates_everseen(iterable, list)), (1, 2), 1, 2
+        )
+
+
+class DuplicatesJustSeenTests(TestCase):
+    def test_basic(self):
+        for iterable, expected in 
+            (, ),
+            (1, 2, 3, 3, 2, 2, 3, 2),
+            (1, 1, 1),
+            (1, 2, 1, 2, ),
+            (1, 2, 3, '1', ),
+        :
+            with self.subTest(args=(iterable,)):
+                self.assertEqual(
+                    list(mi.duplicates_justseen(iterable)), expected
+                )
+
+    def test_non_hashable(self):
+        self.assertEqual(list(mi.duplicates_justseen(1, 2, 3, 4)), )
+        self.assertEqual(
+            list(
+                mi.duplicates_justseen(
+                    1, 2, 3, 4, 3, 4, 3, 4, 1, 2
+                )
+            ),
+            3, 4, 3, 4,
+        )
+
+    def test_partially_hashable(self):
+        self.assertEqual(
+            list(mi.duplicates_justseen(1, 2, 3, 4, (5, 6))), 
+        )
+        self.assertEqual(
+            list(
+                mi.duplicates_justseen(
+                    1, 2, 3, 4, (5, 6), 1, 2, 1, 2
+                )
+            ),
+            1, 2,
+        )
+        self.assertEqual(
+            list(
+                mi.duplicates_justseen(
+                    1, 2, 3, 4, (5, 6), (5, 6), (5, 6)
+                )
+            ),
+            (5, 6), (5, 6),
+        )
+
+    def test_key_hashable(self):
+        iterable = 'HEheHHHhEheeEe'
+        self.assertEqual(list(mi.duplicates_justseen(iterable)), list('HHe'))
+        self.assertEqual(
+            list(mi.duplicates_justseen(iterable, str.lower)),
+            list('HHheEe'),
+        )
+
+    def test_key_non_hashable(self):
+        iterable = 1, 2, 3, 0, 5, -2, 5, 6, 1, 2
+        self.assertEqual(
+            list(mi.duplicates_justseen(iterable, lambda x: x)), 
+        )
+        self.assertEqual(
+            list(mi.duplicates_justseen(iterable, sum)), 3, 0, 5, -2
+        )
+
+    def test_key_partially_hashable(self):
+        iterable = 1, 2, (1, 2), 1, 2, 5, 6, 1, 2
+        self.assertEqual(
+            list(mi.duplicates_justseen(iterable, lambda x: x)), 
+        )
+        self.assertEqual(
+            list(mi.duplicates_justseen(iterable, list)), (1, 2), 1, 2
+        )
+
+    def test_nested(self):
+        iterable = 1, 2, 1, 2, 5, 6, 5, 6
+        self.assertEqual(list(mi.duplicates_justseen(iterable)), 5, 6)

_service:tar_scm:more-itertools-8.5.0.tar.gz/tests/test_recipes.py -> _service:tar_scm:more-itertools-8.12.0.tar.gz/tests/test_recipes.py Changed

@@ -1,9 +1,10 @@
 import warnings
+
 from doctest import DocTestSuite
+from itertools import combinations, count, permutations
+from math import factorial
 from unittest import TestCase
 
-from itertools import combinations
-
 import more_itertools as mi
 
 
@@ -165,13 +166,14 @@
 
 
 class PadnoneTests(TestCase):
-    """Tests for ``padnone()``"""
-
-    def test_happy_path(self):
-        """wrapper iterator should return None indefinitely"""
-        r = range(2)
-        p = mi.padnone(r)
-        self.assertEqual(0, 1, None, None, next(p) for _ in range(4))
+    def test_basic(self):
+        iterable = range(2)
+        for func in (mi.pad_none, mi.padnone):
+            with self.subTest(func=func):
+                p = func(iterable)
+                self.assertEqual(
+                    0, 1, None, None, next(p) for _ in range(4)
+                )
 
 
 class NcyclesTests(TestCase):
@@ -413,6 +415,30 @@
         i = mi.iter_except(l.pop, IndexError, f)
         self.assertEqual(list(i), 25, 3, 2, 1)
 
+    def test_multiple(self):
+        """ensure can catch multiple exceptions"""
+
+        class Fiz(Exception):
+            pass
+
+        class Buzz(Exception):
+            pass
+
+        i = 0
+
+        def fizbuzz():
+            nonlocal i
+            i += 1
+            if i % 3 == 0:
+                raise Fiz
+            if i % 5 == 0:
+                raise Buzz
+            return i
+
+        expected = (1, 2, 4, , 7, 8, )
+        for x in expected:
+            self.assertEqual(list(mi.iter_except(fizbuzz, (Fiz, Buzz))), x)
+
 
 class FirstTrueTests(TestCase):
     """Tests for ``first_true()``"""
@@ -587,6 +613,58 @@
             mi.nth_combination('abcdefg', 3, -36)
 
 
+class NthPermutationTests(TestCase):
+    def test_r_less_than_n(self):
+        iterable = 'abcde'
+        r = 4
+        for index, expected in enumerate(permutations(iterable, r)):
+            actual = mi.nth_permutation(iterable, r, index)
+            self.assertEqual(actual, expected)
+
+    def test_r_equal_to_n(self):
+        iterable = 'abcde'
+        for index, expected in enumerate(permutations(iterable)):
+            actual = mi.nth_permutation(iterable, None, index)
+            self.assertEqual(actual, expected)
+
+    def test_long(self):
+        iterable = tuple(range(180))
+        r = 4
+        index = 1000000
+        actual = mi.nth_permutation(iterable, r, index)
+        expected = mi.nth(permutations(iterable, r), index)
+        self.assertEqual(actual, expected)
+
+    def test_null(self):
+        actual = mi.nth_permutation(, 0, 0)
+        expected = tuple()
+        self.assertEqual(actual, expected)
+
+    def test_negative_index(self):
+        iterable = 'abcde'
+        r = 4
+        n = factorial(len(iterable)) // factorial(len(iterable) - r)
+        for index, expected in enumerate(permutations(iterable, r)):
+            actual = mi.nth_permutation(iterable, r, index - n)
+            self.assertEqual(actual, expected)
+
+    def test_invalid_index(self):
+        iterable = 'abcde'
+        r = 4
+        n = factorial(len(iterable)) // factorial(len(iterable) - r)
+        for index in -1 - n, n + 1:
+            with self.assertRaises(IndexError):
+                mi.nth_combination(iterable, r, index)
+
+    def test_invalid_r(self):
+        iterable = 'abcde'
+        r = 4
+        n = factorial(len(iterable)) // factorial(len(iterable) - r)
+        for r in -1, n + 1:
+            with self.assertRaises(ValueError):
+                mi.nth_combination(iterable, r, 0)
+
+
 class PrependTests(TestCase):
     def test_basic(self):
         value = 'a'
@@ -601,3 +679,87 @@
         actual = tuple(mi.prepend(value, iterator))
         expected = ('ab',) + tuple('cdefg')
         self.assertEqual(actual, expected)
+
+
+class Convolvetests(TestCase):
+    def test_moving_average(self):
+        signal = iter(10, 20, 30, 40, 50)
+        kernel = 0.5, 0.5
+        actual = list(mi.convolve(signal, kernel))
+        expected = 
+            (10 + 0) / 2,
+            (20 + 10) / 2,
+            (30 + 20) / 2,
+            (40 + 30) / 2,
+            (50 + 40) / 2,
+            (0 + 50) / 2,
+        
+        self.assertEqual(actual, expected)
+
+    def test_derivative(self):
+        signal = iter(10, 20, 30, 40, 50)
+        kernel = 1, -1
+        actual = list(mi.convolve(signal, kernel))
+        expected = 10 - 0, 20 - 10, 30 - 20, 40 - 30, 50 - 40, 0 - 50
+        self.assertEqual(actual, expected)
+
+    def test_infinite_signal(self):
+        signal = count()
+        kernel = 1, -1
+        actual = mi.take(5, mi.convolve(signal, kernel))
+        expected = 0, 1, 1, 1, 1
+        self.assertEqual(actual, expected)
+
+
+class BeforeAndAfterTests(TestCase):
+    def test_empty(self):
+        before, after = mi.before_and_after(bool, )
+        self.assertEqual(list(before), )
+        self.assertEqual(list(after), )
+
+    def test_never_true(self):
+        before, after = mi.before_and_after(bool, 0, False, None, '')
+        self.assertEqual(list(before), )
+        self.assertEqual(list(after), 0, False, None, '')
+
+    def test_never_false(self):
+        before, after = mi.before_and_after(bool, 1, True, Ellipsis, ' ')
+        self.assertEqual(list(before), 1, True, Ellipsis, ' ')
+        self.assertEqual(list(after), )
+
+    def test_some_true(self):
+        before, after = mi.before_and_after(bool, 1, True, 0, False)
+        self.assertEqual(list(before), 1, True)
+        self.assertEqual(list(after), 0, False)
+
+
+class TriplewiseTests(TestCase):
+    def test_basic(self):
+        for iterable, expected in 
+            (0, ),
+            (0, 1, ),
+            (0, 1, 2, (0, 1, 2)),
+            (0, 1, 2, 3, (0, 1, 2), (1, 2, 3)),
+            (0, 1, 2, 3, 4, (0, 1, 2), (1, 2, 3), (2, 3, 4)),
+        :
+            with self.subTest(expected=expected):
+                actual = list(mi.triplewise(iterable))
+                self.assertEqual(actual, expected)
+
+
+class SlidingWindowTests(TestCase):
+    def test_basic(self):
+        for iterable, n, expected in 
+            (, 0, ()),
+            (, 1, ),
+            (0, 1, (0,)),
+            (0, 1, 1, (0,), (1,)),
+            (0, 1, 2, 2, (0, 1), (1, 2)),
+            (0, 1, 2, 3, (0, 1, 2)),
+            (0, 1, 2, 4, ),
+            (0, 1, 2, 3, 4, (0, 1, 2, 3)),
+            (0, 1, 2, 3, 4, 4, (0, 1, 2, 3), (1, 2, 3, 4)),
+        :
+            with self.subTest(expected=expected):
+                actual = list(mi.sliding_window(iterable, n))
+                self.assertEqual(actual, expected)

_service:tar_scm:more-itertools-8.5.0.tar.gz/tox.ini -> _service:tar_scm:more-itertools-8.12.0.tar.gz/tox.ini Changed

_service:tar_scm:more-itertools-8.5.0.tar.gz/PKG-INFO Deleted

@@ -1,405 +0,0 @@
-Metadata-Version: 2.1
-Name: more-itertools
-Version: 8.5.0
-Summary: More routines for operating on iterables, beyond itertools
-Home-page: https://github.com/more-itertools/more-itertools
-Author: Erik Rose
-Author-email: erikrose@grinchcentral.com
-License: MIT
-Description: ==============
-        More Itertools
-        ==============
-        
-        .. image:: https://readthedocs.org/projects/more-itertools/badge/?version=latest
-          :target: https://more-itertools.readthedocs.io/en/stable/
-        
-        Python's ``itertools`` library is a gem - you can compose elegant solutions
-        for a variety of problems with the functions it provides. In ``more-itertools``
-        we collect additional building blocks, recipes, and routines for working with
-        Python iterables.
-        
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Grouping               | `chunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.chunked>`_,                                                                                                                        |
-        |                        | `ichunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ichunked>`_,                                                                                                                      |
-        |                        | `sliced <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sliced>`_,                                                                                                                          |
-        |                        | `distribute <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distribute>`_,                                                                                                                  |
-        |                        | `divide <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.divide>`_,                                                                                                                          |
-        |                        | `split_at <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_at>`_,                                                                                                                      |
-        |                        | `split_before <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_before>`_,                                                                                                              |
-        |                        | `split_after <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_after>`_,                                                                                                                |
-        |                        | `split_into <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_into>`_,                                                                                                                  |
-        |                        | `split_when <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_when>`_,                                                                                                                  |
-        |                        | `bucket <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.bucket>`_,                                                                                                                          |
-        |                        | `unzip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unzip>`_,                                                                                                                            |
-        |                        | `grouper <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.grouper>`_,                                                                                                                        |
-        |                        | `partition <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partition>`_                                                                                                                     |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Lookahead and lookback | `spy <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.spy>`_,                                                                                                                                |
-        |                        | `peekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.peekable>`_,                                                                                                                      |
-        |                        | `seekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.seekable>`_                                                                                                                       |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Windowing              | `windowed <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.windowed>`_,                                                                                                                      |
-        |                        | `substrings <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings>`_,                                                                                                                  |
-        |                        | `substrings_indexes <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings_indexes>`_,                                                                                                  |
-        |                        | `stagger <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.stagger>`_,                                                                                                                        |
-        |                        | `pairwise <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.pairwise>`_                                                                                                                       |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Augmenting             | `count_cycle <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.count_cycle>`_,                                                                                                                |
-        |                        | `intersperse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.intersperse>`_,                                                                                                                |
-        |                        | `padded <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padded>`_,                                                                                                                          |
-        |                        | `mark_ends <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.mark_ends>`_,                                                                                                                    |
-        |                        | `repeat_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeat_last>`_,                                                                                                                |
-        |                        | `adjacent <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.adjacent>`_,                                                                                                                      |
-        |                        | `groupby_transform <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.groupby_transform>`_,                                                                                                    |
-        |                        | `padnone <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padnone>`_,                                                                                                                        |
-        |                        | `ncycles <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ncycles>`_                                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Combining              | `collapse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.collapse>`_,                                                                                                                      |
-        |                        | `sort_together <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sort_together>`_,                                                                                                            |
-        |                        | `interleave <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave>`_,                                                                                                                  |
-        |                        | `interleave_longest <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave_longest>`_,                                                                                                  |
-        |                        | `zip_offset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_offset>`_,                                                                                                                  |
-        |                        | `zip_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_equal>`_,                                                                                                                    |
-        |                        | `dotproduct <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.dotproduct>`_,                                                                                                                  |
-        |                        | `flatten <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.flatten>`_,                                                                                                                        |
-        |                        | `roundrobin <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.roundrobin>`_,                                                                                                                  |
-        |                        | `prepend <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.prepend>`_                                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Summarizing            | `ilen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ilen>`_,                                                                                                                              |
-        |                        | `unique_to_each <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_to_each>`_,                                                                                                          |
-        |                        | `sample <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sample>`_,                                                                                                                          |
-        |                        | `consecutive_groups <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consecutive_groups>`_,                                                                                                  |
-        |                        | `run_length <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.run_length>`_,                                                                                                                  |
-        |                        | `map_reduce <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_reduce>`_,                                                                                                                  |
-        |                        | `exactly_n <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.exactly_n>`_,                                                                                                                    |
-        |                        | `is_sorted <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.is_sorted>`_,                                                                                                                    |
-        |                        | `all_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.all_equal>`_,                                                                                                                    |
-        |                        | `first_true <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first_true>`_,                                                                                                                  |
-        |                        | `quantify <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.quantify>`_                                                                                                                       |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Selecting              | `islice_extended <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.islice_extended>`_,                                                                                                        |
-        |                        | `first <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first>`_,                                                                                                                            |
-        |                        | `last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.last>`_,                                                                                                                              |
-        |                        | `one <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.one>`_,                                                                                                                                |
-        |                        | `only <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.only>`_,                                                                                                                              |
-        |                        | `strip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.strip>`_,                                                                                                                            |
-        |                        | `lstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.lstrip>`_,                                                                                                                          |
-        |                        | `rstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rstrip>`_,                                                                                                                          |
-        |                        | `filter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.filter_except>`_                                                                                                             |
-        |                        | `map_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_except>`_                                                                                                                   |
-        |                        | `nth_or_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_or_last>`_,                                                                                                                |
-        |                        | `nth <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth>`_,                                                                                                                                |
-        |                        | `take <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.take>`_,                                                                                                                              |
-        |                        | `tail <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tail>`_,                                                                                                                              |
-        |                        | `unique_everseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertoo ls.unique_everseen>`_,                                                                                                       |
-        |                        | `unique_justseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_justseen>`_                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Combinatorics          | `distinct_permutations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_permutations>`_,                                                                                            |
-        |                        | `distinct_combinations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_combinations>`_,                                                                                            |
-        |                        | `circular_shifts <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.circular_shifts>`_,                                                                                                        |
-        |                        | `partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partitions>`_,                                                                                                                  |
-        |                        | `set_partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.set_partitions>`_,                                                                                                          |
-        |                        | `powerset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.powerset>`_,                                                                                                                      |
-        |                        | `random_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_product>`_,                                                                                                          |
-        |                        | `random_permutation <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_permutation>`_,                                                                                                  |
-        |                        | `random_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination>`_,                                                                                                  |
-        |                        | `random_combination_with_replacement <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination_with_replacement>`_,                                                                |
-        |                        | `nth_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_combination>`_                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Wrapping               | `always_iterable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_iterable>`_,                                                                                                        |
-        |                        | `always_reversible <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_reversible>`_,                                                                                                    |
-        |                        | `consumer <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consumer>`_,                                                                                                                      |
-        |                        | `with_iter <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.with_iter>`_,                                                                                                                    |
-        |                        | `iter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iter_except>`_                                                                                                                 |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Others                 | `locate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.locate>`_,                                                                                                                          |
-        |                        | `rlocate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rlocate>`_,                                                                                                                        |
-        |                        | `replace <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.replace>`_,                                                                                                                        |
-        |                        | `numeric_range <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.numeric_range>`_,                                                                                                            |
-        |                        | `side_effect <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.side_effect>`_,                                                                                                                |
-        |                        | `iterate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iterate>`_,                                                                                                                        |
-        |                        | `difference <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.difference>`_,                                                                                                                  |
-        |                        | `make_decorator <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.make_decorator>`_,                                                                                                          |
-        |                        | `SequenceView <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.SequenceView>`_,                                                                                                              |
-        |                        | `time_limited <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.time_limited>`_,                                                                                                              |
-        |                        | `consume <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consume>`_,                                                                                                                        |
-        |                        | `tabulate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tabulate>`_,                                                                                                                      |
-        |                        | `repeatfunc <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeatfunc>`_                                                                                                                   |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        
-        
-        Getting started
-        ===============
-        
-        To get started, install the library with `pip <https://pip.pypa.io/en/stable/>`_:
-        
-        .. code-block:: shell
-        
-            pip install more-itertools
-        
-        The recipes from the `itertools docs <https://docs.python.org/3/library/itertools.html#itertools-recipes>`_
-        are included in the top-level package:
-        
-        .. code-block:: python
-        
-            >>> from more_itertools import flatten
-            >>> iterable = (0, 1), (2, 3)
-            >>> list(flatten(iterable))
-            0, 1, 2, 3
-        
-        Several new recipes are available as well:
-        
-        .. code-block:: python
-        
-            >>> from more_itertools import chunked
-            >>> iterable = 0, 1, 2, 3, 4, 5, 6, 7, 8
-            >>> list(chunked(iterable, 3))
-            0, 1, 2, 3, 4, 5, 6, 7, 8
-        
-            >>> from more_itertools import spy
-            >>> iterable = (x * x for x in range(1, 6))
-            >>> head, iterable = spy(iterable, n=3)
-            >>> list(head)
-            1, 4, 9
-            >>> list(iterable)
-            1, 4, 9, 16, 25
-        
-        
-        
-        For the full listing of functions, see the `API documentation <https://more-itertools.readthedocs.io/en/stable/api.html>`_.
-        
-        
-        Links elsewhere
-        ===============
-        
-        Blog posts about ``more-itertools``:
-        
-        * `Yo, I heard you like decorators <https://www.bbayles.com/index/decorator_factory>`__
-        * `Tour of Python Itertools <https://martinheinz.dev/blog/16>`__
-        
-        
-        Development
-        ===========
-        
-        ``more-itertools`` is maintained by `@erikrose <https://github.com/erikrose>`_
-        and `@bbayles <https://github.com/bbayles>`_, with help from `many others <https://github.com/more-itertools/more-itertools/graphs/contributors>`_.
-        If you have a problem or suggestion, please file a bug or pull request in this
-        repository. Thanks for contributing!
-        
-        
-        Version History
-        ===============
-        
-        
-           :noindex:
-        
-        8.5.0
-        -----
-        
-        
-        * New itertools
-            * windowed_complete (thanks to MarcinKonowalczyk)
-        
-        * Changes to existing itertools:
-            * The is_sorted implementation was improved (thanks to cool-RR)
-            * The groupby_transform now accepts a ``reducefunc`` parameter.
-            * The last implementation was improved (thanks to brianmaissy)
-        
-        * Other changes
-            * Various documentation fixes (thanks to craigrosie, samuelstjean, PiCT0)
-            * The tests for distinct_combinations were improved (thanks to Minabsapi)
-            * Automated tests now run on GitHub Actions. All commits now check:
-                * That unit tests pass
-                * That the examples in docstrings work
-                * That test coverage remains high (using `coverage`)
-                * For linting errors (using `flake8`)
-                * For consistent style (using `black`)
-                * That the type stubs work (using `mypy`)
-                * That the docs build correctly (using `sphinx`)
-                * That packages build correctly (using `twine`)
-        
-        8.4.0
-        -----
-        
-        * New itertools
-            * mark_ends (thanks to kalekundert)
-            * is_sorted
-        
-        * Changes to existing itertools:
-            * islice_extended can now be used with real slices (thanks to cool-RR)
-            * The implementations for filter_except and map_except were improved (thanks to SergBobrovsky)
-        
-        * Other changes
-            * Automated tests now enforce code style (using `black <https://github.com/psf/black>`__)
-            * The various signatures of islice_extended and numeric_range now appear in the docs (thanks to dsfulf)
-            * The test configuration for mypy was updated (thanks to blueyed)
-        
-        
-        8.3.0
-        -----
-        
-        * New itertools
-            * zip_equal (thanks to frankier and alexmojaki)
-        
-        * Changes to existing itertools:
-            * split_at, split_before, split_after, and split_when all got a ``maxsplit`` paramter (thanks to jferard and ilai-deutel)
-            * split_at now accepts a ``keep_separator`` parameter (thanks to jferard)
-            * distinct_permutations can now generate ``r``-length permutations (thanks to SergBobrovsky and ilai-deutel)
-            * The windowed implementation was improved  (thanks to SergBobrovsky)
-            * The spy implementation was improved (thanks to has2k1)
-        
-        * Other changes
-            * Type stubs are now tested with ``stubtest`` (thankjs to ilai-deutel)
-            * Tests now run with ``python -m unittest`` instead of ``python setup.py test`` (thanks to jdufresne)
-        
-        8.2.0
-        -----
-        
-        * Bug fixes
-            * The .pyi files for typing were updated. (thanks to blueyed and ilai-deutel)
-        
-        * Changes to existing itertools:
-            * numeric_range now behaves more like the built-in range. (thanks to jferard)
-            * bucket now allows for enumerating keys. (thanks to alexchandel)
-            * sliced now should now work for numpy arrays. (thanks to sswingle)
-            * seekable now has a ``maxlen`` parameter.
-        
-        8.1.0
-        -----
-        
-        * Bug fixes
-            * partition works with ``pred=None`` again. (thanks to MSeifert04)
-        
-        * New itertools
-            * sample (thanks to tommyod)
-            * nth_or_last (thanks to d-ryzhikov)
-        
-        * Changes to existing itertools:
-            * The implementation for divide was improved. (thanks to jferard)
-        
-        8.0.2
-        -----
-        
-        * Bug fixes
-            * The type stub files are now part of the wheel distribution (thanks to keisheiled)
-        
-        8.0.1
-        -----
-        
-        * Bug fixes
-            * The type stub files now work for functions imported from the
-              root package (thanks to keisheiled)
-        
-        8.0.0
-        -----
-        
-        * New itertools and other additions
-            * This library now ships type hints for use with mypy.
-              (thanks to ilai-deutel for the implementation, and to gabbard and fmagin for assistance)
-            * split_when (thanks to jferard)
-            * repeat_last (thanks to d-ryzhikov)
-        
-        * Changes to existing itertools:
-            * The implementation for set_partitions was improved. (thanks to jferard)
-            * partition was optimized for expensive predicates. (thanks to stevecj)
-            * unique_everseen and groupby_transform were re-factored. (thanks to SergBobrovsky)
-            * The implementation for difference was improved. (thanks to Jabbey92)
-        
-        * Other changes
-            * Python 3.4 has reached its end of life and is no longer supported.
-            * Python 3.8 is officially supported. (thanks to jdufresne)
-            * The ``collate`` function has been deprecated.
-              It raises a ``DeprecationWarning`` if used, and will be removed in a future release.
-            * one and only now provide more informative error messages. (thanks to gabbard)
-            * Unit tests were moved outside of the main package (thanks to jdufresne)
-            * Various documentation fixes (thanks to kriomant, gabbard, jdufresne)
-        
-        
-        7.2.0
-        -----
-        
-        * New itertools
-            * distinct_combinations
-            * set_partitions (thanks to kbarrett)
-            * filter_except
-            * map_except
-        
-        7.1.0
-        -----
-        
-        * New itertools
-            * ichunked (thanks davebelais and youtux)
-            * only (thanks jaraco)
-        
-        * Changes to existing itertools:
-            * numeric_range now supports ranges specified by
-              ``datetime.datetime`` and ``datetime.timedelta`` objects (thanks to MSeifert04 for tests).
-            * difference now supports an *initial* keyword argument.
-        
-        
-        * Other changes
-            * Various documentation fixes (thanks raimon49, pylang)
-        
-        7.0.0
-        -----
-        
-        * New itertools:
-            * time_limited
-            * partitions (thanks to rominf and Saluev)
-            * substrings_indexes (thanks to rominf)
-        
-        * Changes to existing itertools:
-            * collapse now treats ``bytes`` objects the same as ``str`` objects. (thanks to Sweenpet)
-        
-        The major version update is due to the change in the default behavior of
-        collapse. It now treats ``bytes`` objects the same as ``str`` objects.
-        This aligns its behavior with always_iterable.
-        
-        .. code-block:: python
-        
-            >>> from more_itertools import collapse
-            >>> iterable = 1, 2, b'345', 6
-            >>> print(list(collapse(iterable)))
-            1, 2, b'345', 6
-        
-        6.0.0
-        -----
-        
-        * Major changes:
-            * Python 2.7 is no longer supported. The 5.0.0 release will be the last
-              version targeting Python 2.7.
-            * All future releases will target the active versions of Python 3.
-              As of 2019, those are Python 3.4 and above.
-            * The ``six`` library is no longer a dependency.
-            * The accumulate function is no longer part of this library. You
-              may import a better version from the standard ``itertools`` module.
-        
-        * Changes to existing itertools:
-            * The order of the parameters in grouper have changed to match
-              the latest recipe in the itertools documentation. Use of the old order
-              will be supported in this release, but emit a  ``DeprecationWarning``.
-              The legacy behavior will be dropped in a future release. (thanks to jaraco)
-            * distinct_permutations was improved (thanks to jferard - see also `permutations with unique values <https://stackoverflow.com/questions/6284396/permutations-with-unique-values>`_ at StackOverflow.)
-            * An unused parameter was removed from substrings. (thanks to pylang)
-        
-        * Other changes:
-            * The docs for unique_everseen were improved. (thanks to jferard and MSeifert04)
-            * Several Python 2-isms were removed. (thanks to jaraco, MSeifert04, and hugovk)
-        
-Keywords: itertools,iterator,iteration,filter,peek,peekable,collate,chunk,chunked
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Natural Language :: English
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.5
-Description-Content-Type: text/x-rst

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools.egg-info Deleted

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools.egg-info/PKG-INFO Deleted

@@ -1,405 +0,0 @@
-Metadata-Version: 2.1
-Name: more-itertools
-Version: 8.5.0
-Summary: More routines for operating on iterables, beyond itertools
-Home-page: https://github.com/more-itertools/more-itertools
-Author: Erik Rose
-Author-email: erikrose@grinchcentral.com
-License: MIT
-Description: ==============
-        More Itertools
-        ==============
-        
-        .. image:: https://readthedocs.org/projects/more-itertools/badge/?version=latest
-          :target: https://more-itertools.readthedocs.io/en/stable/
-        
-        Python's ``itertools`` library is a gem - you can compose elegant solutions
-        for a variety of problems with the functions it provides. In ``more-itertools``
-        we collect additional building blocks, recipes, and routines for working with
-        Python iterables.
-        
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Grouping               | `chunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.chunked>`_,                                                                                                                        |
-        |                        | `ichunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ichunked>`_,                                                                                                                      |
-        |                        | `sliced <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sliced>`_,                                                                                                                          |
-        |                        | `distribute <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distribute>`_,                                                                                                                  |
-        |                        | `divide <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.divide>`_,                                                                                                                          |
-        |                        | `split_at <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_at>`_,                                                                                                                      |
-        |                        | `split_before <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_before>`_,                                                                                                              |
-        |                        | `split_after <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_after>`_,                                                                                                                |
-        |                        | `split_into <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_into>`_,                                                                                                                  |
-        |                        | `split_when <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_when>`_,                                                                                                                  |
-        |                        | `bucket <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.bucket>`_,                                                                                                                          |
-        |                        | `unzip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unzip>`_,                                                                                                                            |
-        |                        | `grouper <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.grouper>`_,                                                                                                                        |
-        |                        | `partition <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partition>`_                                                                                                                     |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Lookahead and lookback | `spy <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.spy>`_,                                                                                                                                |
-        |                        | `peekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.peekable>`_,                                                                                                                      |
-        |                        | `seekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.seekable>`_                                                                                                                       |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Windowing              | `windowed <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.windowed>`_,                                                                                                                      |
-        |                        | `substrings <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings>`_,                                                                                                                  |
-        |                        | `substrings_indexes <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings_indexes>`_,                                                                                                  |
-        |                        | `stagger <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.stagger>`_,                                                                                                                        |
-        |                        | `pairwise <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.pairwise>`_                                                                                                                       |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Augmenting             | `count_cycle <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.count_cycle>`_,                                                                                                                |
-        |                        | `intersperse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.intersperse>`_,                                                                                                                |
-        |                        | `padded <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padded>`_,                                                                                                                          |
-        |                        | `mark_ends <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.mark_ends>`_,                                                                                                                    |
-        |                        | `repeat_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeat_last>`_,                                                                                                                |
-        |                        | `adjacent <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.adjacent>`_,                                                                                                                      |
-        |                        | `groupby_transform <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.groupby_transform>`_,                                                                                                    |
-        |                        | `padnone <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padnone>`_,                                                                                                                        |
-        |                        | `ncycles <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ncycles>`_                                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Combining              | `collapse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.collapse>`_,                                                                                                                      |
-        |                        | `sort_together <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sort_together>`_,                                                                                                            |
-        |                        | `interleave <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave>`_,                                                                                                                  |
-        |                        | `interleave_longest <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave_longest>`_,                                                                                                  |
-        |                        | `zip_offset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_offset>`_,                                                                                                                  |
-        |                        | `zip_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_equal>`_,                                                                                                                    |
-        |                        | `dotproduct <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.dotproduct>`_,                                                                                                                  |
-        |                        | `flatten <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.flatten>`_,                                                                                                                        |
-        |                        | `roundrobin <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.roundrobin>`_,                                                                                                                  |
-        |                        | `prepend <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.prepend>`_                                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Summarizing            | `ilen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ilen>`_,                                                                                                                              |
-        |                        | `unique_to_each <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_to_each>`_,                                                                                                          |
-        |                        | `sample <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sample>`_,                                                                                                                          |
-        |                        | `consecutive_groups <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consecutive_groups>`_,                                                                                                  |
-        |                        | `run_length <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.run_length>`_,                                                                                                                  |
-        |                        | `map_reduce <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_reduce>`_,                                                                                                                  |
-        |                        | `exactly_n <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.exactly_n>`_,                                                                                                                    |
-        |                        | `is_sorted <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.is_sorted>`_,                                                                                                                    |
-        |                        | `all_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.all_equal>`_,                                                                                                                    |
-        |                        | `first_true <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first_true>`_,                                                                                                                  |
-        |                        | `quantify <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.quantify>`_                                                                                                                       |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Selecting              | `islice_extended <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.islice_extended>`_,                                                                                                        |
-        |                        | `first <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first>`_,                                                                                                                            |
-        |                        | `last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.last>`_,                                                                                                                              |
-        |                        | `one <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.one>`_,                                                                                                                                |
-        |                        | `only <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.only>`_,                                                                                                                              |
-        |                        | `strip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.strip>`_,                                                                                                                            |
-        |                        | `lstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.lstrip>`_,                                                                                                                          |
-        |                        | `rstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rstrip>`_,                                                                                                                          |
-        |                        | `filter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.filter_except>`_                                                                                                             |
-        |                        | `map_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_except>`_                                                                                                                   |
-        |                        | `nth_or_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_or_last>`_,                                                                                                                |
-        |                        | `nth <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth>`_,                                                                                                                                |
-        |                        | `take <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.take>`_,                                                                                                                              |
-        |                        | `tail <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tail>`_,                                                                                                                              |
-        |                        | `unique_everseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertoo ls.unique_everseen>`_,                                                                                                       |
-        |                        | `unique_justseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_justseen>`_                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Combinatorics          | `distinct_permutations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_permutations>`_,                                                                                            |
-        |                        | `distinct_combinations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_combinations>`_,                                                                                            |
-        |                        | `circular_shifts <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.circular_shifts>`_,                                                                                                        |
-        |                        | `partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partitions>`_,                                                                                                                  |
-        |                        | `set_partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.set_partitions>`_,                                                                                                          |
-        |                        | `powerset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.powerset>`_,                                                                                                                      |
-        |                        | `random_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_product>`_,                                                                                                          |
-        |                        | `random_permutation <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_permutation>`_,                                                                                                  |
-        |                        | `random_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination>`_,                                                                                                  |
-        |                        | `random_combination_with_replacement <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination_with_replacement>`_,                                                                |
-        |                        | `nth_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_combination>`_                                                                                                         |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Wrapping               | `always_iterable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_iterable>`_,                                                                                                        |
-        |                        | `always_reversible <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_reversible>`_,                                                                                                    |
-        |                        | `consumer <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consumer>`_,                                                                                                                      |
-        |                        | `with_iter <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.with_iter>`_,                                                                                                                    |
-        |                        | `iter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iter_except>`_                                                                                                                 |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        | Others                 | `locate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.locate>`_,                                                                                                                          |
-        |                        | `rlocate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rlocate>`_,                                                                                                                        |
-        |                        | `replace <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.replace>`_,                                                                                                                        |
-        |                        | `numeric_range <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.numeric_range>`_,                                                                                                            |
-        |                        | `side_effect <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.side_effect>`_,                                                                                                                |
-        |                        | `iterate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iterate>`_,                                                                                                                        |
-        |                        | `difference <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.difference>`_,                                                                                                                  |
-        |                        | `make_decorator <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.make_decorator>`_,                                                                                                          |
-        |                        | `SequenceView <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.SequenceView>`_,                                                                                                              |
-        |                        | `time_limited <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.time_limited>`_,                                                                                                              |
-        |                        | `consume <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consume>`_,                                                                                                                        |
-        |                        | `tabulate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tabulate>`_,                                                                                                                      |
-        |                        | `repeatfunc <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeatfunc>`_                                                                                                                   |
-        +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-        
-        
-        Getting started
-        ===============
-        
-        To get started, install the library with `pip <https://pip.pypa.io/en/stable/>`_:
-        
-        .. code-block:: shell
-        
-            pip install more-itertools
-        
-        The recipes from the `itertools docs <https://docs.python.org/3/library/itertools.html#itertools-recipes>`_
-        are included in the top-level package:
-        
-        .. code-block:: python
-        
-            >>> from more_itertools import flatten
-            >>> iterable = (0, 1), (2, 3)
-            >>> list(flatten(iterable))
-            0, 1, 2, 3
-        
-        Several new recipes are available as well:
-        
-        .. code-block:: python
-        
-            >>> from more_itertools import chunked
-            >>> iterable = 0, 1, 2, 3, 4, 5, 6, 7, 8
-            >>> list(chunked(iterable, 3))
-            0, 1, 2, 3, 4, 5, 6, 7, 8
-        
-            >>> from more_itertools import spy
-            >>> iterable = (x * x for x in range(1, 6))
-            >>> head, iterable = spy(iterable, n=3)
-            >>> list(head)
-            1, 4, 9
-            >>> list(iterable)
-            1, 4, 9, 16, 25
-        
-        
-        
-        For the full listing of functions, see the `API documentation <https://more-itertools.readthedocs.io/en/stable/api.html>`_.
-        
-        
-        Links elsewhere
-        ===============
-        
-        Blog posts about ``more-itertools``:
-        
-        * `Yo, I heard you like decorators <https://www.bbayles.com/index/decorator_factory>`__
-        * `Tour of Python Itertools <https://martinheinz.dev/blog/16>`__
-        
-        
-        Development
-        ===========
-        
-        ``more-itertools`` is maintained by `@erikrose <https://github.com/erikrose>`_
-        and `@bbayles <https://github.com/bbayles>`_, with help from `many others <https://github.com/more-itertools/more-itertools/graphs/contributors>`_.
-        If you have a problem or suggestion, please file a bug or pull request in this
-        repository. Thanks for contributing!
-        
-        
-        Version History
-        ===============
-        
-        
-           :noindex:
-        
-        8.5.0
-        -----
-        
-        
-        * New itertools
-            * windowed_complete (thanks to MarcinKonowalczyk)
-        
-        * Changes to existing itertools:
-            * The is_sorted implementation was improved (thanks to cool-RR)
-            * The groupby_transform now accepts a ``reducefunc`` parameter.
-            * The last implementation was improved (thanks to brianmaissy)
-        
-        * Other changes
-            * Various documentation fixes (thanks to craigrosie, samuelstjean, PiCT0)
-            * The tests for distinct_combinations were improved (thanks to Minabsapi)
-            * Automated tests now run on GitHub Actions. All commits now check:
-                * That unit tests pass
-                * That the examples in docstrings work
-                * That test coverage remains high (using `coverage`)
-                * For linting errors (using `flake8`)
-                * For consistent style (using `black`)
-                * That the type stubs work (using `mypy`)
-                * That the docs build correctly (using `sphinx`)
-                * That packages build correctly (using `twine`)
-        
-        8.4.0
-        -----
-        
-        * New itertools
-            * mark_ends (thanks to kalekundert)
-            * is_sorted
-        
-        * Changes to existing itertools:
-            * islice_extended can now be used with real slices (thanks to cool-RR)
-            * The implementations for filter_except and map_except were improved (thanks to SergBobrovsky)
-        
-        * Other changes
-            * Automated tests now enforce code style (using `black <https://github.com/psf/black>`__)
-            * The various signatures of islice_extended and numeric_range now appear in the docs (thanks to dsfulf)
-            * The test configuration for mypy was updated (thanks to blueyed)
-        
-        
-        8.3.0
-        -----
-        
-        * New itertools
-            * zip_equal (thanks to frankier and alexmojaki)
-        
-        * Changes to existing itertools:
-            * split_at, split_before, split_after, and split_when all got a ``maxsplit`` paramter (thanks to jferard and ilai-deutel)
-            * split_at now accepts a ``keep_separator`` parameter (thanks to jferard)
-            * distinct_permutations can now generate ``r``-length permutations (thanks to SergBobrovsky and ilai-deutel)
-            * The windowed implementation was improved  (thanks to SergBobrovsky)
-            * The spy implementation was improved (thanks to has2k1)
-        
-        * Other changes
-            * Type stubs are now tested with ``stubtest`` (thankjs to ilai-deutel)
-            * Tests now run with ``python -m unittest`` instead of ``python setup.py test`` (thanks to jdufresne)
-        
-        8.2.0
-        -----
-        
-        * Bug fixes
-            * The .pyi files for typing were updated. (thanks to blueyed and ilai-deutel)
-        
-        * Changes to existing itertools:
-            * numeric_range now behaves more like the built-in range. (thanks to jferard)
-            * bucket now allows for enumerating keys. (thanks to alexchandel)
-            * sliced now should now work for numpy arrays. (thanks to sswingle)
-            * seekable now has a ``maxlen`` parameter.
-        
-        8.1.0
-        -----
-        
-        * Bug fixes
-            * partition works with ``pred=None`` again. (thanks to MSeifert04)
-        
-        * New itertools
-            * sample (thanks to tommyod)
-            * nth_or_last (thanks to d-ryzhikov)
-        
-        * Changes to existing itertools:
-            * The implementation for divide was improved. (thanks to jferard)
-        
-        8.0.2
-        -----
-        
-        * Bug fixes
-            * The type stub files are now part of the wheel distribution (thanks to keisheiled)
-        
-        8.0.1
-        -----
-        
-        * Bug fixes
-            * The type stub files now work for functions imported from the
-              root package (thanks to keisheiled)
-        
-        8.0.0
-        -----
-        
-        * New itertools and other additions
-            * This library now ships type hints for use with mypy.
-              (thanks to ilai-deutel for the implementation, and to gabbard and fmagin for assistance)
-            * split_when (thanks to jferard)
-            * repeat_last (thanks to d-ryzhikov)
-        
-        * Changes to existing itertools:
-            * The implementation for set_partitions was improved. (thanks to jferard)
-            * partition was optimized for expensive predicates. (thanks to stevecj)
-            * unique_everseen and groupby_transform were re-factored. (thanks to SergBobrovsky)
-            * The implementation for difference was improved. (thanks to Jabbey92)
-        
-        * Other changes
-            * Python 3.4 has reached its end of life and is no longer supported.
-            * Python 3.8 is officially supported. (thanks to jdufresne)
-            * The ``collate`` function has been deprecated.
-              It raises a ``DeprecationWarning`` if used, and will be removed in a future release.
-            * one and only now provide more informative error messages. (thanks to gabbard)
-            * Unit tests were moved outside of the main package (thanks to jdufresne)
-            * Various documentation fixes (thanks to kriomant, gabbard, jdufresne)
-        
-        
-        7.2.0
-        -----
-        
-        * New itertools
-            * distinct_combinations
-            * set_partitions (thanks to kbarrett)
-            * filter_except
-            * map_except
-        
-        7.1.0
-        -----
-        
-        * New itertools
-            * ichunked (thanks davebelais and youtux)
-            * only (thanks jaraco)
-        
-        * Changes to existing itertools:
-            * numeric_range now supports ranges specified by
-              ``datetime.datetime`` and ``datetime.timedelta`` objects (thanks to MSeifert04 for tests).
-            * difference now supports an *initial* keyword argument.
-        
-        
-        * Other changes
-            * Various documentation fixes (thanks raimon49, pylang)
-        
-        7.0.0
-        -----
-        
-        * New itertools:
-            * time_limited
-            * partitions (thanks to rominf and Saluev)
-            * substrings_indexes (thanks to rominf)
-        
-        * Changes to existing itertools:
-            * collapse now treats ``bytes`` objects the same as ``str`` objects. (thanks to Sweenpet)
-        
-        The major version update is due to the change in the default behavior of
-        collapse. It now treats ``bytes`` objects the same as ``str`` objects.
-        This aligns its behavior with always_iterable.
-        
-        .. code-block:: python
-        
-            >>> from more_itertools import collapse
-            >>> iterable = 1, 2, b'345', 6
-            >>> print(list(collapse(iterable)))
-            1, 2, b'345', 6
-        
-        6.0.0
-        -----
-        
-        * Major changes:
-            * Python 2.7 is no longer supported. The 5.0.0 release will be the last
-              version targeting Python 2.7.
-            * All future releases will target the active versions of Python 3.
-              As of 2019, those are Python 3.4 and above.
-            * The ``six`` library is no longer a dependency.
-            * The accumulate function is no longer part of this library. You
-              may import a better version from the standard ``itertools`` module.
-        
-        * Changes to existing itertools:
-            * The order of the parameters in grouper have changed to match
-              the latest recipe in the itertools documentation. Use of the old order
-              will be supported in this release, but emit a  ``DeprecationWarning``.
-              The legacy behavior will be dropped in a future release. (thanks to jaraco)
-            * distinct_permutations was improved (thanks to jferard - see also `permutations with unique values <https://stackoverflow.com/questions/6284396/permutations-with-unique-values>`_ at StackOverflow.)
-            * An unused parameter was removed from substrings. (thanks to pylang)
-        
-        * Other changes:
-            * The docs for unique_everseen were improved. (thanks to jferard and MSeifert04)
-            * Several Python 2-isms were removed. (thanks to jaraco, MSeifert04, and hugovk)
-        
-Keywords: itertools,iterator,iteration,filter,peek,peekable,collate,chunk,chunked
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Natural Language :: English
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.5
-Description-Content-Type: text/x-rst

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools.egg-info/SOURCES.txt Deleted

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools.egg-info/dependency_links.txt Deleted

_service:tar_scm:more-itertools-8.5.0.tar.gz/more_itertools.egg-info/top_level.txt Deleted

Changes of Revision 2