diff --git a/.github/workflows/ci-additional.yaml b/.github/workflows/ci-additional.yaml index 5478c2c57..21baff867 100644 --- a/.github/workflows/ci-additional.yaml +++ b/.github/workflows/ci-additional.yaml @@ -128,7 +128,8 @@ jobs: - name: Run mypy run: | - python -m mypy --install-types --non-interactive --cobertura-xml-report mypy_report + mkdir .mypy_cache + python -m mypy --install-types --non-interactive --cache-dir=.mypy_cache/ --cobertura-xml-report mypy_report - name: Upload mypy coverage to Codecov uses: codecov/codecov-action@v4.5.0 diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index f3633fc68..04799a78e 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -16,7 +16,7 @@ concurrency: jobs: test: - name: Test (${{ matrix.python-version }}, ${{ matrix.os }}) + name: Test (${{matrix.env}}, ${{ matrix.python-version }}, ${{ matrix.os }}) runs-on: ${{ matrix.os }} defaults: run: @@ -25,10 +25,18 @@ jobs: fail-fast: false matrix: os: ["ubuntu-latest"] + env: ["environment"] python-version: ["3.9", "3.12"] include: - os: "windows-latest" + env: "environment" python-version: "3.12" + - os: "ubuntu-latest" + env: "no-dask" # "no-xarray", "no-numba" + python-version: "3.12" + - os: "ubuntu-latest" + env: "minimal-requirements" + python-version: "3.9" steps: - uses: actions/checkout@v4 with: @@ -39,7 +47,7 @@ jobs: - name: Set up conda environment uses: mamba-org/setup-micromamba@v1 with: - environment-file: ci/environment.yml + environment-file: ci/${{ matrix.env }}.yml environment-name: flox-tests init-shell: bash cache-environment: true @@ -81,48 +89,6 @@ jobs: path: .hypothesis/ key: cache-hypothesis-${{ runner.os }}-${{ matrix.python-version }}-${{ github.run_id }} - optional-deps: - name: ${{ matrix.env }} - runs-on: "ubuntu-latest" - defaults: - run: - shell: bash -l {0} - strategy: - fail-fast: false - matrix: - python-version: ["3.12"] - env: ["no-dask"] # "no-xarray", "no-numba" - include: - - env: "minimal-requirements" - python-version: "3.9" - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 # Fetch all history for all branches and tags. - - name: Set up conda environment - uses: mamba-org/setup-micromamba@v1 - with: - environment-file: ci/${{ matrix.env }}.yml - environment-name: flox-tests - init-shell: bash - cache-environment: true - create-args: | - python=${{ matrix.python-version }} - - name: Install flox - run: | - python -m pip install --no-deps -e . - - name: Run tests - run: | - python -m pytest -n auto --cov=./ --cov-report=xml - - name: Upload code coverage to Codecov - uses: codecov/codecov-action@v4.5.0 - with: - file: ./coverage.xml - flags: unittests - env_vars: RUNNER_OS - name: codecov-umbrella - fail_ci_if_error: false - xarray-groupby: name: xarray-groupby runs-on: ubuntu-latest diff --git a/asv_bench/__init__.py b/asv_bench/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/asv_bench/benchmarks/cohorts.py b/asv_bench/benchmarks/cohorts.py index f827f6e0e..f2e993798 100644 --- a/asv_bench/benchmarks/cohorts.py +++ b/asv_bench/benchmarks/cohorts.py @@ -47,6 +47,9 @@ def time_find_group_cohorts(self): except AttributeError: pass + def track_num_cohorts(self): + return len(self.chunks_cohorts()) + def time_graph_construct(self): flox.groupby_reduce(self.array, self.by, func="sum", axis=self.axis) @@ -60,10 +63,11 @@ def track_num_tasks_optimized(self): def track_num_layers(self): return len(self.result.dask.layers) + track_num_cohorts.unit = "cohorts" # type: ignore[attr-defined] # Lazy track_num_tasks.unit = "tasks" # type: ignore[attr-defined] # Lazy track_num_tasks_optimized.unit = "tasks" # type: ignore[attr-defined] # Lazy track_num_layers.unit = "layers" # type: ignore[attr-defined] # Lazy - for f in [track_num_tasks, track_num_tasks_optimized, track_num_layers]: + for f in [track_num_tasks, track_num_tasks_optimized, track_num_layers, track_num_cohorts]: f.repeat = 1 # type: ignore[attr-defined] # Lazy f.rounds = 1 # type: ignore[attr-defined] # Lazy f.number = 1 # type: ignore[attr-defined] # Lazy diff --git a/ci/docs.yml b/ci/docs.yml index 1ad62512e..50bf98829 100644 --- a/ci/docs.yml +++ b/ci/docs.yml @@ -16,7 +16,7 @@ dependencies: - myst-parser - myst-nb - sphinx - - furo + - furo>=2024.08 - ipykernel - jupyter - sphinx-codeautolink diff --git a/ci/environment.yml b/ci/environment.yml index 5a6b09df2..82995d079 100644 --- a/ci/environment.yml +++ b/ci/environment.yml @@ -18,6 +18,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - xarray - pre-commit - numpy_groupies>=0.9.19 diff --git a/ci/minimal-requirements.yml b/ci/minimal-requirements.yml index fa5eae251..5074292ac 100644 --- a/ci/minimal-requirements.yml +++ b/ci/minimal-requirements.yml @@ -9,6 +9,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - numpy==1.22 - scipy==1.9.0 - numpy_groupies==0.9.19 diff --git a/ci/no-dask.yml b/ci/no-dask.yml index 27cdb59a9..1f05c63a9 100644 --- a/ci/no-dask.yml +++ b/ci/no-dask.yml @@ -13,6 +13,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - xarray - numpydoc - pre-commit diff --git a/ci/no-numba.yml b/ci/no-numba.yml index be3cec4a0..8039b20f7 100644 --- a/ci/no-numba.yml +++ b/ci/no-numba.yml @@ -18,6 +18,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - xarray - pre-commit - numpy_groupies>=0.9.19 diff --git a/ci/no-xarray.yml b/ci/no-xarray.yml index 2dfac3ae5..030796507 100644 --- a/ci/no-xarray.yml +++ b/ci/no-xarray.yml @@ -3,6 +3,7 @@ channels: - conda-forge dependencies: - codecov + - syrupy - pandas - numpy>=1.22 - scipy @@ -11,6 +12,7 @@ dependencies: - pytest-cov - pytest-pretty - pytest-xdist + - syrupy - dask-core - numpydoc - pre-commit diff --git a/ci/upstream-dev-env.yml b/ci/upstream-dev-env.yml index 856bbafda..4020dd840 100644 --- a/ci/upstream-dev-env.yml +++ b/ci/upstream-dev-env.yml @@ -11,6 +11,7 @@ dependencies: # - scipy - pytest-pretty - pytest-xdist + - syrupy - pip # for cftime - cython>=0.29.20 diff --git a/docs/diagrams/containment.png b/docs/diagrams/containment.png index 0a1571215..e69f9c343 100644 Binary files a/docs/diagrams/containment.png and b/docs/diagrams/containment.png differ diff --git a/flox/__init__.py b/flox/__init__.py index 2ca5fa5ba..839bfb076 100644 --- a/flox/__init__.py +++ b/flox/__init__.py @@ -2,7 +2,7 @@ # flake8: noqa """Top-level module for flox .""" from . import cache -from .aggregations import Aggregation # noqa +from .aggregations import Aggregation, Scan # noqa from .core import groupby_reduce, groupby_scan, rechunk_for_blockwise, rechunk_for_cohorts # noqa diff --git a/flox/core.py b/flox/core.py index d357aa672..5ab4009e2 100644 --- a/flox/core.py +++ b/flox/core.py @@ -171,7 +171,9 @@ def _is_minmax_reduction(func: T_Agg) -> bool: def _is_first_last_reduction(func: T_Agg) -> bool: - return isinstance(func, str) and func in ["nanfirst", "nanlast", "first", "last"] + if isinstance(func, Aggregation): + func = func.name + return func in ["nanfirst", "nanlast", "first", "last"] def _get_expected_groups(by: T_By, sort: bool) -> T_ExpectIndex: @@ -395,14 +397,16 @@ def find_group_cohorts( chunks_per_label = chunks_per_label[present_labels_mask] label_chunks = { - present_labels[idx]: bitmask.indices[slice(bitmask.indptr[idx], bitmask.indptr[idx + 1])] + present_labels[idx].item(): bitmask.indices[ + slice(bitmask.indptr[idx], bitmask.indptr[idx + 1]) + ] for idx in range(bitmask.shape[LABEL_AXIS]) } # Invert the label_chunks mapping so we know which labels occur together. def invert(x) -> tuple[np.ndarray, ...]: arr = label_chunks[x] - return tuple(arr) + return tuple(arr.tolist()) chunks_cohorts = tlz.groupby(invert, label_chunks.keys()) @@ -476,36 +480,52 @@ def invert(x) -> tuple[np.ndarray, ...]: containment.nnz / math.prod(containment.shape) ) ) - # Use a threshold to force some merging. We do not use the filtered - # containment matrix for estimating "sparsity" because it is a bit - # hard to reason about. + + # Next we for-loop over groups and merge those that are quite similar. + # Use a threshold on containment to always force some merging. + # Note that we do not use the filtered containment matrix for estimating "sparsity" + # because it is a bit hard to reason about. MIN_CONTAINMENT = 0.75 # arbitrary mask = containment.data < MIN_CONTAINMENT + + # Now we also know "exact cohorts" -- cohorts whose constituent groups + # occur in exactly the same chunks. We only need examine one member of each group. + # Skip the others by first looping over the exact cohorts, and zero out those rows. + repeated = np.concatenate([v[1:] for v in chunks_cohorts.values()]).astype(int) + repeated_idx = np.searchsorted(present_labels, repeated) + for i in repeated_idx: + mask[containment.indptr[i] : containment.indptr[i + 1]] = True containment.data[mask] = 0 containment.eliminate_zeros() - # Iterate over labels, beginning with those with most chunks + # Figure out all the labels we need to loop over later + n_overlapping_labels = containment.astype(bool).sum(axis=1) + order = np.argsort(n_overlapping_labels, kind="stable")[::-1] + # Order is such that we iterate over labels, beginning with those with most overlaps + # Also filter out any "exact" cohorts + order = order[n_overlapping_labels[order] > 0] + logger.debug("find_group_cohorts: merging cohorts") - order = np.argsort(containment.sum(axis=LABEL_AXIS))[::-1] merged_cohorts = {} merged_keys = set() - # TODO: we can optimize this to loop over chunk_cohorts instead - # by zeroing out rows that are already in a cohort for rowidx in order: + if present_labels[rowidx] in merged_keys: + continue cohidx = containment.indices[ slice(containment.indptr[rowidx], containment.indptr[rowidx + 1]) ] cohort_ = present_labels[cohidx] - cohort = [elem for elem in cohort_ if elem not in merged_keys] + cohort = [elem.item() for elem in cohort_ if elem not in merged_keys] if not cohort: continue merged_keys.update(cohort) - allchunks = (label_chunks[member] for member in cohort) + allchunks = (label_chunks[member].tolist() for member in cohort) chunk = tuple(set(itertools.chain(*allchunks))) merged_cohorts[chunk] = cohort actual_ngroups = np.concatenate(tuple(merged_cohorts.values())).size expected_ngroups = present_labels.size + assert len(merged_keys) == actual_ngroups assert expected_ngroups == actual_ngroups, (expected_ngroups, actual_ngroups) # sort by first label in cohort @@ -1629,7 +1649,12 @@ def dask_groupby_agg( # This allows us to discover groups at compute time, support argreductions, lower intermediate # memory usage (but method="cohorts" would also work to reduce memory in some cases) labels_are_unknown = is_duck_dask_array(by_input) and expected_groups is None - do_simple_combine = not _is_arg_reduction(agg) and not labels_are_unknown + do_grouped_combine = ( + _is_arg_reduction(agg) + or labels_are_unknown + or (_is_first_last_reduction(agg) and array.dtype.kind != "f") + ) + do_simple_combine = not do_grouped_combine if method == "blockwise": # use the "non dask" code path, but applied blockwise @@ -1686,7 +1711,7 @@ def dask_groupby_agg( tree_reduce = partial( dask.array.reductions._tree_reduce, - name=f"{name}-reduce", + name=f"{name}-simple-reduce", dtype=array.dtype, axis=axis, keepdims=True, @@ -1721,14 +1746,20 @@ def dask_groupby_agg( groups_ = [] for blks, cohort in chunks_cohorts.items(): cohort_index = pd.Index(cohort) - reindexer = partial(reindex_intermediates, agg=agg, unique_groups=cohort_index) + reindexer = ( + partial(reindex_intermediates, agg=agg, unique_groups=cohort_index) + if do_simple_combine + else identity + ) reindexed = subset_to_blocks(intermediate, blks, block_shape, reindexer) # now that we have reindexed, we can set reindex=True explicitlly reduced_.append( tree_reduce( reindexed, - combine=partial(combine, agg=agg, reindex=True), - aggregate=partial(aggregate, expected_groups=cohort_index, reindex=True), + combine=partial(combine, agg=agg, reindex=do_simple_combine), + aggregate=partial( + aggregate, expected_groups=cohort_index, reindex=do_simple_combine + ), ) ) # This is done because pandas promotes to 64-bit types when an Index is created @@ -1974,8 +2005,13 @@ def _validate_reindex( expected_groups, any_by_dask: bool, is_dask_array: bool, + array_dtype: Any, ) -> bool | None: # logger.debug("Entering _validate_reindex: reindex is {}".format(reindex)) # noqa + def first_or_last(): + return func in ["first", "last"] or ( + _is_first_last_reduction(func) and array_dtype.kind != "f" + ) all_numpy = not is_dask_array and not any_by_dask if reindex is True and not all_numpy: @@ -1985,7 +2021,7 @@ def _validate_reindex( raise ValueError( "reindex=True is not a valid choice for method='blockwise' or method='cohorts'." ) - if func in ["first", "last"]: + if first_or_last(): raise ValueError("reindex must be None or False when func is 'first' or 'last.") if reindex is None: @@ -1996,9 +2032,10 @@ def _validate_reindex( if all_numpy: return True - if func in ["first", "last"]: + if first_or_last(): # have to do the grouped_combine since there's no good fill_value - reindex = False + # Also needed for nanfirst, nanlast with no-NaN dtypes + return False if method == "blockwise": # for grouping by dask arrays, we set reindex=True @@ -2403,12 +2440,19 @@ def groupby_reduce( if method == "cohorts" and any_by_dask: raise ValueError(f"method={method!r} can only be used when grouping by numpy arrays.") + if not is_duck_array(array): + array = np.asarray(array) + reindex = _validate_reindex( - reindex, func, method, expected_groups, any_by_dask, is_duck_dask_array(array) + reindex, + func, + method, + expected_groups, + any_by_dask, + is_duck_dask_array(array), + array.dtype, ) - if not is_duck_array(array): - array = np.asarray(array) is_bool_array = np.issubdtype(array.dtype, bool) array = array.astype(np.intp) if is_bool_array else array @@ -2592,7 +2636,7 @@ def groupby_reduce( # TODO: clean this up reindex = _validate_reindex( - reindex, func, method, expected_, any_by_dask, is_duck_dask_array(array) + reindex, func, method, expected_, any_by_dask, is_duck_dask_array(array), array.dtype ) if TYPE_CHECKING: diff --git a/readthedocs.yml b/readthedocs.yml index 25699dd03..51b6b6b18 100644 --- a/readthedocs.yml +++ b/readthedocs.yml @@ -1,9 +1,9 @@ version: 2 build: - os: "ubuntu-20.04" + os: "ubuntu-lts-latest" tools: - python: "mambaforge-4.10" + python: "mambaforge-latest" conda: environment: ci/docs.yml diff --git a/tests/__snapshots__/test_cohorts.ambr b/tests/__snapshots__/test_cohorts.ambr new file mode 100644 index 000000000..a96dae4bf --- /dev/null +++ b/tests/__snapshots__/test_cohorts.ambr @@ -0,0 +1,14356 @@ +# serializer version: 1 +# name: test_snapshot_cohorts[ERA5DayOfYear] + dict({ + tuple( + 0, + 365, + 183, + ): list([ + 0, + ]), + tuple( + 0, + 366, + 183, + ): list([ + 1, + ]), + tuple( + 8, + 373, + 191, + ): list([ + 16, + ]), + tuple( + 8, + 374, + 191, + ): list([ + 17, + ]), + tuple( + 16, + 381, + 199, + ): list([ + 32, + ]), + tuple( + 16, + 382, + 199, + ): list([ + 33, + ]), + tuple( + 24, + 389, + 207, + ): list([ + 48, + ]), + tuple( + 24, + 390, + 207, + ): list([ + 49, + ]), + tuple( + 32, + 397, + 215, + ): list([ + 64, + ]), + tuple( + 32, + 398, + 215, + ): list([ + 65, + ]), + tuple( + 40, + 405, + 223, + ): list([ + 80, + ]), + tuple( + 40, + 406, + 223, + ): list([ + 81, + ]), + tuple( + 48, + 413, + 231, + ): list([ + 96, + ]), + tuple( + 48, + 414, + 231, + ): list([ + 97, + ]), + tuple( + 56, + 421, + 239, + ): list([ + 112, + ]), + tuple( + 56, + 422, + 239, + ): list([ + 113, + ]), + tuple( + 64, + 429, + 247, + ): list([ + 128, + ]), + tuple( + 64, + 430, + 247, + ): list([ + 129, + ]), + tuple( + 72, + 437, + 255, + ): list([ + 144, + ]), + tuple( + 72, + 438, + 255, + ): list([ + 145, + ]), + tuple( + 80, + 445, + 263, + ): list([ + 160, + ]), + tuple( + 80, + 446, + 263, + ): list([ + 161, + ]), + tuple( + 88, + 453, + 271, + ): list([ + 176, + ]), + tuple( + 88, + 454, + 271, + ): list([ + 177, + ]), + tuple( + 96, + 461, + 279, + ): list([ + 192, + ]), + tuple( + 96, + 462, + 279, + ): list([ + 193, + ]), + tuple( + 104, + 469, + 287, + ): list([ + 208, + ]), + tuple( + 104, + 470, + 287, + ): list([ + 209, + ]), + tuple( + 112, + 477, + 295, + ): list([ + 224, + ]), + tuple( + 112, + 478, + 295, + ): list([ + 225, + ]), + tuple( + 120, + 485, + 303, + ): list([ + 240, + ]), + tuple( + 120, + 486, + 303, + ): list([ + 241, + ]), + tuple( + 128, + 493, + 311, + ): list([ + 256, + ]), + tuple( + 128, + 494, + 311, + ): list([ + 257, + ]), + tuple( + 136, + 501, + 319, + ): list([ + 272, + ]), + tuple( + 136, + 502, + 319, + ): list([ + 273, + ]), + tuple( + 144, + 509, + 327, + ): list([ + 288, + ]), + tuple( + 144, + 510, + 327, + ): list([ + 289, + ]), + tuple( + 152, + 517, + 335, + ): list([ + 304, + ]), + tuple( + 152, + 518, + 335, + ): list([ + 305, + ]), + tuple( + 160, + 525, + 343, + ): list([ + 320, + ]), + tuple( + 160, + 526, + 343, + ): list([ + 321, + ]), + tuple( + 168, + 533, + 351, + ): list([ + 336, + ]), + tuple( + 168, + 534, + 351, + ): list([ + 337, + ]), + tuple( + 176, + 541, + 359, + ): list([ + 352, + ]), + tuple( + 176, + 542, + 359, + ): list([ + 353, + ]), + tuple( + 184, + 1, + 366, + ): list([ + 2, + ]), + tuple( + 184, + 1, + 367, + ): list([ + 3, + ]), + tuple( + 185, + 2, + 367, + ): list([ + 4, + ]), + tuple( + 192, + 9, + 374, + ): list([ + 18, + ]), + tuple( + 192, + 9, + 375, + ): list([ + 19, + ]), + tuple( + 193, + 10, + 375, + ): list([ + 20, + ]), + tuple( + 200, + 17, + 382, + ): list([ + 34, + ]), + tuple( + 200, + 17, + 383, + ): list([ + 35, + ]), + tuple( + 201, + 18, + 383, + ): list([ + 36, + ]), + tuple( + 208, + 25, + 390, + ): list([ + 50, + ]), + tuple( + 208, + 25, + 391, + ): list([ + 51, + ]), + tuple( + 209, + 26, + 391, + ): list([ + 52, + ]), + tuple( + 216, + 33, + 398, + ): list([ + 66, + ]), + tuple( + 216, + 33, + 399, + ): list([ + 67, + ]), + tuple( + 217, + 34, + 399, + ): list([ + 68, + ]), + tuple( + 224, + 41, + 406, + ): list([ + 82, + ]), + tuple( + 224, + 41, + 407, + ): list([ + 83, + ]), + tuple( + 225, + 42, + 407, + ): list([ + 84, + ]), + tuple( + 232, + 49, + 414, + ): list([ + 98, + ]), + tuple( + 232, + 49, + 415, + ): list([ + 99, + ]), + tuple( + 233, + 50, + 415, + ): list([ + 100, + ]), + tuple( + 240, + 57, + 422, + ): list([ + 114, + ]), + tuple( + 240, + 57, + 423, + ): list([ + 115, + ]), + tuple( + 241, + 58, + 423, + ): list([ + 116, + ]), + tuple( + 248, + 65, + 430, + ): list([ + 130, + ]), + tuple( + 248, + 65, + 431, + ): list([ + 131, + ]), + tuple( + 249, + 66, + 431, + ): list([ + 132, + ]), + tuple( + 256, + 73, + 438, + ): list([ + 146, + ]), + tuple( + 256, + 73, + 439, + ): list([ + 147, + ]), + tuple( + 257, + 74, + 439, + ): list([ + 148, + ]), + tuple( + 264, + 81, + 446, + ): list([ + 162, + ]), + tuple( + 264, + 81, + 447, + ): list([ + 163, + ]), + tuple( + 265, + 82, + 447, + ): list([ + 164, + ]), + tuple( + 272, + 89, + 454, + ): list([ + 178, + ]), + tuple( + 272, + 89, + 455, + ): list([ + 179, + ]), + tuple( + 273, + 90, + 455, + ): list([ + 180, + ]), + tuple( + 280, + 97, + 462, + ): list([ + 194, + ]), + tuple( + 280, + 97, + 463, + ): list([ + 195, + ]), + tuple( + 281, + 98, + 463, + ): list([ + 196, + ]), + tuple( + 288, + 105, + 470, + ): list([ + 210, + ]), + tuple( + 288, + 105, + 471, + ): list([ + 211, + ]), + tuple( + 289, + 106, + 471, + ): list([ + 212, + ]), + tuple( + 296, + 113, + 478, + ): list([ + 226, + ]), + tuple( + 296, + 113, + 479, + ): list([ + 227, + ]), + tuple( + 297, + 114, + 479, + ): list([ + 228, + ]), + tuple( + 304, + 121, + 486, + ): list([ + 242, + ]), + tuple( + 304, + 121, + 487, + ): list([ + 243, + ]), + tuple( + 305, + 122, + 487, + ): list([ + 244, + ]), + tuple( + 312, + 129, + 494, + ): list([ + 258, + ]), + tuple( + 312, + 129, + 495, + ): list([ + 259, + ]), + tuple( + 313, + 130, + 495, + ): list([ + 260, + ]), + tuple( + 320, + 137, + 502, + ): list([ + 274, + ]), + tuple( + 320, + 137, + 503, + ): list([ + 275, + ]), + tuple( + 321, + 138, + 503, + ): list([ + 276, + ]), + tuple( + 328, + 145, + 510, + ): list([ + 290, + ]), + tuple( + 328, + 145, + 511, + ): list([ + 291, + ]), + tuple( + 329, + 146, + 511, + ): list([ + 292, + ]), + tuple( + 336, + 153, + 518, + ): list([ + 306, + ]), + tuple( + 336, + 153, + 519, + ): list([ + 307, + ]), + tuple( + 337, + 154, + 519, + ): list([ + 308, + ]), + tuple( + 344, + 161, + 526, + ): list([ + 322, + ]), + tuple( + 344, + 161, + 527, + ): list([ + 323, + ]), + tuple( + 345, + 162, + 527, + ): list([ + 324, + ]), + tuple( + 352, + 169, + 534, + ): list([ + 338, + ]), + tuple( + 352, + 169, + 535, + ): list([ + 339, + ]), + tuple( + 353, + 170, + 535, + ): list([ + 340, + ]), + tuple( + 360, + 177, + 542, + ): list([ + 354, + ]), + tuple( + 360, + 177, + 543, + ): list([ + 355, + ]), + tuple( + 361, + 178, + 543, + ): list([ + 356, + ]), + tuple( + 368, + 185, + 2, + ): list([ + 5, + ]), + tuple( + 368, + 186, + 3, + ): list([ + 6, + ]), + tuple( + 369, + 186, + 3, + ): list([ + 7, + ]), + tuple( + 369, + 187, + 4, + ): list([ + 8, + ]), + tuple( + 370, + 187, + 4, + ): list([ + 9, + ]), + tuple( + 370, + 188, + 5, + ): list([ + 10, + ]), + tuple( + 371, + 188, + 5, + ): list([ + 11, + ]), + tuple( + 371, + 189, + 6, + ): list([ + 12, + ]), + tuple( + 372, + 189, + 6, + ): list([ + 13, + ]), + tuple( + 372, + 190, + 7, + ): list([ + 14, + ]), + tuple( + 373, + 190, + 7, + ): list([ + 15, + ]), + tuple( + 376, + 193, + 10, + ): list([ + 21, + ]), + tuple( + 376, + 194, + 11, + ): list([ + 22, + ]), + tuple( + 377, + 194, + 11, + ): list([ + 23, + ]), + tuple( + 377, + 195, + 12, + ): list([ + 24, + ]), + tuple( + 378, + 195, + 12, + ): list([ + 25, + ]), + tuple( + 378, + 196, + 13, + ): list([ + 26, + ]), + tuple( + 379, + 196, + 13, + ): list([ + 27, + ]), + tuple( + 379, + 197, + 14, + ): list([ + 28, + ]), + tuple( + 380, + 197, + 14, + ): list([ + 29, + ]), + tuple( + 380, + 198, + 15, + ): list([ + 30, + ]), + tuple( + 381, + 198, + 15, + ): list([ + 31, + ]), + tuple( + 384, + 201, + 18, + ): list([ + 37, + ]), + tuple( + 384, + 202, + 19, + ): list([ + 38, + ]), + tuple( + 385, + 202, + 19, + ): list([ + 39, + ]), + tuple( + 385, + 203, + 20, + ): list([ + 40, + ]), + tuple( + 386, + 203, + 20, + ): list([ + 41, + ]), + tuple( + 386, + 204, + 21, + ): list([ + 42, + ]), + tuple( + 387, + 204, + 21, + ): list([ + 43, + ]), + tuple( + 387, + 205, + 22, + ): list([ + 44, + ]), + tuple( + 388, + 205, + 22, + ): list([ + 45, + ]), + tuple( + 388, + 206, + 23, + ): list([ + 46, + ]), + tuple( + 389, + 206, + 23, + ): list([ + 47, + ]), + tuple( + 392, + 209, + 26, + ): list([ + 53, + ]), + tuple( + 392, + 210, + 27, + ): list([ + 54, + ]), + tuple( + 393, + 210, + 27, + ): list([ + 55, + ]), + tuple( + 393, + 211, + 28, + ): list([ + 56, + ]), + tuple( + 394, + 211, + 28, + ): list([ + 57, + ]), + tuple( + 394, + 212, + 29, + ): list([ + 58, + ]), + tuple( + 395, + 212, + 29, + ): list([ + 59, + ]), + tuple( + 395, + 213, + 30, + ): list([ + 60, + ]), + tuple( + 396, + 213, + 30, + ): list([ + 61, + ]), + tuple( + 396, + 214, + 31, + ): list([ + 62, + ]), + tuple( + 397, + 214, + 31, + ): list([ + 63, + ]), + tuple( + 400, + 217, + 34, + ): list([ + 69, + ]), + tuple( + 400, + 218, + 35, + ): list([ + 70, + ]), + tuple( + 401, + 218, + 35, + ): list([ + 71, + ]), + tuple( + 401, + 219, + 36, + ): list([ + 72, + ]), + tuple( + 402, + 219, + 36, + ): list([ + 73, + ]), + tuple( + 402, + 220, + 37, + ): list([ + 74, + ]), + tuple( + 403, + 220, + 37, + ): list([ + 75, + ]), + tuple( + 403, + 221, + 38, + ): list([ + 76, + ]), + tuple( + 404, + 221, + 38, + ): list([ + 77, + ]), + tuple( + 404, + 222, + 39, + ): list([ + 78, + ]), + tuple( + 405, + 222, + 39, + ): list([ + 79, + ]), + tuple( + 408, + 225, + 42, + ): list([ + 85, + ]), + tuple( + 408, + 226, + 43, + ): list([ + 86, + ]), + tuple( + 409, + 226, + 43, + ): list([ + 87, + ]), + tuple( + 409, + 227, + 44, + ): list([ + 88, + ]), + tuple( + 410, + 227, + 44, + ): list([ + 89, + ]), + tuple( + 410, + 228, + 45, + ): list([ + 90, + ]), + tuple( + 411, + 228, + 45, + ): list([ + 91, + ]), + tuple( + 411, + 229, + 46, + ): list([ + 92, + ]), + tuple( + 412, + 229, + 46, + ): list([ + 93, + ]), + tuple( + 412, + 230, + 47, + ): list([ + 94, + ]), + tuple( + 413, + 230, + 47, + ): list([ + 95, + ]), + tuple( + 416, + 233, + 50, + ): list([ + 101, + ]), + tuple( + 416, + 234, + 51, + ): list([ + 102, + ]), + tuple( + 417, + 234, + 51, + ): list([ + 103, + ]), + tuple( + 417, + 235, + 52, + ): list([ + 104, + ]), + tuple( + 418, + 235, + 52, + ): list([ + 105, + ]), + tuple( + 418, + 236, + 53, + ): list([ + 106, + ]), + tuple( + 419, + 236, + 53, + ): list([ + 107, + ]), + tuple( + 419, + 237, + 54, + ): list([ + 108, + ]), + tuple( + 420, + 237, + 54, + ): list([ + 109, + ]), + tuple( + 420, + 238, + 55, + ): list([ + 110, + ]), + tuple( + 421, + 238, + 55, + ): list([ + 111, + ]), + tuple( + 424, + 241, + 58, + ): list([ + 117, + ]), + tuple( + 424, + 242, + 59, + ): list([ + 118, + ]), + tuple( + 425, + 242, + 59, + ): list([ + 119, + ]), + tuple( + 425, + 243, + 60, + ): list([ + 120, + ]), + tuple( + 426, + 243, + 60, + ): list([ + 121, + ]), + tuple( + 426, + 244, + 61, + ): list([ + 122, + ]), + tuple( + 427, + 244, + 61, + ): list([ + 123, + ]), + tuple( + 427, + 245, + 62, + ): list([ + 124, + ]), + tuple( + 428, + 245, + 62, + ): list([ + 125, + ]), + tuple( + 428, + 246, + 63, + ): list([ + 126, + ]), + tuple( + 429, + 246, + 63, + ): list([ + 127, + ]), + tuple( + 432, + 249, + 66, + ): list([ + 133, + ]), + tuple( + 432, + 250, + 67, + ): list([ + 134, + ]), + tuple( + 433, + 250, + 67, + ): list([ + 135, + ]), + tuple( + 433, + 251, + 68, + ): list([ + 136, + ]), + tuple( + 434, + 251, + 68, + ): list([ + 137, + ]), + tuple( + 434, + 252, + 69, + ): list([ + 138, + ]), + tuple( + 435, + 252, + 69, + ): list([ + 139, + ]), + tuple( + 435, + 253, + 70, + ): list([ + 140, + ]), + tuple( + 436, + 253, + 70, + ): list([ + 141, + ]), + tuple( + 436, + 254, + 71, + ): list([ + 142, + ]), + tuple( + 437, + 254, + 71, + ): list([ + 143, + ]), + tuple( + 440, + 257, + 74, + ): list([ + 149, + ]), + tuple( + 440, + 258, + 75, + ): list([ + 150, + ]), + tuple( + 441, + 258, + 75, + ): list([ + 151, + ]), + tuple( + 441, + 259, + 76, + ): list([ + 152, + ]), + tuple( + 442, + 259, + 76, + ): list([ + 153, + ]), + tuple( + 442, + 260, + 77, + ): list([ + 154, + ]), + tuple( + 443, + 260, + 77, + ): list([ + 155, + ]), + tuple( + 443, + 261, + 78, + ): list([ + 156, + ]), + tuple( + 444, + 261, + 78, + ): list([ + 157, + ]), + tuple( + 444, + 262, + 79, + ): list([ + 158, + ]), + tuple( + 445, + 262, + 79, + ): list([ + 159, + ]), + tuple( + 448, + 265, + 82, + ): list([ + 165, + ]), + tuple( + 448, + 266, + 83, + ): list([ + 166, + ]), + tuple( + 449, + 266, + 83, + ): list([ + 167, + ]), + tuple( + 449, + 267, + 84, + ): list([ + 168, + ]), + tuple( + 450, + 267, + 84, + ): list([ + 169, + ]), + tuple( + 450, + 268, + 85, + ): list([ + 170, + ]), + tuple( + 451, + 268, + 85, + ): list([ + 171, + ]), + tuple( + 451, + 269, + 86, + ): list([ + 172, + ]), + tuple( + 452, + 269, + 86, + ): list([ + 173, + ]), + tuple( + 452, + 270, + 87, + ): list([ + 174, + ]), + tuple( + 453, + 270, + 87, + ): list([ + 175, + ]), + tuple( + 456, + 273, + 90, + ): list([ + 181, + ]), + tuple( + 456, + 274, + 91, + ): list([ + 182, + ]), + tuple( + 457, + 274, + 91, + ): list([ + 183, + ]), + tuple( + 457, + 275, + 92, + ): list([ + 184, + ]), + tuple( + 458, + 275, + 92, + ): list([ + 185, + ]), + tuple( + 458, + 276, + 93, + ): list([ + 186, + ]), + tuple( + 459, + 276, + 93, + ): list([ + 187, + ]), + tuple( + 459, + 277, + 94, + ): list([ + 188, + ]), + tuple( + 460, + 277, + 94, + ): list([ + 189, + ]), + tuple( + 460, + 278, + 95, + ): list([ + 190, + ]), + tuple( + 461, + 278, + 95, + ): list([ + 191, + ]), + tuple( + 464, + 281, + 98, + ): list([ + 197, + ]), + tuple( + 464, + 282, + 99, + ): list([ + 198, + ]), + tuple( + 465, + 282, + 99, + ): list([ + 199, + ]), + tuple( + 465, + 283, + 100, + ): list([ + 200, + ]), + tuple( + 466, + 283, + 100, + ): list([ + 201, + ]), + tuple( + 466, + 284, + 101, + ): list([ + 202, + ]), + tuple( + 467, + 284, + 101, + ): list([ + 203, + ]), + tuple( + 467, + 285, + 102, + ): list([ + 204, + ]), + tuple( + 468, + 285, + 102, + ): list([ + 205, + ]), + tuple( + 468, + 286, + 103, + ): list([ + 206, + ]), + tuple( + 469, + 286, + 103, + ): list([ + 207, + ]), + tuple( + 472, + 289, + 106, + ): list([ + 213, + ]), + tuple( + 472, + 290, + 107, + ): list([ + 214, + ]), + tuple( + 473, + 290, + 107, + ): list([ + 215, + ]), + tuple( + 473, + 291, + 108, + ): list([ + 216, + ]), + tuple( + 474, + 291, + 108, + ): list([ + 217, + ]), + tuple( + 474, + 292, + 109, + ): list([ + 218, + ]), + tuple( + 475, + 292, + 109, + ): list([ + 219, + ]), + tuple( + 475, + 293, + 110, + ): list([ + 220, + ]), + tuple( + 476, + 293, + 110, + ): list([ + 221, + ]), + tuple( + 476, + 294, + 111, + ): list([ + 222, + ]), + tuple( + 477, + 294, + 111, + ): list([ + 223, + ]), + tuple( + 480, + 297, + 114, + ): list([ + 229, + ]), + tuple( + 480, + 298, + 115, + ): list([ + 230, + ]), + tuple( + 481, + 298, + 115, + ): list([ + 231, + ]), + tuple( + 481, + 299, + 116, + ): list([ + 232, + ]), + tuple( + 482, + 299, + 116, + ): list([ + 233, + ]), + tuple( + 482, + 300, + 117, + ): list([ + 234, + ]), + tuple( + 483, + 300, + 117, + ): list([ + 235, + ]), + tuple( + 483, + 301, + 118, + ): list([ + 236, + ]), + tuple( + 484, + 301, + 118, + ): list([ + 237, + ]), + tuple( + 484, + 302, + 119, + ): list([ + 238, + ]), + tuple( + 485, + 302, + 119, + ): list([ + 239, + ]), + tuple( + 488, + 305, + 122, + ): list([ + 245, + ]), + tuple( + 488, + 306, + 123, + ): list([ + 246, + ]), + tuple( + 489, + 306, + 123, + ): list([ + 247, + ]), + tuple( + 489, + 307, + 124, + ): list([ + 248, + ]), + tuple( + 490, + 307, + 124, + ): list([ + 249, + ]), + tuple( + 490, + 308, + 125, + ): list([ + 250, + ]), + tuple( + 491, + 308, + 125, + ): list([ + 251, + ]), + tuple( + 491, + 309, + 126, + ): list([ + 252, + ]), + tuple( + 492, + 309, + 126, + ): list([ + 253, + ]), + tuple( + 492, + 310, + 127, + ): list([ + 254, + ]), + tuple( + 493, + 310, + 127, + ): list([ + 255, + ]), + tuple( + 496, + 313, + 130, + ): list([ + 261, + ]), + tuple( + 496, + 314, + 131, + ): list([ + 262, + ]), + tuple( + 497, + 314, + 131, + ): list([ + 263, + ]), + tuple( + 497, + 315, + 132, + ): list([ + 264, + ]), + tuple( + 498, + 315, + 132, + ): list([ + 265, + ]), + tuple( + 498, + 316, + 133, + ): list([ + 266, + ]), + tuple( + 499, + 316, + 133, + ): list([ + 267, + ]), + tuple( + 499, + 317, + 134, + ): list([ + 268, + ]), + tuple( + 500, + 317, + 134, + ): list([ + 269, + ]), + tuple( + 500, + 318, + 135, + ): list([ + 270, + ]), + tuple( + 501, + 318, + 135, + ): list([ + 271, + ]), + tuple( + 504, + 321, + 138, + ): list([ + 277, + ]), + tuple( + 504, + 322, + 139, + ): list([ + 278, + ]), + tuple( + 505, + 322, + 139, + ): list([ + 279, + ]), + tuple( + 505, + 323, + 140, + ): list([ + 280, + ]), + tuple( + 506, + 323, + 140, + ): list([ + 281, + ]), + tuple( + 506, + 324, + 141, + ): list([ + 282, + ]), + tuple( + 507, + 324, + 141, + ): list([ + 283, + ]), + tuple( + 507, + 325, + 142, + ): list([ + 284, + ]), + tuple( + 508, + 325, + 142, + ): list([ + 285, + ]), + tuple( + 508, + 326, + 143, + ): list([ + 286, + ]), + tuple( + 509, + 326, + 143, + ): list([ + 287, + ]), + tuple( + 512, + 329, + 146, + ): list([ + 293, + ]), + tuple( + 512, + 330, + 147, + ): list([ + 294, + ]), + tuple( + 513, + 330, + 147, + ): list([ + 295, + ]), + tuple( + 513, + 331, + 148, + ): list([ + 296, + ]), + tuple( + 514, + 331, + 148, + ): list([ + 297, + ]), + tuple( + 514, + 332, + 149, + ): list([ + 298, + ]), + tuple( + 515, + 332, + 149, + ): list([ + 299, + ]), + tuple( + 515, + 333, + 150, + ): list([ + 300, + ]), + tuple( + 516, + 333, + 150, + ): list([ + 301, + ]), + tuple( + 516, + 334, + 151, + ): list([ + 302, + ]), + tuple( + 517, + 334, + 151, + ): list([ + 303, + ]), + tuple( + 520, + 337, + 154, + ): list([ + 309, + ]), + tuple( + 520, + 338, + 155, + ): list([ + 310, + ]), + tuple( + 521, + 338, + 155, + ): list([ + 311, + ]), + tuple( + 521, + 339, + 156, + ): list([ + 312, + ]), + tuple( + 522, + 339, + 156, + ): list([ + 313, + ]), + tuple( + 522, + 340, + 157, + ): list([ + 314, + ]), + tuple( + 523, + 340, + 157, + ): list([ + 315, + ]), + tuple( + 523, + 341, + 158, + ): list([ + 316, + ]), + tuple( + 524, + 341, + 158, + ): list([ + 317, + ]), + tuple( + 524, + 342, + 159, + ): list([ + 318, + ]), + tuple( + 525, + 342, + 159, + ): list([ + 319, + ]), + tuple( + 528, + 345, + 162, + ): list([ + 325, + ]), + tuple( + 528, + 346, + 163, + ): list([ + 326, + ]), + tuple( + 529, + 346, + 163, + ): list([ + 327, + ]), + tuple( + 529, + 347, + 164, + ): list([ + 328, + ]), + tuple( + 530, + 347, + 164, + ): list([ + 329, + ]), + tuple( + 530, + 348, + 165, + ): list([ + 330, + ]), + tuple( + 531, + 348, + 165, + ): list([ + 331, + ]), + tuple( + 531, + 349, + 166, + ): list([ + 332, + ]), + tuple( + 532, + 349, + 166, + ): list([ + 333, + ]), + tuple( + 532, + 350, + 167, + ): list([ + 334, + ]), + tuple( + 533, + 350, + 167, + ): list([ + 335, + ]), + tuple( + 536, + 353, + 170, + ): list([ + 341, + ]), + tuple( + 536, + 354, + 171, + ): list([ + 342, + ]), + tuple( + 537, + 354, + 171, + ): list([ + 343, + ]), + tuple( + 537, + 355, + 172, + ): list([ + 344, + ]), + tuple( + 538, + 355, + 172, + ): list([ + 345, + ]), + tuple( + 538, + 356, + 173, + ): list([ + 346, + ]), + tuple( + 539, + 356, + 173, + ): list([ + 347, + ]), + tuple( + 539, + 357, + 174, + ): list([ + 348, + ]), + tuple( + 540, + 357, + 174, + ): list([ + 349, + ]), + tuple( + 540, + 358, + 175, + ): list([ + 350, + ]), + tuple( + 541, + 358, + 175, + ): list([ + 351, + ]), + tuple( + 544, + 361, + 178, + ): list([ + 357, + ]), + tuple( + 544, + 362, + 179, + ): list([ + 358, + ]), + tuple( + 545, + 362, + 179, + ): list([ + 359, + ]), + tuple( + 545, + 363, + 180, + ): list([ + 360, + ]), + tuple( + 546, + 363, + 180, + ): list([ + 361, + ]), + tuple( + 546, + 364, + 181, + ): list([ + 362, + ]), + tuple( + 547, + 364, + 181, + ): list([ + 363, + ]), + tuple( + 547, + 365, + 182, + ): list([ + 364, + 365, + ]), + }) +# --- +# name: test_snapshot_cohorts[ERA5Google] + dict({ + tuple( + 0, + 1, + 2, + 3, + 124, + 125, + 126, + 127, + 236, + 237, + 238, + 239, + 360, + 361, + 362, + 363, + 480, + 481, + 482, + 483, + 604, + 605, + 606, + 607, + 724, + 725, + 726, + 727, + 848, + 849, + 850, + 851, + ): list([ + 0, + ]), + tuple( + 4, + 5, + 6, + 7, + 128, + 129, + 130, + 131, + 240, + 241, + 242, + 243, + 364, + 365, + 366, + 367, + 484, + 485, + 486, + 487, + 608, + 609, + 610, + 611, + 728, + 729, + 730, + 731, + 852, + 853, + 854, + 855, + ): list([ + 1, + ]), + tuple( + 8, + 9, + 10, + 11, + 132, + 133, + 134, + 135, + 244, + 245, + 246, + 247, + 368, + 369, + 370, + 371, + 488, + 489, + 490, + 491, + 612, + 613, + 614, + 615, + 732, + 733, + 734, + 735, + 856, + 857, + 858, + 859, + ): list([ + 2, + ]), + tuple( + 12, + 13, + 14, + 15, + 136, + 137, + 138, + 139, + 248, + 249, + 250, + 251, + 372, + 373, + 374, + 375, + 492, + 493, + 494, + 495, + 616, + 617, + 618, + 619, + 736, + 737, + 738, + 739, + 860, + 861, + 862, + 863, + ): list([ + 3, + ]), + tuple( + 16, + 17, + 18, + 19, + 140, + 141, + 142, + 143, + 252, + 253, + 254, + 255, + 376, + 377, + 378, + 379, + 496, + 497, + 498, + 499, + 620, + 621, + 622, + 623, + 740, + 741, + 742, + 743, + 864, + 865, + 866, + 867, + ): list([ + 4, + ]), + tuple( + 20, + 21, + 22, + 23, + 144, + 145, + 146, + 147, + 256, + 257, + 258, + 259, + 380, + 381, + 382, + 383, + 500, + 501, + 502, + 503, + 624, + 625, + 626, + 627, + 744, + 745, + 746, + 747, + 868, + 869, + 870, + 871, + ): list([ + 5, + ]), + tuple( + 24, + 25, + 26, + 27, + 148, + 149, + 150, + 151, + 260, + 261, + 262, + 263, + 384, + 385, + 386, + 387, + 504, + 505, + 506, + 507, + 628, + 629, + 630, + 631, + 748, + 749, + 750, + 751, + 872, + 873, + 874, + 875, + ): list([ + 6, + ]), + tuple( + 28, + 29, + 30, + 31, + 152, + 153, + 154, + 155, + 264, + 265, + 266, + 267, + 388, + 389, + 390, + 391, + 508, + 509, + 510, + 511, + 632, + 633, + 634, + 635, + 752, + 753, + 754, + 755, + 876, + 877, + 878, + 879, + ): list([ + 7, + ]), + tuple( + 32, + 33, + 34, + 35, + 156, + 157, + 158, + 159, + 268, + 269, + 270, + 271, + 392, + 393, + 394, + 395, + 512, + 513, + 514, + 515, + 636, + 637, + 638, + 639, + 756, + 757, + 758, + 759, + 880, + 881, + 882, + 883, + ): list([ + 8, + ]), + tuple( + 36, + 37, + 38, + 39, + 160, + 161, + 162, + 163, + 272, + 273, + 274, + 275, + 396, + 397, + 398, + 399, + 516, + 517, + 518, + 519, + 640, + 641, + 642, + 643, + 760, + 761, + 762, + 763, + 884, + 885, + 886, + 887, + ): list([ + 9, + ]), + tuple( + 40, + 41, + 42, + 43, + 164, + 165, + 166, + 167, + 276, + 277, + 278, + 279, + 400, + 401, + 402, + 403, + 520, + 521, + 522, + 523, + 644, + 645, + 646, + 647, + 764, + 765, + 766, + 767, + 888, + 889, + 890, + 891, + ): list([ + 10, + ]), + tuple( + 44, + 45, + 46, + 47, + 168, + 169, + 170, + 171, + 280, + 281, + 282, + 283, + 404, + 405, + 406, + 407, + 524, + 525, + 526, + 527, + 648, + 649, + 650, + 651, + 768, + 769, + 770, + 771, + 892, + 893, + 894, + 895, + ): list([ + 11, + ]), + tuple( + 48, + 49, + 50, + 51, + 172, + 173, + 174, + 175, + 284, + 285, + 286, + 287, + 408, + 409, + 410, + 411, + 528, + 529, + 530, + 531, + 652, + 653, + 654, + 655, + 772, + 773, + 774, + 775, + 896, + 897, + 898, + 899, + ): list([ + 12, + ]), + tuple( + 52, + 53, + 54, + 55, + 176, + 177, + 178, + 179, + 288, + 289, + 290, + 291, + 412, + 413, + 414, + 415, + 532, + 533, + 534, + 535, + 656, + 657, + 658, + 659, + 776, + 777, + 778, + 779, + ): list([ + 13, + ]), + tuple( + 56, + 57, + 58, + 59, + 180, + 181, + 182, + 183, + 292, + 293, + 294, + 295, + 416, + 417, + 418, + 419, + 536, + 537, + 538, + 539, + 660, + 661, + 662, + 663, + 780, + 781, + 782, + 783, + ): list([ + 14, + ]), + tuple( + 60, + 61, + 62, + 63, + 184, + 185, + 186, + 187, + 296, + 297, + 298, + 299, + 420, + 421, + 422, + 423, + 540, + 541, + 542, + 543, + 664, + 665, + 666, + 667, + 784, + 785, + 786, + 787, + ): list([ + 15, + ]), + tuple( + 64, + 65, + 66, + 67, + 188, + 189, + 190, + 191, + 300, + 301, + 302, + 303, + 424, + 425, + 426, + 427, + 544, + 545, + 546, + 547, + 668, + 669, + 670, + 671, + 788, + 789, + 790, + 791, + ): list([ + 16, + ]), + tuple( + 68, + 69, + 70, + 71, + 192, + 193, + 194, + 195, + 304, + 305, + 306, + 307, + 428, + 429, + 430, + 431, + 548, + 549, + 550, + 551, + 672, + 673, + 674, + 675, + 792, + 793, + 794, + 795, + ): list([ + 17, + ]), + tuple( + 72, + 73, + 74, + 75, + 196, + 197, + 198, + 199, + 308, + 309, + 310, + 311, + 432, + 433, + 434, + 435, + 552, + 553, + 554, + 555, + 676, + 677, + 678, + 679, + 796, + 797, + 798, + 799, + ): list([ + 18, + ]), + tuple( + 76, + 77, + 78, + 79, + 200, + 201, + 202, + 203, + 312, + 313, + 314, + 315, + 436, + 437, + 438, + 439, + 556, + 557, + 558, + 559, + 680, + 681, + 682, + 683, + 800, + 801, + 802, + 803, + ): list([ + 19, + ]), + tuple( + 80, + 81, + 82, + 83, + 204, + 205, + 206, + 207, + 316, + 317, + 318, + 319, + 440, + 441, + 442, + 443, + 560, + 561, + 562, + 563, + 684, + 685, + 686, + 687, + 804, + 805, + 806, + 807, + ): list([ + 20, + ]), + tuple( + 84, + 85, + 86, + 87, + 208, + 209, + 210, + 211, + 320, + 321, + 322, + 323, + 444, + 445, + 446, + 447, + 564, + 565, + 566, + 567, + 688, + 689, + 690, + 691, + 808, + 809, + 810, + 811, + ): list([ + 21, + ]), + tuple( + 88, + 89, + 90, + 91, + 212, + 213, + 214, + 215, + 324, + 325, + 326, + 327, + 448, + 449, + 450, + 451, + 568, + 569, + 570, + 571, + 692, + 693, + 694, + 695, + 812, + 813, + 814, + 815, + ): list([ + 22, + ]), + tuple( + 92, + 93, + 94, + 95, + 216, + 217, + 218, + 219, + 328, + 329, + 330, + 331, + 452, + 453, + 454, + 455, + 572, + 573, + 574, + 575, + 696, + 697, + 698, + 699, + 816, + 817, + 818, + 819, + ): list([ + 23, + ]), + tuple( + 96, + 97, + 98, + 99, + 220, + 221, + 222, + 223, + 332, + 333, + 334, + 335, + 456, + 457, + 458, + 459, + 576, + 577, + 578, + 579, + 700, + 701, + 702, + 703, + 820, + 821, + 822, + 823, + ): list([ + 24, + ]), + tuple( + 100, + 101, + 102, + 103, + 224, + 225, + 226, + 227, + 336, + 337, + 338, + 339, + 460, + 461, + 462, + 463, + 580, + 581, + 582, + 583, + 704, + 705, + 706, + 707, + 824, + 825, + 826, + 827, + ): list([ + 25, + ]), + tuple( + 104, + 105, + 106, + 107, + 228, + 229, + 230, + 231, + 340, + 341, + 342, + 343, + 464, + 465, + 466, + 467, + 584, + 585, + 586, + 587, + 708, + 709, + 710, + 711, + 828, + 829, + 830, + 831, + ): list([ + 26, + ]), + tuple( + 108, + 109, + 110, + 111, + 232, + 233, + 234, + 235, + 344, + 345, + 346, + 347, + 468, + 469, + 470, + 471, + 588, + 589, + 590, + 591, + 712, + 713, + 714, + 715, + 832, + 833, + 834, + 835, + ): list([ + 27, + ]), + tuple( + 112, + 113, + 114, + 115, + 348, + 349, + 350, + 351, + 472, + 473, + 474, + 475, + 592, + 593, + 594, + 595, + 716, + 717, + 718, + 719, + 836, + 837, + 838, + 839, + ): list([ + 28, + ]), + tuple( + 116, + 117, + 118, + 119, + 352, + 353, + 354, + 355, + 476, + 477, + 478, + 479, + 596, + 597, + 598, + 599, + 720, + 721, + 722, + 723, + 840, + 841, + 842, + 843, + ): list([ + 29, + ]), + tuple( + 120, + 121, + 122, + 123, + 356, + 357, + 358, + 359, + 600, + 601, + 602, + 603, + 844, + 845, + 846, + 847, + ): list([ + 30, + ]), + }) +# --- +# name: test_snapshot_cohorts[ERA5MonthHourRechunked] + dict({ + tuple( + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + ]), + tuple( + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + ): list([ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + ]), + tuple( + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 516, + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 122, + 123, + 124, + 125, + 126, + 127, + ): list([ + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + ]), + tuple( + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + ): list([ + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + ]), + tuple( + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 547, + 548, + 549, + 550, + 551, + 552, + 553, + 554, + 555, + 556, + 557, + 558, + 559, + 560, + 561, + 562, + 168, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + ): list([ + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + ]), + tuple( + 183, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 562, + 563, + 564, + 565, + 566, + 567, + 568, + 569, + 570, + 571, + 572, + 573, + 574, + 575, + 576, + 577, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + ): list([ + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + ]), + tuple( + 256, + 257, + 258, + 61, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + ): list([ + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + ]), + tuple( + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 455, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 76, + ): list([ + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + ]), + tuple( + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + ): list([ + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + ]), + tuple( + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + ): list([ + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + ]), + tuple( + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 577, + 578, + 579, + 580, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591, + 592, + 593, + 380, + 381, + 382, + 383, + ): list([ + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + ]), + tuple( + 512, + 513, + 514, + 515, + 516, + 505, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 506, + 507, + 503, + 122, + 504, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 501, + 502, + 508, + 509, + 510, + 511, + ): list([ + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + ]), + }) +# --- +# name: test_snapshot_cohorts[ERA5MonthHour] + dict({ + tuple( + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + ]), + tuple( + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 122, + 123, + 124, + 125, + 126, + 127, + ): list([ + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + ]), + tuple( + 256, + 257, + 258, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + ): list([ + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + ]), + tuple( + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + ): list([ + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + ]), + tuple( + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + ): list([ + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + ]), + tuple( + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + ): list([ + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + ]), + tuple( + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 381, + 382, + 383, + ): list([ + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + ]), + tuple( + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + ): list([ + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + ]), + tuple( + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + ): list([ + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + ]), + tuple( + 512, + 513, + 514, + 515, + 516, + 517, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 502, + 503, + 504, + 505, + 506, + 507, + 508, + 509, + 510, + 511, + ): list([ + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + ]), + tuple( + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + ): list([ + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + ]), + tuple( + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + ): list([ + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + ]), + }) +# --- +# name: test_snapshot_cohorts[NWMMidwest] + dict({ + tuple( + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 26, + 27, + 39, + 52, + 65, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 25, + 26, + 27, + 29, + ]), + tuple( + 2, + 3, + 5, + 6, + 10, + 12, + 14, + 15, + 52, + 26, + 27, + ): list([ + 24, + 28, + ]), + tuple( + 2, + 4, + 6, + 14, + 15, + 26, + 27, + ): list([ + 30, + ]), + tuple( + 3, + 4, + 5, + 7, + 39, + 40, + 8, + 9, + 14, + 15, + 16, + 26, + 27, + 28, + ): list([ + 32, + 33, + 35, + 36, + 37, + 38, + 40, + 46, + 51, + ]), + tuple( + 3, + 4, + 6, + 15, + 16, + 17, + 27, + ): list([ + 34, + 41, + ]), + tuple( + 3, + 6, + 7, + 14, + 15, + 26, + 27, + ): list([ + 31, + ]), + tuple( + 4, + 5, + 6, + 8, + 40, + 9, + 15, + 17, + 18, + 27, + 28, + ): list([ + 49, + 53, + 56, + 57, + ]), + tuple( + 4, + 10, + 11, + 15, + 17, + 52, + 53, + ): list([ + 45, + ]), + tuple( + 5, + 6, + 7, + 10, + 11, + 12, + 15, + 16, + 52, + 53, + 27, + 28, + ): list([ + 43, + 47, + 50, + ]), + tuple( + 6, + 7, + 40, + 9, + 41, + 8, + 16, + 17, + 19, + 20, + 21, + 27, + 28, + ): list([ + 44, + 54, + 55, + 58, + 60, + 63, + 66, + 69, + 72, + 80, + ]), + tuple( + 6, + 10, + 11, + 19, + 53, + 28, + ): list([ + 62, + ]), + tuple( + 6, + 39, + 40, + 9, + 15, + 16, + 27, + ): list([ + 39, + ]), + tuple( + 7, + 8, + 40, + 11, + 15, + 16, + 17, + 52, + 53, + ): list([ + 48, + ]), + tuple( + 7, + 40, + 9, + 10, + 8, + 41, + 11, + 16, + 17, + 18, + 53, + 28, + 29, + ): list([ + 59, + 61, + 64, + 65, + 67, + ]), + tuple( + 8, + 41, + 10, + 11, + 17, + 21, + 53, + 54, + ): list([ + 75, + 79, + ]), + tuple( + 9, + 10, + 41, + 22, + 23, + 54, + ): list([ + 87, + ]), + tuple( + 9, + 41, + 17, + 18, + 22, + 30, + ): list([ + 84, + ]), + tuple( + 10, + 11, + 54, + 23, + 24, + ): list([ + 93, + ]), + tuple( + 10, + 12, + 18, + 19, + 20, + 53, + 54, + 28, + 29, + ): list([ + 76, + 85, + ]), + tuple( + 11, + 19, + 54, + 24, + 29, + 30, + ): list([ + 99, + ]), + tuple( + 16, + 17, + 18, + 29, + 30, + 31, + ): list([ + 78, + 92, + ]), + tuple( + 24, + 54, + 31, + ): list([ + 111, + ]), + tuple( + 25, + 67, + 54, + ): list([ + 120, + ]), + tuple( + 32, + 33, + 34, + 35, + 44, + 45, + 55, + 24, + 25, + 56, + ): list([ + 143, + 145, + 149, + 154, + 156, + 160, + 163, + 164, + 166, + 169, + 170, + 175, + 183, + 190, + ]), + tuple( + 32, + 33, + 34, + 36, + 37, + 45, + 46, + 47, + 57, + ): list([ + 165, + 172, + 173, + 178, + 179, + 180, + 185, + ]), + tuple( + 32, + 33, + 34, + 44, + 23, + 55, + 24, + 56, + ): list([ + 121, + 140, + 144, + 151, + 153, + 155, + ]), + tuple( + 32, + 33, + 41, + 42, + 23, + 55, + 54, + 22, + 24, + 25, + 31, + ): list([ + 101, + 113, + 116, + 124, + 125, + 129, + 130, + 131, + ]), + tuple( + 32, + 33, + 42, + 19, + 20, + 22, + 30, + 31, + ): list([ + 110, + 122, + 159, + ]), + tuple( + 32, + 33, + 45, + ): list([ + 150, + 158, + ]), + tuple( + 32, + 33, + 55, + 24, + 31, + ): list([ + 137, + ]), + tuple( + 32, + 41, + 42, + 43, + 19, + 20, + 21, + 22, + 23, + 54, + 24, + 29, + 30, + 31, + ): list([ + 77, + 90, + 94, + 95, + 98, + 100, + 104, + 107, + 108, + 109, + 112, + 115, + 117, + ]), + tuple( + 32, + 42, + 43, + 20, + 21, + 31, + ): list([ + 123, + ]), + tuple( + 32, + 43, + 22, + ): list([ + 139, + ]), + tuple( + 33, + 34, + 35, + 42, + 43, + 44, + 20, + 21, + 22, + ): list([ + 106, + 119, + 128, + 132, + 138, + 141, + 147, + 152, + ]), + tuple( + 33, + 43, + 44, + 20, + 30, + 31, + ): list([ + 118, + 126, + 135, + 142, + ]), + tuple( + 34, + 46, + 47, + ): list([ + 187, + 193, + ]), + tuple( + 35, + 36, + 37, + 38, + 44, + 45, + 46, + 57, + 58, + 59, + ): list([ + 168, + 177, + 186, + 191, + 195, + 199, + 203, + 204, + 213, + ]), + tuple( + 35, + 36, + 43, + 44, + 22, + 23, + 56, + 57, + ): list([ + 146, + 157, + 162, + ]), + tuple( + 35, + 36, + 46, + 48, + 49, + 59, + ): list([ + 200, + 205, + 212, + 219, + ]), + tuple( + 35, + 37, + 44, + 24, + 57, + 56, + ): list([ + 171, + 176, + 192, + 198, + ]), + tuple( + 35, + 38, + 45, + 56, + 25, + 57, + ): list([ + 181, + ]), + tuple( + 36, + 37, + 23, + 24, + 57, + 56, + ): list([ + 167, + 182, + 189, + ]), + tuple( + 36, + 37, + 38, + 46, + 47, + 48, + 57, + 58, + ): list([ + 188, + 201, + 208, + 211, + 217, + 223, + ]), + tuple( + 36, + 37, + 47, + 58, + 59, + ): list([ + 197, + 206, + 210, + 216, + 221, + ]), + tuple( + 36, + 37, + 49, + 50, + 59, + ): list([ + 224, + 230, + 234, + ]), + tuple( + 37, + 49, + 58, + 59, + 60, + ): list([ + 225, + ]), + tuple( + 38, + 71, + 72, + 58, + 59, + ): list([ + 218, + 226, + 231, + 237, + ]), + tuple( + 38, + 72, + 73, + 51, + 59, + 60, + ): list([ + 245, + 252, + 260, + 267, + ]), + tuple( + 39, + 40, + 9, + 10, + 52, + 53, + ): list([ + 42, + ]), + tuple( + 40, + 9, + 10, + 41, + 53, + 54, + ): list([ + 74, + ]), + tuple( + 40, + 9, + 41, + 12, + 18, + 19, + 53, + 22, + 28, + 29, + ): list([ + 68, + 82, + ]), + tuple( + 40, + 9, + 41, + 16, + 17, + 18, + 29, + ): list([ + 71, + ]), + tuple( + 41, + 10, + 18, + 19, + 21, + 54, + 23, + 29, + 30, + ): list([ + 73, + 86, + 89, + 91, + ]), + tuple( + 41, + 11, + 18, + 20, + 53, + 54, + 21, + 24, + 29, + 30, + ): list([ + 81, + 83, + 96, + ]), + tuple( + 41, + 18, + 22, + 30, + 31, + ): list([ + 97, + 103, + ]), + tuple( + 42, + 43, + 20, + 21, + 54, + 24, + ): list([ + 114, + ]), + tuple( + 42, + 43, + 23, + 22, + 55, + 24, + 56, + ): list([ + 127, + 136, + ]), + tuple( + 43, + 23, + 21, + 55, + 24, + ): list([ + 133, + ]), + tuple( + 46, + 47, + 48, + 49, + 50, + 59, + 60, + ): list([ + 194, + 202, + 209, + 214, + 215, + 220, + 222, + 227, + 228, + 229, + 232, + 233, + 235, + 236, + 241, + 243, + ]), + tuple( + 48, + 49, + 50, + 61, + 62, + 63, + ): list([ + 253, + 254, + 255, + 258, + 259, + 261, + 263, + 264, + 265, + 266, + 269, + 270, + 271, + 274, + 275, + 276, + 279, + 280, + 283, + 284, + 287, + 290, + ]), + tuple( + 48, + 49, + 61, + ): list([ + 242, + 249, + ]), + tuple( + 49, + 50, + 60, + ): list([ + 239, + 246, + 247, + 250, + 251, + 257, + ]), + tuple( + 49, + 51, + 59, + 60, + 61, + ): list([ + 248, + 256, + 262, + ]), + tuple( + 50, + 59, + 60, + ): list([ + 238, + 244, + ]), + tuple( + 59, + 51, + 38, + ): list([ + 240, + ]), + tuple( + 64, + 74, + 75, + 51, + 61, + 62, + ): list([ + 268, + 272, + 273, + 277, + 278, + 281, + ]), + tuple( + 64, + 75, + 76, + 62, + 63, + ): list([ + 282, + 285, + 286, + 288, + 289, + 291, + 292, + 293, + 294, + ]), + tuple( + 64, + 77, + ): list([ + 295, + 296, + ]), + tuple( + 65, + 66, + 12, + 52, + 53, + ): list([ + 52, + ]), + tuple( + 66, + 67, + 12, + 53, + 54, + ): list([ + 70, + 88, + ]), + tuple( + 67, + 42, + 12, + 19, + 21, + 54, + 25, + 30, + ): list([ + 102, + 105, + ]), + tuple( + 68, + 69, + 55, + 56, + 25, + ): list([ + 134, + 148, + 161, + ]), + tuple( + 69, + 38, + 70, + 56, + 25, + 57, + ): list([ + 174, + 184, + 196, + 207, + ]), + }) +# --- +# name: test_snapshot_cohorts[OISST] + dict({ + tuple( + 0, + 255, + 1168, + 401, + 146, + 657, + 913, + 1424, + 1022, + 767, + 1278, + 1314, + 547, + 36, + 292, + 803, + 1059, + 1315, + 693, + 182, + 438, + 949, + 1205, + 694, + 839, + 72, + 328, + 584, + 1095, + 1351, + 73, + 840, + 1241, + 474, + 219, + 730, + 986, + 1387, + 620, + 109, + 365, + 876, + 1132, + 621, + 1388, + 766, + 511, + ): list([ + 242, + 243, + 244, + ]), + tuple( + 0, + 256, + 255, + 1424, + 401, + 146, + 657, + 767, + 913, + 1169, + 402, + 1023, + 1278, + 803, + 36, + 292, + 548, + 1059, + 1315, + 949, + 182, + 438, + 694, + 1205, + 183, + 950, + 1095, + 328, + 73, + 584, + 840, + 1351, + 329, + 1096, + 730, + 475, + 219, + 986, + 1242, + 876, + 109, + 365, + 621, + 1132, + 1388, + 877, + 1022, + 511, + ): list([ + 245, + 246, + 247, + ]), + tuple( + 0, + 256, + 512, + 1, + 768, + 913, + 146, + 402, + 658, + 1169, + 1425, + 147, + 914, + 1023, + 1279, + 548, + 37, + 293, + 804, + 1060, + 1315, + 694, + 439, + 183, + 950, + 1206, + 840, + 73, + 329, + 585, + 1096, + 1352, + 74, + 841, + 986, + 475, + 219, + 731, + 1242, + 220, + 987, + 1388, + 621, + 110, + 366, + 877, + 1133, + 767, + ): list([ + 251, + 252, + 253, + ]), + tuple( + 0, + 256, + 512, + 1424, + 657, + 146, + 402, + 767, + 913, + 1169, + 658, + 1425, + 1023, + 1059, + 292, + 37, + 548, + 804, + 1315, + 1279, + 1205, + 438, + 183, + 694, + 950, + 439, + 1206, + 1351, + 584, + 73, + 329, + 840, + 1096, + 585, + 1352, + 986, + 475, + 219, + 731, + 1242, + 1132, + 365, + 110, + 621, + 877, + 1388, + 1278, + 511, + ): list([ + 248, + 249, + 250, + ]), + tuple( + 128, + 383, + 1296, + 529, + 18, + 274, + 785, + 1041, + 1297, + 895, + 1406, + 675, + 164, + 420, + 931, + 1187, + 1442, + 1443, + 676, + 821, + 54, + 310, + 566, + 1077, + 1333, + 55, + 822, + 1223, + 456, + 201, + 712, + 968, + 1369, + 602, + 347, + 91, + 858, + 1114, + 603, + 1370, + 748, + 237, + 493, + 1004, + 1260, + 749, + 1150, + 639, + ): list([ + 62, + 63, + 64, + ]), + tuple( + 128, + 384, + 383, + 785, + 18, + 274, + 530, + 1041, + 1297, + 895, + 1151, + 931, + 164, + 420, + 676, + 1187, + 1443, + 165, + 932, + 1077, + 310, + 55, + 566, + 822, + 1333, + 311, + 1078, + 712, + 201, + 457, + 968, + 1224, + 858, + 347, + 603, + 91, + 1114, + 1370, + 859, + 1004, + 237, + 493, + 749, + 1260, + 1005, + 238, + 1406, + 639, + ): list([ + 65, + 66, + 67, + ]), + tuple( + 128, + 384, + 640, + 129, + 896, + 1297, + 530, + 19, + 275, + 786, + 1042, + 1151, + 1443, + 676, + 165, + 421, + 932, + 1188, + 1407, + 1444, + 822, + 567, + 55, + 311, + 1078, + 1334, + 56, + 823, + 968, + 201, + 457, + 713, + 1224, + 202, + 969, + 1370, + 603, + 348, + 92, + 859, + 1115, + 749, + 238, + 494, + 1005, + 1261, + 750, + 895, + ): list([ + 71, + 72, + 73, + ]), + tuple( + 128, + 384, + 640, + 1041, + 274, + 19, + 530, + 786, + 1297, + 895, + 1151, + 1187, + 420, + 165, + 676, + 932, + 1443, + 1407, + 421, + 1188, + 1333, + 566, + 55, + 311, + 822, + 1078, + 567, + 1334, + 968, + 201, + 457, + 713, + 1224, + 1114, + 603, + 347, + 92, + 859, + 1370, + 1260, + 493, + 238, + 749, + 1005, + 494, + 1261, + 1406, + 639, + ): list([ + 68, + 69, + 70, + ]), + tuple( + 256, + 1, + 512, + 768, + 1024, + 1169, + 402, + 147, + 658, + 914, + 1425, + 1170, + 403, + 1279, + 548, + 37, + 293, + 804, + 1060, + 1316, + 549, + 950, + 439, + 183, + 695, + 1206, + 1096, + 329, + 74, + 585, + 841, + 1352, + 330, + 1097, + 1242, + 475, + 220, + 731, + 987, + 476, + 1243, + 877, + 110, + 366, + 622, + 1133, + 1389, + 1023, + ): list([ + 254, + 255, + 256, + ]), + tuple( + 382, + 893, + 527, + 16, + 272, + 783, + 1039, + 1295, + 528, + 1149, + 1404, + 929, + 162, + 418, + 674, + 1185, + 1441, + 1075, + 308, + 53, + 564, + 820, + 1331, + 309, + 1076, + 1221, + 454, + 199, + 710, + 966, + 455, + 1222, + 856, + 345, + 601, + 89, + 1112, + 1368, + 1002, + 235, + 491, + 747, + 1258, + 1003, + 381, + 1148, + 637, + 126, + ): list([ + 44, + 45, + 46, + ]), + tuple( + 382, + 1295, + 528, + 17, + 273, + 784, + 894, + 1040, + 1296, + 529, + 1150, + 1405, + 674, + 163, + 419, + 930, + 1186, + 1442, + 675, + 1076, + 309, + 54, + 565, + 821, + 1332, + 1222, + 455, + 200, + 711, + 967, + 456, + 1223, + 1368, + 601, + 346, + 90, + 857, + 1113, + 602, + 1369, + 1003, + 236, + 492, + 748, + 1259, + 1149, + 638, + 127, + ): list([ + 53, + 54, + 55, + ]), + tuple( + 384, + 129, + 640, + 896, + 1152, + 385, + 530, + 19, + 275, + 786, + 1042, + 1298, + 531, + 932, + 165, + 421, + 677, + 1188, + 1407, + 1444, + 1078, + 567, + 311, + 56, + 823, + 1334, + 312, + 1079, + 1224, + 457, + 202, + 713, + 969, + 458, + 1225, + 859, + 348, + 92, + 604, + 1115, + 1371, + 1005, + 238, + 494, + 750, + 1261, + 1006, + 1151, + ): list([ + 74, + 75, + 76, + ]), + tuple( + 509, + 764, + 1020, + 1421, + 654, + 143, + 399, + 910, + 1166, + 655, + 1422, + 1276, + 1056, + 289, + 34, + 545, + 801, + 1312, + 1202, + 435, + 180, + 691, + 947, + 436, + 1203, + 1348, + 581, + 70, + 326, + 837, + 1093, + 582, + 1349, + 983, + 472, + 216, + 728, + 1239, + 1129, + 362, + 107, + 618, + 874, + 1385, + 1275, + 508, + 253, + ): list([ + 218, + 219, + 220, + ]), + tuple( + 511, + 766, + 912, + 145, + 401, + 657, + 1168, + 1424, + 1022, + 1278, + 1058, + 291, + 36, + 547, + 803, + 1314, + 292, + 1059, + 1204, + 437, + 182, + 693, + 949, + 438, + 1205, + 839, + 72, + 328, + 584, + 1095, + 1351, + 985, + 474, + 218, + 730, + 1241, + 1131, + 364, + 109, + 620, + 876, + 1387, + 365, + 1132, + 1277, + 510, + 255, + ): list([ + 239, + 240, + 241, + ]), + tuple( + 512, + 1, + 257, + 768, + 1024, + 1425, + 658, + 147, + 403, + 914, + 1170, + 659, + 1426, + 804, + 37, + 293, + 549, + 1060, + 1316, + 38, + 805, + 1206, + 439, + 184, + 695, + 951, + 1352, + 585, + 74, + 330, + 841, + 1097, + 586, + 1353, + 731, + 476, + 220, + 987, + 1243, + 732, + 1133, + 110, + 366, + 622, + 878, + 1389, + 111, + 1279, + ): list([ + 257, + 258, + 259, + ]), + tuple( + 637, + 892, + 1038, + 271, + 16, + 527, + 783, + 1148, + 1294, + 1404, + 1184, + 417, + 162, + 673, + 929, + 1440, + 418, + 1185, + 1330, + 563, + 52, + 308, + 819, + 1075, + 564, + 1331, + 965, + 198, + 454, + 710, + 1221, + 1111, + 600, + 344, + 89, + 856, + 1367, + 1257, + 490, + 235, + 746, + 1002, + 491, + 1258, + 125, + 1403, + 636, + 381, + ): list([ + 38, + 39, + 40, + ]), + tuple( + 638, + 893, + 783, + 16, + 272, + 528, + 1039, + 1295, + 1149, + 17, + 784, + 1405, + 1185, + 418, + 163, + 674, + 930, + 1441, + 1331, + 564, + 53, + 309, + 820, + 1076, + 565, + 1332, + 710, + 199, + 455, + 966, + 1222, + 711, + 1112, + 345, + 601, + 89, + 857, + 1368, + 90, + 1258, + 491, + 236, + 747, + 1003, + 126, + 1404, + 637, + 382, + ): list([ + 47, + 48, + 49, + ]), + tuple( + 638, + 1039, + 272, + 17, + 528, + 784, + 1295, + 1149, + 273, + 1040, + 894, + 1405, + 1441, + 674, + 163, + 419, + 930, + 1186, + 820, + 53, + 309, + 565, + 1076, + 1332, + 966, + 199, + 455, + 711, + 1222, + 200, + 967, + 1112, + 601, + 345, + 90, + 857, + 1368, + 346, + 1113, + 747, + 236, + 492, + 1003, + 1259, + 126, + 893, + 382, + 127, + ): list([ + 50, + 51, + 52, + ]), + tuple( + 639, + 1040, + 273, + 18, + 529, + 785, + 1296, + 274, + 1041, + 1150, + 1186, + 419, + 164, + 675, + 931, + 1406, + 1442, + 420, + 1187, + 821, + 54, + 310, + 566, + 1077, + 1333, + 967, + 200, + 456, + 712, + 1223, + 1113, + 602, + 346, + 91, + 858, + 1369, + 347, + 1114, + 1259, + 492, + 237, + 748, + 1004, + 493, + 1260, + 127, + 894, + 383, + ): list([ + 59, + 60, + 61, + ]), + tuple( + 640, + 129, + 385, + 896, + 1152, + 641, + 1408, + 786, + 19, + 275, + 531, + 1042, + 1298, + 20, + 787, + 1188, + 421, + 166, + 677, + 933, + 1444, + 1334, + 567, + 312, + 56, + 823, + 1079, + 568, + 1335, + 713, + 202, + 458, + 969, + 1225, + 714, + 1115, + 348, + 92, + 604, + 860, + 1371, + 93, + 1261, + 494, + 239, + 750, + 1006, + 1407, + ): list([ + 77, + 78, + 79, + ]), + tuple( + 764, + 1019, + 1165, + 398, + 143, + 654, + 910, + 1275, + 1421, + 1311, + 544, + 33, + 289, + 800, + 1056, + 1312, + 690, + 179, + 435, + 946, + 1202, + 691, + 836, + 69, + 325, + 581, + 1092, + 1348, + 70, + 837, + 1238, + 471, + 216, + 727, + 983, + 1384, + 617, + 106, + 362, + 873, + 1129, + 618, + 1385, + 252, + 763, + 508, + ): list([ + 212, + 213, + 214, + ]), + tuple( + 764, + 1020, + 1421, + 398, + 143, + 654, + 910, + 1166, + 1275, + 399, + 800, + 33, + 289, + 545, + 1056, + 1312, + 946, + 179, + 435, + 691, + 1202, + 180, + 947, + 1092, + 325, + 70, + 581, + 837, + 1348, + 326, + 1093, + 727, + 472, + 216, + 983, + 1239, + 873, + 106, + 362, + 618, + 1129, + 1385, + 874, + 252, + 1019, + 508, + 253, + ): list([ + 215, + 216, + 217, + ]), + tuple( + 765, + 1020, + 910, + 143, + 399, + 655, + 1166, + 1422, + 1276, + 144, + 911, + 1312, + 545, + 34, + 290, + 801, + 1057, + 691, + 180, + 436, + 947, + 1203, + 837, + 70, + 326, + 582, + 1093, + 1349, + 71, + 838, + 983, + 472, + 216, + 728, + 1239, + 217, + 984, + 1385, + 618, + 107, + 363, + 874, + 1130, + 253, + 764, + 509, + ): list([ + 221, + 222, + 223, + ]), + tuple( + 765, + 1166, + 399, + 144, + 655, + 911, + 1422, + 1276, + 1167, + 400, + 1021, + 545, + 34, + 290, + 801, + 1057, + 1313, + 546, + 947, + 180, + 436, + 692, + 1203, + 1093, + 326, + 71, + 582, + 838, + 1349, + 327, + 1094, + 1239, + 472, + 217, + 728, + 984, + 473, + 1240, + 874, + 107, + 363, + 619, + 1130, + 1386, + 253, + 1020, + 509, + ): list([ + 224, + 225, + 226, + ]), + tuple( + 765, + 1422, + 655, + 144, + 400, + 911, + 1021, + 1167, + 656, + 1423, + 801, + 34, + 290, + 546, + 1057, + 1313, + 35, + 802, + 1203, + 436, + 181, + 692, + 948, + 1349, + 582, + 71, + 327, + 838, + 1094, + 583, + 1350, + 728, + 473, + 217, + 984, + 1240, + 729, + 1130, + 107, + 363, + 619, + 875, + 1386, + 108, + 1276, + 509, + 254, + ): list([ + 227, + 228, + 229, + ]), + tuple( + 766, + 1167, + 400, + 145, + 656, + 912, + 1423, + 1168, + 1277, + 1313, + 546, + 35, + 291, + 802, + 1058, + 1314, + 547, + 692, + 181, + 437, + 948, + 1204, + 693, + 1094, + 327, + 72, + 583, + 839, + 1350, + 1240, + 473, + 218, + 729, + 985, + 474, + 1241, + 1386, + 619, + 108, + 364, + 875, + 1131, + 620, + 1387, + 254, + 1021, + 510, + ): list([ + 233, + 234, + 235, + ]), + tuple( + 766, + 1423, + 656, + 145, + 401, + 912, + 1168, + 1022, + 802, + 35, + 291, + 547, + 1058, + 1314, + 36, + 803, + 948, + 181, + 437, + 693, + 1204, + 182, + 949, + 1350, + 583, + 72, + 328, + 839, + 1095, + 729, + 474, + 218, + 985, + 1241, + 730, + 875, + 108, + 364, + 620, + 1131, + 1387, + 876, + 109, + 254, + 1277, + 510, + 255, + ): list([ + 236, + 237, + 238, + ]), + tuple( + 768, + 1, + 257, + 513, + 1024, + 1280, + 914, + 147, + 403, + 659, + 1170, + 1426, + 148, + 915, + 1060, + 293, + 38, + 549, + 805, + 1316, + 294, + 1061, + 695, + 440, + 184, + 951, + 1207, + 841, + 74, + 330, + 586, + 1097, + 1353, + 987, + 476, + 220, + 732, + 1243, + 221, + 988, + 1133, + 366, + 111, + 622, + 878, + 1389, + 367, + 1134, + ): list([ + 260, + 261, + 262, + ]), + tuple( + 769, + 2, + 258, + 514, + 1025, + 1281, + 3, + 770, + 1171, + 404, + 149, + 660, + 916, + 1427, + 1317, + 550, + 39, + 295, + 806, + 1062, + 1318, + 696, + 441, + 185, + 952, + 1208, + 697, + 842, + 75, + 331, + 587, + 1098, + 1354, + 76, + 843, + 1244, + 477, + 222, + 733, + 989, + 1390, + 623, + 112, + 368, + 879, + 1135, + 624, + 1391, + ): list([ + 272, + 273, + 274, + ]), + tuple( + 770, + 3, + 259, + 515, + 1026, + 1282, + 4, + 771, + 916, + 149, + 405, + 661, + 1172, + 1428, + 150, + 917, + 1318, + 551, + 40, + 296, + 807, + 1063, + 697, + 442, + 186, + 953, + 1209, + 843, + 76, + 332, + 588, + 1099, + 1355, + 77, + 844, + 989, + 478, + 222, + 734, + 1245, + 223, + 990, + 1391, + 624, + 113, + 369, + 880, + 1136, + ): list([ + 281, + 282, + 283, + ]), + tuple( + 771, + 4, + 260, + 516, + 1027, + 1283, + 917, + 150, + 406, + 662, + 1173, + 1429, + 151, + 918, + 1063, + 296, + 41, + 552, + 808, + 1319, + 297, + 1064, + 698, + 443, + 187, + 954, + 1210, + 844, + 77, + 333, + 589, + 1100, + 1356, + 990, + 479, + 223, + 735, + 1246, + 224, + 991, + 1136, + 369, + 114, + 625, + 881, + 1392, + 370, + 1137, + ): list([ + 290, + 291, + 292, + ]), + tuple( + 772, + 5, + 261, + 517, + 1028, + 1284, + 6, + 773, + 1174, + 663, + 407, + 152, + 919, + 1430, + 1320, + 553, + 42, + 298, + 809, + 1065, + 1321, + 699, + 444, + 188, + 955, + 1211, + 700, + 845, + 78, + 334, + 590, + 1101, + 1357, + 79, + 846, + 1247, + 480, + 225, + 736, + 992, + 1393, + 626, + 115, + 371, + 882, + 1138, + 627, + 1394, + ): list([ + 302, + 303, + 304, + ]), + tuple( + 773, + 6, + 262, + 518, + 1029, + 1285, + 7, + 774, + 919, + 408, + 664, + 152, + 1175, + 1431, + 153, + 920, + 1321, + 554, + 43, + 299, + 810, + 1066, + 700, + 189, + 445, + 956, + 1212, + 846, + 79, + 335, + 591, + 1102, + 1358, + 80, + 847, + 992, + 225, + 481, + 737, + 1248, + 226, + 993, + 1394, + 627, + 116, + 372, + 883, + 1139, + ): list([ + 311, + 312, + 313, + ]), + tuple( + 774, + 7, + 263, + 519, + 1030, + 1286, + 920, + 409, + 665, + 153, + 1176, + 1432, + 154, + 921, + 1066, + 299, + 44, + 555, + 811, + 1322, + 300, + 1067, + 701, + 446, + 190, + 957, + 1213, + 847, + 80, + 336, + 592, + 1103, + 1359, + 993, + 226, + 482, + 738, + 1249, + 227, + 994, + 1139, + 372, + 117, + 628, + 884, + 1395, + 373, + 1140, + ): list([ + 320, + 321, + 322, + ]), + tuple( + 775, + 8, + 264, + 520, + 1031, + 1287, + 9, + 776, + 1177, + 666, + 410, + 155, + 922, + 1433, + 1323, + 556, + 45, + 301, + 812, + 1068, + 1324, + 702, + 447, + 191, + 958, + 1214, + 703, + 848, + 81, + 337, + 593, + 1104, + 1360, + 82, + 849, + 1250, + 483, + 228, + 739, + 995, + 1396, + 629, + 118, + 374, + 885, + 1141, + 630, + 1397, + ): list([ + 332, + 333, + 334, + ]), + tuple( + 776, + 9, + 265, + 521, + 1032, + 1288, + 10, + 777, + 922, + 411, + 155, + 667, + 1178, + 1434, + 156, + 923, + 1324, + 557, + 46, + 302, + 813, + 1069, + 703, + 192, + 448, + 959, + 1215, + 849, + 82, + 338, + 594, + 1105, + 1361, + 83, + 850, + 375, + 995, + 228, + 484, + 740, + 1251, + 229, + 996, + 1397, + 630, + 119, + 886, + 1142, + ): list([ + 341, + 342, + 343, + ]), + tuple( + 777, + 10, + 266, + 522, + 1033, + 1289, + 923, + 668, + 412, + 156, + 1179, + 1435, + 157, + 924, + 1069, + 302, + 47, + 558, + 814, + 1325, + 303, + 1070, + 704, + 193, + 449, + 960, + 1216, + 850, + 83, + 339, + 595, + 1106, + 1362, + 1143, + 375, + 996, + 229, + 485, + 741, + 1252, + 376, + 230, + 997, + 887, + 1142, + 631, + 120, + 1398, + ): list([ + 350, + 351, + 352, + ]), + tuple( + 784, + 17, + 273, + 529, + 894, + 1040, + 1296, + 18, + 785, + 1150, + 930, + 163, + 419, + 675, + 1186, + 1442, + 164, + 931, + 1332, + 565, + 54, + 310, + 821, + 1077, + 711, + 200, + 456, + 967, + 1223, + 712, + 857, + 346, + 602, + 90, + 1113, + 1369, + 858, + 91, + 1259, + 236, + 492, + 748, + 1004, + 237, + 127, + 1405, + 638, + 383, + ): list([ + 56, + 57, + 58, + ]), + tuple( + 891, + 1146, + 1036, + 269, + 14, + 525, + 781, + 1292, + 1402, + 270, + 1037, + 1438, + 671, + 160, + 416, + 927, + 1183, + 817, + 50, + 306, + 562, + 1073, + 1329, + 963, + 196, + 452, + 708, + 1219, + 197, + 964, + 1109, + 342, + 87, + 598, + 854, + 1365, + 343, + 1110, + 744, + 233, + 489, + 123, + 1000, + 1256, + 379, + 890, + 635, + 124, + ): list([ + 20, + 21, + 22, + ]), + tuple( + 891, + 1147, + 781, + 14, + 270, + 526, + 1037, + 1293, + 15, + 782, + 927, + 160, + 416, + 672, + 1183, + 1439, + 161, + 928, + 1329, + 562, + 51, + 307, + 818, + 1074, + 708, + 197, + 453, + 964, + 1220, + 709, + 854, + 599, + 87, + 343, + 1110, + 1366, + 855, + 88, + 1256, + 233, + 489, + 745, + 1001, + 234, + 124, + 1402, + 635, + 380, + ): list([ + 26, + 27, + 28, + ]), + tuple( + 891, + 1147, + 1292, + 525, + 14, + 270, + 781, + 1037, + 1402, + 1293, + 526, + 671, + 160, + 416, + 927, + 1183, + 1439, + 672, + 1073, + 306, + 51, + 562, + 818, + 1329, + 1219, + 452, + 197, + 708, + 964, + 453, + 1220, + 1365, + 598, + 87, + 343, + 854, + 1110, + 599, + 1366, + 1000, + 233, + 489, + 745, + 1256, + 379, + 1146, + 635, + 124, + ): list([ + 23, + 24, + 25, + ]), + tuple( + 892, + 782, + 15, + 271, + 527, + 1038, + 1148, + 1294, + 928, + 161, + 417, + 673, + 1184, + 1440, + 162, + 929, + 1074, + 307, + 52, + 563, + 819, + 1330, + 308, + 1075, + 709, + 198, + 454, + 965, + 1221, + 855, + 344, + 600, + 88, + 1111, + 1367, + 856, + 1001, + 234, + 490, + 746, + 1257, + 1002, + 235, + 381, + 380, + 1403, + 636, + 125, + ): list([ + 35, + 36, + 37, + ]), + tuple( + 892, + 1293, + 526, + 15, + 271, + 782, + 1038, + 1403, + 1294, + 1439, + 672, + 161, + 417, + 928, + 1184, + 1440, + 673, + 818, + 51, + 307, + 563, + 1074, + 1330, + 52, + 819, + 1220, + 453, + 198, + 709, + 965, + 1366, + 599, + 344, + 88, + 855, + 1111, + 600, + 1367, + 745, + 234, + 490, + 1001, + 1257, + 746, + 380, + 1147, + 636, + 125, + ): list([ + 32, + 33, + 34, + ]), + tuple( + 893, + 1294, + 527, + 16, + 272, + 783, + 1039, + 1148, + 1404, + 1440, + 673, + 162, + 418, + 929, + 1185, + 1441, + 819, + 52, + 308, + 564, + 1075, + 1331, + 53, + 820, + 965, + 198, + 454, + 710, + 1221, + 199, + 966, + 1367, + 600, + 345, + 89, + 856, + 1112, + 746, + 235, + 491, + 1002, + 1258, + 747, + 381, + 125, + 892, + 637, + 126, + ): list([ + 41, + 42, + 43, + ]), + tuple( + 896, + 129, + 385, + 641, + 1152, + 1408, + 130, + 897, + 1042, + 275, + 20, + 531, + 787, + 1298, + 276, + 1043, + 1444, + 677, + 166, + 422, + 933, + 1189, + 823, + 312, + 568, + 56, + 1079, + 1335, + 969, + 202, + 458, + 714, + 1225, + 203, + 970, + 1115, + 348, + 93, + 604, + 860, + 1371, + 349, + 1116, + 750, + 239, + 495, + 1006, + 1262, + ): list([ + 80, + 81, + 82, + ]), + tuple( + 897, + 130, + 386, + 642, + 1153, + 1409, + 1043, + 276, + 21, + 532, + 788, + 1299, + 277, + 1044, + 1189, + 422, + 167, + 678, + 934, + 1445, + 423, + 1190, + 824, + 313, + 569, + 57, + 1080, + 1336, + 970, + 203, + 459, + 715, + 1226, + 1116, + 605, + 349, + 94, + 861, + 1372, + 350, + 1117, + 1262, + 495, + 240, + 751, + 1007, + 496, + 1263, + ): list([ + 89, + 90, + 91, + ]), + tuple( + 898, + 131, + 387, + 643, + 1154, + 1410, + 132, + 899, + 1300, + 533, + 22, + 278, + 789, + 1045, + 1446, + 679, + 168, + 424, + 935, + 1191, + 1447, + 825, + 314, + 570, + 58, + 1081, + 1337, + 59, + 826, + 971, + 204, + 460, + 716, + 1227, + 205, + 972, + 1373, + 606, + 351, + 95, + 862, + 1118, + 752, + 241, + 497, + 1008, + 1264, + 753, + ): list([ + 101, + 102, + 103, + ]), + tuple( + 899, + 132, + 388, + 644, + 1155, + 1411, + 133, + 900, + 1045, + 278, + 23, + 534, + 790, + 1301, + 279, + 1046, + 1447, + 680, + 169, + 425, + 936, + 1192, + 826, + 315, + 571, + 59, + 1082, + 1338, + 972, + 205, + 461, + 717, + 1228, + 206, + 973, + 1118, + 607, + 96, + 351, + 863, + 1374, + 352, + 1119, + 753, + 242, + 498, + 1009, + 1265, + ): list([ + 110, + 111, + 112, + ]), + tuple( + 900, + 133, + 389, + 645, + 1156, + 1412, + 1046, + 535, + 279, + 24, + 791, + 1302, + 280, + 1047, + 1192, + 425, + 170, + 681, + 937, + 1448, + 426, + 1193, + 827, + 316, + 60, + 572, + 1083, + 1339, + 973, + 206, + 462, + 718, + 1229, + 1119, + 352, + 97, + 608, + 864, + 1375, + 353, + 1120, + 1265, + 498, + 243, + 754, + 1010, + 499, + 1266, + ): list([ + 119, + 120, + 121, + ]), + tuple( + 901, + 134, + 390, + 646, + 1157, + 1413, + 135, + 902, + 1303, + 536, + 281, + 25, + 792, + 1048, + 1449, + 682, + 171, + 427, + 938, + 1194, + 1450, + 828, + 573, + 317, + 61, + 1084, + 1340, + 62, + 829, + 974, + 207, + 463, + 719, + 1230, + 208, + 975, + 1376, + 609, + 98, + 354, + 865, + 1121, + 755, + 244, + 500, + 1011, + 1267, + 756, + ): list([ + 131, + 132, + 133, + ]), + tuple( + 902, + 135, + 391, + 647, + 1158, + 1414, + 136, + 903, + 1048, + 537, + 281, + 26, + 793, + 1304, + 282, + 1049, + 1450, + 683, + 172, + 428, + 939, + 1195, + 829, + 318, + 574, + 62, + 1085, + 1341, + 975, + 208, + 464, + 720, + 1231, + 209, + 976, + 1121, + 354, + 99, + 610, + 866, + 1377, + 355, + 1122, + 756, + 245, + 501, + 1012, + 1268, + ): list([ + 140, + 141, + 142, + ]), + tuple( + 903, + 136, + 392, + 648, + 1159, + 1415, + 1049, + 538, + 282, + 27, + 794, + 1305, + 283, + 1050, + 1195, + 428, + 173, + 684, + 940, + 1451, + 429, + 1196, + 830, + 319, + 575, + 63, + 1086, + 1342, + 976, + 209, + 465, + 721, + 1232, + 1122, + 355, + 100, + 611, + 867, + 1378, + 356, + 1123, + 1268, + 501, + 246, + 757, + 1013, + 502, + 1269, + ): list([ + 149, + 150, + 151, + ]), + tuple( + 904, + 137, + 393, + 649, + 1160, + 1416, + 138, + 905, + 1306, + 539, + 284, + 28, + 795, + 1051, + 1452, + 685, + 174, + 430, + 941, + 1197, + 1453, + 831, + 64, + 320, + 576, + 1087, + 1343, + 65, + 832, + 977, + 210, + 466, + 722, + 1233, + 211, + 978, + 247, + 1379, + 612, + 101, + 357, + 868, + 1124, + 759, + 758, + 503, + 1014, + 1270, + ): list([ + 161, + 162, + 163, + ]), + tuple( + 905, + 138, + 394, + 650, + 1161, + 1417, + 139, + 906, + 1051, + 540, + 284, + 29, + 796, + 1307, + 285, + 1052, + 686, + 175, + 431, + 942, + 1198, + 832, + 65, + 321, + 577, + 1088, + 1344, + 978, + 211, + 467, + 723, + 1234, + 212, + 979, + 248, + 1124, + 357, + 102, + 613, + 869, + 1380, + 358, + 1125, + 1015, + 759, + 504, + 1271, + ): list([ + 170, + 171, + 172, + ]), + tuple( + 911, + 144, + 400, + 656, + 1021, + 1167, + 1423, + 145, + 912, + 1277, + 1057, + 290, + 35, + 546, + 802, + 1313, + 291, + 1058, + 692, + 181, + 437, + 948, + 1204, + 838, + 71, + 327, + 583, + 1094, + 1350, + 984, + 473, + 217, + 729, + 1240, + 218, + 985, + 1130, + 363, + 108, + 619, + 875, + 1386, + 364, + 1131, + 254, + 765, + 510, + ): list([ + 230, + 231, + 232, + ]), + tuple( + 1018, + 1273, + 1163, + 396, + 141, + 652, + 908, + 1419, + 1164, + 397, + 542, + 287, + 31, + 798, + 1054, + 1310, + 543, + 944, + 177, + 433, + 689, + 1200, + 1090, + 323, + 68, + 579, + 835, + 1346, + 324, + 1091, + 1236, + 469, + 214, + 725, + 981, + 470, + 1237, + 762, + 871, + 104, + 360, + 616, + 250, + 1127, + 1383, + 1017, + 506, + ): list([ + 194, + 195, + 196, + ]), + tuple( + 1018, + 1274, + 908, + 141, + 397, + 653, + 1164, + 1420, + 142, + 909, + 1054, + 543, + 32, + 287, + 799, + 1310, + 288, + 1055, + 689, + 178, + 434, + 945, + 1201, + 835, + 68, + 324, + 580, + 1091, + 1347, + 981, + 214, + 470, + 726, + 1237, + 215, + 982, + 1127, + 360, + 105, + 616, + 872, + 1383, + 361, + 1128, + 251, + 762, + 507, + ): list([ + 200, + 201, + 202, + ]), + tuple( + 1018, + 1419, + 652, + 141, + 397, + 908, + 1164, + 653, + 1420, + 798, + 287, + 543, + 31, + 1054, + 1310, + 32, + 799, + 1200, + 433, + 178, + 689, + 945, + 1346, + 579, + 68, + 324, + 835, + 1091, + 580, + 1347, + 725, + 214, + 470, + 981, + 1237, + 726, + 762, + 1127, + 104, + 360, + 616, + 872, + 1383, + 105, + 1273, + 506, + 251, + ): list([ + 197, + 198, + 199, + ]), + tuple( + 1019, + 909, + 142, + 398, + 654, + 1165, + 1421, + 1275, + 1055, + 288, + 33, + 544, + 800, + 1311, + 289, + 1056, + 1201, + 434, + 179, + 690, + 946, + 435, + 1202, + 836, + 69, + 325, + 581, + 1092, + 1348, + 982, + 471, + 215, + 727, + 1238, + 1128, + 361, + 106, + 617, + 873, + 1384, + 508, + 362, + 1129, + 1274, + 507, + 252, + 763, + ): list([ + 209, + 210, + 211, + ]), + tuple( + 1019, + 1420, + 653, + 142, + 398, + 909, + 1165, + 799, + 32, + 288, + 544, + 1055, + 1311, + 33, + 800, + 945, + 178, + 434, + 690, + 1201, + 179, + 946, + 1347, + 580, + 69, + 325, + 836, + 1092, + 726, + 471, + 215, + 982, + 1238, + 727, + 872, + 105, + 361, + 617, + 1128, + 1384, + 873, + 251, + 106, + 1274, + 507, + 252, + 763, + ): list([ + 206, + 207, + 208, + ]), + tuple( + 1024, + 257, + 2, + 513, + 769, + 1280, + 1170, + 403, + 148, + 659, + 915, + 1426, + 1171, + 1316, + 549, + 38, + 294, + 805, + 1061, + 1317, + 550, + 695, + 440, + 184, + 951, + 1207, + 696, + 1097, + 330, + 75, + 586, + 842, + 1353, + 1243, + 476, + 221, + 732, + 988, + 477, + 1244, + 1389, + 622, + 111, + 367, + 878, + 1134, + 623, + 1390, + ): list([ + 263, + 264, + 265, + ]), + tuple( + 1025, + 258, + 3, + 514, + 770, + 1281, + 1026, + 259, + 1427, + 404, + 149, + 660, + 916, + 1172, + 405, + 806, + 39, + 295, + 551, + 1062, + 1318, + 952, + 441, + 185, + 697, + 1208, + 186, + 953, + 1098, + 331, + 76, + 587, + 843, + 1354, + 332, + 1099, + 733, + 478, + 222, + 989, + 1245, + 879, + 112, + 368, + 624, + 1135, + 1391, + 880, + ): list([ + 275, + 276, + 277, + ]), + tuple( + 1026, + 259, + 4, + 515, + 771, + 1282, + 1027, + 1172, + 405, + 150, + 661, + 917, + 1428, + 1173, + 406, + 551, + 40, + 296, + 807, + 1063, + 1319, + 552, + 953, + 442, + 186, + 698, + 1209, + 1099, + 332, + 77, + 588, + 844, + 1355, + 333, + 1100, + 1245, + 478, + 223, + 734, + 990, + 479, + 1246, + 880, + 113, + 369, + 625, + 1136, + 1392, + ): list([ + 284, + 285, + 286, + ]), + tuple( + 1027, + 260, + 5, + 516, + 772, + 1283, + 1173, + 406, + 151, + 662, + 918, + 1429, + 1174, + 1319, + 552, + 41, + 297, + 808, + 1064, + 1320, + 553, + 698, + 443, + 187, + 954, + 1210, + 699, + 1100, + 333, + 78, + 589, + 845, + 1356, + 1246, + 479, + 224, + 735, + 991, + 480, + 1247, + 1392, + 625, + 114, + 370, + 881, + 1137, + 626, + 1393, + ): list([ + 293, + 294, + 295, + ]), + tuple( + 1028, + 261, + 6, + 517, + 773, + 1284, + 1029, + 262, + 1430, + 663, + 407, + 152, + 919, + 1175, + 408, + 809, + 42, + 298, + 554, + 1065, + 1321, + 955, + 444, + 188, + 700, + 1211, + 189, + 956, + 1101, + 334, + 79, + 590, + 846, + 1357, + 335, + 1102, + 736, + 225, + 481, + 992, + 1248, + 882, + 115, + 371, + 627, + 1138, + 1394, + 883, + ): list([ + 305, + 306, + 307, + ]), + tuple( + 1029, + 262, + 7, + 518, + 774, + 1285, + 1030, + 1175, + 664, + 408, + 153, + 920, + 1431, + 1176, + 409, + 554, + 43, + 299, + 810, + 1066, + 1322, + 555, + 956, + 189, + 445, + 701, + 1212, + 1102, + 335, + 80, + 591, + 847, + 1358, + 336, + 1103, + 1248, + 481, + 226, + 737, + 993, + 482, + 1249, + 883, + 116, + 372, + 628, + 1139, + 1395, + ): list([ + 314, + 315, + 316, + ]), + tuple( + 1030, + 263, + 8, + 519, + 775, + 1286, + 1176, + 665, + 409, + 154, + 921, + 1432, + 1177, + 1322, + 555, + 44, + 300, + 811, + 1067, + 1323, + 556, + 701, + 446, + 190, + 957, + 1213, + 702, + 1103, + 336, + 81, + 592, + 848, + 1359, + 1249, + 482, + 227, + 738, + 994, + 483, + 1250, + 1395, + 628, + 117, + 373, + 884, + 1140, + 629, + 1396, + ): list([ + 323, + 324, + 325, + ]), + tuple( + 1031, + 264, + 9, + 520, + 776, + 1287, + 1032, + 265, + 1433, + 666, + 410, + 155, + 922, + 1178, + 411, + 812, + 45, + 301, + 557, + 1068, + 1324, + 958, + 447, + 191, + 703, + 1214, + 192, + 959, + 1104, + 337, + 82, + 593, + 849, + 1360, + 338, + 1105, + 739, + 228, + 484, + 995, + 1251, + 885, + 118, + 374, + 630, + 1141, + 1397, + 886, + ): list([ + 335, + 336, + 337, + ]), + tuple( + 1032, + 265, + 10, + 521, + 777, + 1288, + 1033, + 1178, + 667, + 411, + 156, + 923, + 1434, + 1179, + 412, + 557, + 46, + 302, + 813, + 1069, + 1325, + 558, + 959, + 192, + 448, + 704, + 1215, + 1105, + 338, + 83, + 594, + 850, + 1361, + 119, + 339, + 1106, + 375, + 1251, + 484, + 229, + 740, + 996, + 485, + 1252, + 886, + 631, + 1142, + 1398, + ): list([ + 344, + 345, + 346, + ]), + tuple( + 1033, + 266, + 11, + 522, + 778, + 1289, + 1179, + 668, + 412, + 157, + 924, + 1435, + 1180, + 1325, + 558, + 47, + 303, + 814, + 1070, + 1326, + 559, + 704, + 193, + 449, + 960, + 1216, + 705, + 1106, + 339, + 84, + 595, + 851, + 1143, + 1362, + 120, + 1252, + 485, + 230, + 741, + 997, + 486, + 1253, + 632, + 887, + 1398, + 631, + 376, + 1399, + ): list([ + 353, + 354, + 355, + ]), + tuple( + 1145, + 779, + 12, + 268, + 524, + 1035, + 1291, + 925, + 414, + 670, + 158, + 1181, + 1437, + 159, + 926, + 1071, + 304, + 49, + 560, + 816, + 1327, + 305, + 1072, + 706, + 195, + 451, + 962, + 1218, + 852, + 85, + 341, + 597, + 1108, + 1364, + 853, + 889, + 998, + 231, + 487, + 377, + 743, + 1254, + 999, + 232, + 378, + 1400, + 633, + 122, + ): list([ + 5, + 6, + 7, + ]), + tuple( + 1145, + 1401, + 1035, + 268, + 13, + 524, + 780, + 1291, + 1181, + 670, + 414, + 159, + 926, + 1437, + 415, + 1182, + 1327, + 560, + 49, + 305, + 816, + 1072, + 561, + 1328, + 962, + 195, + 451, + 707, + 1218, + 1108, + 341, + 86, + 597, + 853, + 1364, + 889, + 122, + 487, + 232, + 743, + 999, + 1254, + 488, + 1255, + 634, + 1400, + 633, + 378, + ): list([ + 8, + 9, + 10, + ]), + tuple( + 1145, + 1401, + 1291, + 524, + 13, + 269, + 780, + 1036, + 1437, + 670, + 415, + 159, + 926, + 1182, + 1438, + 816, + 49, + 305, + 561, + 1072, + 1328, + 50, + 817, + 962, + 195, + 451, + 707, + 1218, + 196, + 963, + 1364, + 597, + 86, + 342, + 853, + 1109, + 122, + 743, + 232, + 488, + 999, + 1255, + 744, + 634, + 889, + 378, + 123, + 890, + ): list([ + 11, + 12, + 13, + ]), + tuple( + 1146, + 780, + 13, + 269, + 525, + 1036, + 1292, + 14, + 781, + 1402, + 1182, + 671, + 160, + 415, + 927, + 1438, + 1328, + 561, + 50, + 306, + 817, + 1073, + 562, + 1329, + 707, + 196, + 452, + 963, + 1219, + 708, + 1109, + 86, + 342, + 598, + 854, + 1365, + 87, + 1255, + 488, + 233, + 744, + 123, + 1000, + 635, + 1401, + 634, + 379, + 890, + ): list([ + 17, + 18, + 19, + ]), + tuple( + 1146, + 1401, + 524, + 13, + 269, + 780, + 1036, + 1292, + 525, + 926, + 415, + 671, + 159, + 1182, + 1438, + 1072, + 305, + 50, + 561, + 817, + 1328, + 306, + 1073, + 1218, + 451, + 196, + 707, + 963, + 452, + 1219, + 853, + 86, + 342, + 598, + 1109, + 1365, + 999, + 232, + 488, + 744, + 1255, + 1000, + 378, + 379, + 1145, + 634, + 123, + 890, + ): list([ + 14, + 15, + 16, + ]), + tuple( + 1147, + 1037, + 270, + 15, + 526, + 782, + 1293, + 1403, + 271, + 1038, + 1183, + 416, + 161, + 672, + 928, + 1439, + 417, + 1184, + 818, + 51, + 307, + 563, + 1074, + 1330, + 964, + 197, + 453, + 709, + 1220, + 1110, + 599, + 343, + 88, + 855, + 1366, + 344, + 1111, + 1256, + 489, + 234, + 745, + 1001, + 490, + 1257, + 124, + 380, + 891, + 636, + ): list([ + 29, + 30, + 31, + ]), + tuple( + 1152, + 385, + 130, + 641, + 897, + 1408, + 1153, + 1298, + 531, + 20, + 276, + 787, + 1043, + 1299, + 532, + 677, + 166, + 422, + 933, + 1189, + 1445, + 678, + 1079, + 568, + 312, + 57, + 824, + 1335, + 1225, + 458, + 203, + 714, + 970, + 459, + 1226, + 1371, + 604, + 349, + 93, + 860, + 1116, + 605, + 1372, + 1006, + 239, + 495, + 751, + 1262, + ): list([ + 83, + 84, + 85, + ]), + tuple( + 1153, + 386, + 131, + 642, + 898, + 1409, + 1299, + 532, + 21, + 277, + 788, + 1044, + 1300, + 1445, + 678, + 167, + 423, + 934, + 1190, + 1446, + 679, + 824, + 313, + 569, + 57, + 1080, + 1336, + 58, + 825, + 1226, + 459, + 204, + 715, + 971, + 1372, + 605, + 350, + 94, + 861, + 1117, + 606, + 1373, + 751, + 240, + 496, + 1007, + 1263, + 752, + ): list([ + 92, + 93, + 94, + ]), + tuple( + 1154, + 387, + 132, + 643, + 899, + 1410, + 1155, + 388, + 533, + 22, + 278, + 789, + 1045, + 1301, + 534, + 935, + 168, + 424, + 680, + 1191, + 1447, + 1081, + 570, + 314, + 59, + 826, + 1337, + 315, + 1082, + 1227, + 460, + 205, + 716, + 972, + 461, + 1228, + 862, + 351, + 607, + 95, + 1118, + 1374, + 1008, + 241, + 497, + 753, + 1264, + 1009, + ): list([ + 104, + 105, + 106, + ]), + tuple( + 1155, + 388, + 133, + 644, + 900, + 1411, + 1156, + 1301, + 534, + 279, + 23, + 790, + 1046, + 1302, + 535, + 680, + 169, + 425, + 936, + 1192, + 1448, + 681, + 1082, + 571, + 315, + 60, + 827, + 1338, + 1228, + 461, + 206, + 717, + 973, + 462, + 1229, + 1374, + 607, + 96, + 352, + 863, + 1119, + 608, + 1375, + 1009, + 242, + 498, + 754, + 1265, + ): list([ + 113, + 114, + 115, + ]), + tuple( + 1156, + 389, + 134, + 645, + 901, + 1412, + 1302, + 535, + 280, + 24, + 791, + 1047, + 1303, + 1448, + 681, + 170, + 426, + 937, + 1193, + 1449, + 682, + 827, + 316, + 60, + 572, + 1083, + 1339, + 61, + 828, + 1229, + 462, + 207, + 718, + 974, + 1375, + 608, + 97, + 353, + 864, + 1120, + 609, + 1376, + 754, + 243, + 499, + 1010, + 1266, + 755, + ): list([ + 122, + 123, + 124, + ]), + tuple( + 1157, + 390, + 135, + 646, + 902, + 1413, + 1158, + 391, + 536, + 281, + 25, + 792, + 1048, + 1304, + 537, + 938, + 171, + 427, + 683, + 1194, + 1450, + 1084, + 573, + 317, + 62, + 829, + 1340, + 318, + 1085, + 1230, + 463, + 208, + 719, + 975, + 464, + 1231, + 865, + 98, + 354, + 610, + 1121, + 1377, + 1011, + 244, + 500, + 756, + 1267, + 1012, + ): list([ + 134, + 135, + 136, + ]), + tuple( + 1158, + 391, + 136, + 647, + 903, + 1414, + 1159, + 1304, + 537, + 282, + 26, + 793, + 1049, + 1305, + 538, + 683, + 172, + 428, + 939, + 1195, + 1451, + 684, + 1085, + 574, + 318, + 63, + 830, + 1341, + 1231, + 464, + 209, + 720, + 976, + 465, + 1232, + 1377, + 610, + 99, + 355, + 866, + 1122, + 611, + 1378, + 1012, + 245, + 501, + 757, + 1268, + ): list([ + 143, + 144, + 145, + ]), + tuple( + 1159, + 392, + 137, + 648, + 904, + 1415, + 1305, + 538, + 283, + 27, + 794, + 1050, + 1306, + 1451, + 684, + 173, + 429, + 940, + 1196, + 1452, + 685, + 830, + 319, + 575, + 63, + 1086, + 1342, + 64, + 831, + 1232, + 465, + 210, + 721, + 977, + 1378, + 611, + 100, + 356, + 867, + 1123, + 612, + 1379, + 757, + 246, + 502, + 1013, + 1269, + 758, + ): list([ + 152, + 153, + 154, + ]), + tuple( + 1160, + 393, + 138, + 649, + 905, + 1416, + 1161, + 394, + 539, + 284, + 28, + 795, + 1051, + 1307, + 540, + 941, + 174, + 430, + 686, + 1197, + 1453, + 1087, + 320, + 65, + 576, + 832, + 1343, + 321, + 1088, + 1233, + 466, + 211, + 722, + 978, + 467, + 1234, + 247, + 868, + 101, + 357, + 613, + 1124, + 1380, + 759, + 1015, + 1014, + 503, + 1270, + ): list([ + 164, + 165, + 166, + ]), + tuple( + 1161, + 394, + 139, + 650, + 906, + 1417, + 1162, + 1307, + 540, + 285, + 29, + 796, + 1052, + 1308, + 541, + 686, + 175, + 431, + 942, + 1198, + 687, + 1088, + 321, + 66, + 577, + 833, + 1344, + 1234, + 467, + 212, + 723, + 979, + 468, + 1235, + 248, + 1380, + 613, + 102, + 358, + 869, + 1125, + 614, + 1381, + 760, + 1015, + 504, + 1271, + ): list([ + 173, + 174, + 175, + ]), + tuple( + 1272, + 906, + 139, + 395, + 651, + 1162, + 1418, + 1052, + 541, + 285, + 30, + 797, + 1308, + 286, + 1053, + 1198, + 431, + 176, + 687, + 943, + 432, + 1199, + 833, + 66, + 322, + 578, + 1089, + 1345, + 979, + 212, + 468, + 724, + 1235, + 1016, + 1125, + 358, + 103, + 614, + 870, + 1381, + 359, + 1126, + 505, + 760, + 1271, + 504, + 249, + ): list([ + 179, + 180, + 181, + ]), + tuple( + 1272, + 1162, + 395, + 140, + 651, + 907, + 1418, + 1308, + 541, + 30, + 286, + 797, + 1053, + 1309, + 687, + 176, + 432, + 943, + 1199, + 688, + 833, + 66, + 322, + 578, + 1089, + 1345, + 67, + 834, + 1235, + 468, + 213, + 724, + 980, + 1016, + 249, + 614, + 103, + 359, + 870, + 1126, + 1381, + 615, + 1382, + 761, + 760, + 505, + ): list([ + 182, + 183, + 184, + ]), + tuple( + 1272, + 1418, + 395, + 140, + 651, + 907, + 1163, + 396, + 797, + 542, + 30, + 286, + 1053, + 1309, + 943, + 176, + 432, + 688, + 1199, + 177, + 944, + 1089, + 322, + 67, + 578, + 834, + 1345, + 323, + 1090, + 724, + 213, + 469, + 980, + 1236, + 249, + 870, + 103, + 359, + 615, + 1126, + 1382, + 871, + 761, + 1016, + 505, + 250, + 1017, + ): list([ + 185, + 186, + 187, + ]), + tuple( + 1273, + 907, + 140, + 396, + 652, + 1163, + 1419, + 141, + 908, + 1309, + 542, + 287, + 31, + 798, + 1054, + 688, + 177, + 433, + 944, + 1200, + 834, + 67, + 323, + 579, + 1090, + 1346, + 68, + 835, + 980, + 213, + 469, + 725, + 1236, + 214, + 981, + 762, + 1382, + 615, + 104, + 360, + 250, + 871, + 1127, + 761, + 506, + 1017, + ): list([ + 191, + 192, + 193, + ]), + tuple( + 1273, + 1418, + 651, + 140, + 396, + 907, + 1163, + 652, + 1419, + 1053, + 542, + 286, + 31, + 798, + 1309, + 1199, + 432, + 177, + 688, + 944, + 433, + 1200, + 1345, + 578, + 67, + 323, + 834, + 1090, + 579, + 1346, + 980, + 213, + 469, + 725, + 1236, + 1126, + 359, + 104, + 615, + 871, + 1382, + 506, + 761, + 1272, + 505, + 250, + 1017, + ): list([ + 188, + 189, + 190, + ]), + tuple( + 1274, + 1164, + 397, + 142, + 653, + 909, + 1420, + 1165, + 1310, + 543, + 32, + 288, + 799, + 1055, + 1311, + 544, + 689, + 178, + 434, + 945, + 1201, + 690, + 1091, + 324, + 69, + 580, + 836, + 1347, + 1237, + 470, + 215, + 726, + 982, + 471, + 1238, + 1383, + 616, + 105, + 361, + 872, + 1128, + 617, + 1384, + 251, + 1018, + 507, + 763, + ): list([ + 203, + 204, + 205, + ]), + tuple( + 1280, + 257, + 2, + 513, + 769, + 1025, + 258, + 1426, + 659, + 148, + 404, + 915, + 1171, + 805, + 38, + 294, + 550, + 1061, + 1317, + 39, + 806, + 951, + 440, + 184, + 696, + 1207, + 185, + 952, + 1353, + 586, + 75, + 331, + 842, + 1098, + 732, + 477, + 221, + 988, + 1244, + 733, + 878, + 111, + 367, + 623, + 1134, + 1390, + 879, + 112, + ): list([ + 266, + 267, + 268, + ]), + tuple( + 1280, + 513, + 2, + 258, + 769, + 1025, + 514, + 1281, + 915, + 148, + 404, + 660, + 1171, + 1427, + 1061, + 294, + 39, + 550, + 806, + 1317, + 295, + 1062, + 1207, + 440, + 185, + 696, + 952, + 441, + 1208, + 842, + 75, + 331, + 587, + 1098, + 1354, + 988, + 477, + 221, + 733, + 1244, + 1134, + 367, + 112, + 623, + 879, + 1390, + 368, + 1135, + ): list([ + 269, + 270, + 271, + ]), + tuple( + 1281, + 514, + 3, + 259, + 770, + 1026, + 515, + 1282, + 1427, + 660, + 149, + 405, + 916, + 1172, + 661, + 1428, + 1062, + 295, + 40, + 551, + 807, + 1318, + 1208, + 441, + 186, + 697, + 953, + 442, + 1209, + 1354, + 587, + 76, + 332, + 843, + 1099, + 588, + 1355, + 989, + 478, + 222, + 734, + 1245, + 1135, + 368, + 113, + 624, + 880, + 1391, + ): list([ + 278, + 279, + 280, + ]), + tuple( + 1282, + 515, + 4, + 260, + 771, + 1027, + 1428, + 661, + 150, + 406, + 917, + 1173, + 662, + 1429, + 807, + 40, + 296, + 552, + 1063, + 1319, + 41, + 808, + 1209, + 442, + 187, + 698, + 954, + 1355, + 588, + 77, + 333, + 844, + 1100, + 589, + 1356, + 734, + 479, + 223, + 990, + 1246, + 735, + 1136, + 113, + 369, + 625, + 881, + 1392, + 114, + ): list([ + 287, + 288, + 289, + ]), + tuple( + 1283, + 260, + 5, + 516, + 772, + 1028, + 261, + 1429, + 662, + 407, + 151, + 918, + 1174, + 808, + 41, + 297, + 553, + 1064, + 1320, + 42, + 809, + 954, + 443, + 187, + 699, + 1210, + 188, + 955, + 1356, + 589, + 78, + 334, + 845, + 1101, + 735, + 224, + 480, + 991, + 1247, + 736, + 881, + 114, + 370, + 626, + 1137, + 1393, + 882, + 115, + ): list([ + 296, + 297, + 298, + ]), + tuple( + 1283, + 516, + 5, + 261, + 772, + 1028, + 517, + 1284, + 918, + 407, + 663, + 151, + 1174, + 1430, + 1064, + 297, + 42, + 553, + 809, + 1320, + 298, + 1065, + 1210, + 443, + 188, + 699, + 955, + 444, + 1211, + 845, + 78, + 334, + 590, + 1101, + 1357, + 991, + 224, + 480, + 736, + 1247, + 1137, + 370, + 115, + 626, + 882, + 1393, + 371, + 1138, + ): list([ + 299, + 300, + 301, + ]), + tuple( + 1284, + 517, + 6, + 262, + 773, + 1029, + 518, + 1285, + 1430, + 663, + 408, + 152, + 919, + 1175, + 664, + 1431, + 1065, + 298, + 43, + 554, + 810, + 1321, + 1211, + 444, + 189, + 700, + 956, + 445, + 1212, + 1357, + 590, + 79, + 335, + 846, + 1102, + 591, + 1358, + 992, + 225, + 481, + 737, + 1248, + 1138, + 371, + 116, + 627, + 883, + 1394, + ): list([ + 308, + 309, + 310, + ]), + tuple( + 1285, + 518, + 7, + 263, + 774, + 1030, + 1431, + 664, + 409, + 153, + 920, + 1176, + 665, + 1432, + 810, + 43, + 299, + 555, + 1066, + 1322, + 44, + 811, + 1212, + 445, + 190, + 701, + 957, + 1358, + 591, + 80, + 336, + 847, + 1103, + 592, + 1359, + 737, + 226, + 482, + 993, + 1249, + 738, + 1139, + 116, + 372, + 628, + 884, + 1395, + 117, + ): list([ + 317, + 318, + 319, + ]), + tuple( + 1286, + 263, + 8, + 519, + 775, + 1031, + 264, + 1432, + 665, + 410, + 154, + 921, + 1177, + 811, + 44, + 300, + 556, + 1067, + 1323, + 45, + 812, + 957, + 446, + 190, + 702, + 1213, + 191, + 958, + 1359, + 592, + 81, + 337, + 848, + 1104, + 738, + 227, + 483, + 994, + 1250, + 739, + 884, + 117, + 373, + 629, + 1140, + 1396, + 885, + 118, + ): list([ + 326, + 327, + 328, + ]), + tuple( + 1286, + 519, + 8, + 264, + 775, + 1031, + 520, + 1287, + 921, + 410, + 666, + 154, + 1177, + 1433, + 1067, + 300, + 45, + 556, + 812, + 1323, + 301, + 1068, + 1213, + 446, + 191, + 702, + 958, + 447, + 1214, + 848, + 81, + 337, + 593, + 1104, + 1360, + 994, + 227, + 483, + 739, + 1250, + 1140, + 373, + 118, + 629, + 885, + 1396, + 374, + 1141, + ): list([ + 329, + 330, + 331, + ]), + tuple( + 1287, + 520, + 9, + 265, + 776, + 1032, + 521, + 1288, + 1433, + 666, + 411, + 155, + 922, + 1178, + 667, + 1434, + 1068, + 301, + 46, + 557, + 813, + 1324, + 1214, + 447, + 192, + 703, + 959, + 448, + 1215, + 1360, + 593, + 82, + 338, + 849, + 1105, + 594, + 1361, + 995, + 228, + 484, + 740, + 1251, + 1141, + 374, + 119, + 630, + 886, + 1397, + ): list([ + 338, + 339, + 340, + ]), + tuple( + 1288, + 521, + 10, + 266, + 777, + 1033, + 1434, + 667, + 412, + 156, + 923, + 1179, + 668, + 1435, + 813, + 46, + 302, + 558, + 1069, + 1325, + 47, + 814, + 1215, + 448, + 193, + 704, + 960, + 1361, + 594, + 83, + 339, + 850, + 1106, + 119, + 595, + 1362, + 120, + 375, + 740, + 229, + 485, + 996, + 1252, + 741, + 887, + 1142, + 631, + 1398, + ): list([ + 347, + 348, + 349, + ]), + tuple( + 1289, + 266, + 11, + 522, + 778, + 1034, + 267, + 1435, + 668, + 157, + 413, + 924, + 1180, + 814, + 47, + 303, + 559, + 1070, + 1326, + 48, + 815, + 960, + 193, + 449, + 705, + 1216, + 194, + 961, + 1362, + 595, + 84, + 340, + 851, + 1107, + 1143, + 120, + 741, + 230, + 486, + 997, + 1253, + 742, + 632, + 888, + 887, + 376, + 121, + 1399, + ): list([ + 356, + 357, + 358, + ]), + tuple( + 1289, + 522, + 11, + 267, + 778, + 1034, + 523, + 1290, + 924, + 669, + 157, + 413, + 1180, + 1436, + 1070, + 303, + 48, + 559, + 815, + 1326, + 304, + 1071, + 1216, + 449, + 194, + 705, + 961, + 450, + 1217, + 851, + 84, + 340, + 596, + 1107, + 1363, + 376, + 997, + 230, + 486, + 742, + 1253, + 377, + 888, + 1143, + 632, + 121, + 1144, + 1399, + ): list([ + 359, + 360, + 361, + ]), + tuple( + 1400, + 1034, + 267, + 12, + 523, + 779, + 1290, + 268, + 1035, + 11, + 778, + 1436, + 669, + 414, + 158, + 925, + 1181, + 413, + 1180, + 1326, + 815, + 48, + 304, + 560, + 1071, + 1327, + 559, + 961, + 194, + 450, + 706, + 1217, + 705, + 1107, + 340, + 85, + 596, + 852, + 1363, + 341, + 1108, + 84, + 851, + 121, + 1253, + 742, + 231, + 487, + 998, + 1254, + 486, + 632, + 633, + 1399, + 888, + 377, + 1144, + ): list([ + 0, + 1, + 362, + 363, + 364, + 365, + ]), + tuple( + 1400, + 1290, + 523, + 12, + 268, + 779, + 1035, + 1291, + 1436, + 669, + 414, + 158, + 925, + 1181, + 1437, + 670, + 815, + 48, + 304, + 560, + 1071, + 1327, + 49, + 816, + 1217, + 450, + 195, + 706, + 962, + 1363, + 596, + 85, + 341, + 852, + 1108, + 597, + 1364, + 889, + 742, + 231, + 487, + 377, + 998, + 1254, + 743, + 1144, + 633, + 122, + ): list([ + 2, + 3, + 4, + ]), + tuple( + 1408, + 641, + 130, + 386, + 897, + 1153, + 787, + 20, + 276, + 532, + 1043, + 1299, + 21, + 788, + 933, + 166, + 422, + 678, + 1189, + 1445, + 167, + 934, + 1335, + 568, + 313, + 57, + 824, + 1080, + 714, + 203, + 459, + 970, + 1226, + 715, + 860, + 605, + 349, + 93, + 1116, + 1372, + 861, + 94, + 1262, + 239, + 495, + 751, + 1007, + 240, + ): list([ + 86, + 87, + 88, + ]), + tuple( + 1409, + 386, + 131, + 642, + 898, + 1154, + 387, + 788, + 21, + 277, + 533, + 1044, + 1300, + 934, + 167, + 423, + 679, + 1190, + 1446, + 168, + 935, + 1080, + 569, + 313, + 58, + 825, + 1336, + 314, + 1081, + 715, + 204, + 460, + 971, + 1227, + 861, + 350, + 606, + 94, + 1117, + 1373, + 862, + 1007, + 240, + 496, + 752, + 1263, + 1008, + 241, + ): list([ + 95, + 96, + 97, + ]), + tuple( + 1409, + 642, + 131, + 387, + 898, + 1154, + 643, + 1410, + 1044, + 277, + 22, + 533, + 789, + 1300, + 1190, + 423, + 168, + 679, + 935, + 1446, + 424, + 1191, + 1336, + 569, + 314, + 58, + 825, + 1081, + 570, + 1337, + 971, + 204, + 460, + 716, + 1227, + 1117, + 606, + 350, + 95, + 862, + 1373, + 1263, + 496, + 241, + 752, + 1008, + 497, + 1264, + ): list([ + 98, + 99, + 100, + ]), + tuple( + 1410, + 643, + 132, + 388, + 899, + 1155, + 644, + 1411, + 789, + 22, + 278, + 534, + 1045, + 1301, + 23, + 790, + 1191, + 424, + 169, + 680, + 936, + 1447, + 1337, + 570, + 315, + 59, + 826, + 1082, + 571, + 1338, + 716, + 205, + 461, + 972, + 1228, + 717, + 1118, + 351, + 607, + 95, + 863, + 1374, + 96, + 1264, + 497, + 242, + 753, + 1009, + ): list([ + 107, + 108, + 109, + ]), + tuple( + 1411, + 644, + 133, + 389, + 900, + 1156, + 790, + 535, + 279, + 23, + 1046, + 1302, + 24, + 791, + 936, + 169, + 425, + 681, + 1192, + 1448, + 170, + 937, + 1338, + 571, + 316, + 60, + 827, + 1083, + 717, + 206, + 462, + 973, + 1229, + 718, + 863, + 96, + 352, + 608, + 1119, + 1375, + 864, + 97, + 1265, + 242, + 498, + 754, + 1010, + 243, + ): list([ + 116, + 117, + 118, + ]), + tuple( + 1412, + 389, + 134, + 645, + 901, + 1157, + 390, + 791, + 280, + 536, + 24, + 1047, + 1303, + 937, + 170, + 426, + 682, + 1193, + 1449, + 171, + 938, + 1083, + 316, + 61, + 572, + 828, + 1339, + 317, + 1084, + 718, + 207, + 463, + 974, + 1230, + 864, + 97, + 353, + 609, + 1120, + 1376, + 865, + 1010, + 243, + 499, + 755, + 1266, + 1011, + 244, + ): list([ + 125, + 126, + 127, + ]), + tuple( + 1412, + 645, + 134, + 390, + 901, + 1157, + 646, + 1413, + 1047, + 536, + 280, + 25, + 792, + 1303, + 1193, + 426, + 171, + 682, + 938, + 1449, + 427, + 1194, + 1339, + 572, + 317, + 61, + 828, + 1084, + 573, + 1340, + 974, + 207, + 463, + 719, + 1230, + 1120, + 353, + 98, + 609, + 865, + 1376, + 1266, + 499, + 244, + 755, + 1011, + 500, + 1267, + ): list([ + 128, + 129, + 130, + ]), + tuple( + 1413, + 646, + 135, + 391, + 902, + 1158, + 647, + 1414, + 792, + 281, + 537, + 25, + 1048, + 1304, + 26, + 793, + 1194, + 427, + 172, + 683, + 939, + 1450, + 1340, + 573, + 318, + 62, + 829, + 1085, + 574, + 1341, + 719, + 208, + 464, + 975, + 1231, + 720, + 1121, + 98, + 354, + 610, + 866, + 1377, + 99, + 1267, + 500, + 245, + 756, + 1012, + ): list([ + 137, + 138, + 139, + ]), + tuple( + 1414, + 647, + 136, + 392, + 903, + 1159, + 793, + 282, + 538, + 26, + 1049, + 1305, + 27, + 794, + 939, + 172, + 428, + 684, + 1195, + 1451, + 173, + 940, + 1341, + 574, + 319, + 63, + 830, + 1086, + 720, + 209, + 465, + 976, + 1232, + 721, + 866, + 99, + 355, + 611, + 1122, + 1378, + 867, + 100, + 1268, + 245, + 501, + 757, + 1013, + 246, + ): list([ + 146, + 147, + 148, + ]), + tuple( + 1415, + 392, + 137, + 648, + 904, + 1160, + 393, + 794, + 283, + 539, + 27, + 1050, + 1306, + 940, + 173, + 429, + 685, + 1196, + 1452, + 174, + 941, + 1086, + 575, + 64, + 319, + 831, + 1342, + 320, + 1087, + 721, + 210, + 466, + 977, + 1233, + 247, + 867, + 100, + 356, + 612, + 1123, + 1379, + 868, + 1013, + 246, + 502, + 758, + 1269, + 1014, + ): list([ + 155, + 156, + 157, + ]), + tuple( + 1415, + 648, + 137, + 393, + 904, + 1160, + 649, + 1416, + 1050, + 539, + 283, + 28, + 795, + 1306, + 1196, + 429, + 174, + 685, + 941, + 1452, + 430, + 1197, + 1342, + 575, + 64, + 320, + 831, + 1087, + 576, + 1343, + 977, + 210, + 466, + 722, + 1233, + 1123, + 356, + 101, + 612, + 868, + 1379, + 503, + 1269, + 502, + 247, + 758, + 1014, + 1270, + ): list([ + 158, + 159, + 160, + ]), + tuple( + 1416, + 649, + 138, + 394, + 905, + 1161, + 650, + 1417, + 795, + 284, + 28, + 540, + 1051, + 1307, + 29, + 796, + 1197, + 430, + 175, + 686, + 942, + 1343, + 576, + 65, + 321, + 832, + 1088, + 577, + 1344, + 722, + 211, + 467, + 978, + 1234, + 723, + 1124, + 101, + 357, + 613, + 869, + 1380, + 102, + 759, + 1015, + 1270, + 503, + 248, + ): list([ + 167, + 168, + 169, + ]), + tuple( + 1417, + 650, + 139, + 395, + 906, + 1162, + 796, + 541, + 285, + 29, + 1052, + 1308, + 30, + 797, + 942, + 175, + 431, + 687, + 1198, + 176, + 943, + 1344, + 577, + 66, + 322, + 833, + 1089, + 723, + 212, + 468, + 979, + 1235, + 724, + 1016, + 248, + 869, + 102, + 358, + 614, + 1125, + 1381, + 870, + 103, + 760, + 1271, + 504, + 249, + ): list([ + 176, + 177, + 178, + ]), + }) +# --- +# name: test_snapshot_cohorts[PerfectBlockwiseResampling] + dict({ + tuple( + 0, + ): list([ + 0, + 1, + ]), + tuple( + 1, + ): list([ + 2, + 3, + ]), + tuple( + 2, + ): list([ + 4, + 5, + ]), + tuple( + 3, + ): list([ + 6, + 7, + ]), + tuple( + 4, + ): list([ + 8, + 9, + ]), + tuple( + 5, + ): list([ + 10, + 11, + ]), + tuple( + 6, + ): list([ + 12, + 13, + ]), + tuple( + 7, + ): list([ + 14, + 15, + ]), + tuple( + 8, + ): list([ + 16, + 17, + ]), + tuple( + 9, + ): list([ + 18, + 19, + ]), + tuple( + 10, + ): list([ + 20, + 21, + ]), + tuple( + 11, + ): list([ + 22, + 23, + ]), + tuple( + 12, + ): list([ + 24, + 25, + ]), + tuple( + 13, + ): list([ + 26, + 27, + ]), + tuple( + 14, + ): list([ + 28, + 29, + ]), + tuple( + 15, + ): list([ + 30, + 31, + ]), + tuple( + 16, + ): list([ + 32, + 33, + ]), + tuple( + 17, + ): list([ + 34, + 35, + ]), + tuple( + 18, + ): list([ + 36, + 37, + ]), + tuple( + 19, + ): list([ + 38, + 39, + ]), + tuple( + 20, + ): list([ + 40, + 41, + ]), + tuple( + 21, + ): list([ + 42, + 43, + ]), + tuple( + 22, + ): list([ + 44, + 45, + ]), + tuple( + 23, + ): list([ + 46, + 47, + ]), + tuple( + 24, + ): list([ + 48, + 49, + ]), + tuple( + 25, + ): list([ + 50, + 51, + ]), + tuple( + 26, + ): list([ + 52, + 53, + ]), + tuple( + 27, + ): list([ + 54, + 55, + ]), + tuple( + 28, + ): list([ + 56, + 57, + ]), + tuple( + 29, + ): list([ + 58, + 59, + ]), + tuple( + 30, + ): list([ + 60, + 61, + ]), + tuple( + 31, + ): list([ + 62, + 63, + ]), + tuple( + 32, + ): list([ + 64, + 65, + ]), + tuple( + 33, + ): list([ + 66, + 67, + ]), + tuple( + 34, + ): list([ + 68, + 69, + ]), + tuple( + 35, + ): list([ + 70, + 71, + ]), + tuple( + 36, + ): list([ + 72, + 73, + ]), + tuple( + 37, + ): list([ + 74, + 75, + ]), + tuple( + 38, + ): list([ + 76, + 77, + ]), + tuple( + 39, + ): list([ + 78, + 79, + ]), + tuple( + 40, + ): list([ + 80, + 81, + ]), + tuple( + 41, + ): list([ + 82, + 83, + ]), + tuple( + 42, + ): list([ + 84, + 85, + ]), + tuple( + 43, + ): list([ + 86, + 87, + ]), + tuple( + 44, + ): list([ + 88, + 89, + ]), + tuple( + 45, + ): list([ + 90, + 91, + ]), + tuple( + 46, + ): list([ + 92, + 93, + ]), + tuple( + 47, + ): list([ + 94, + 95, + ]), + tuple( + 48, + ): list([ + 96, + 97, + ]), + tuple( + 49, + ): list([ + 98, + 99, + ]), + tuple( + 50, + ): list([ + 100, + 101, + ]), + tuple( + 51, + ): list([ + 102, + 103, + ]), + tuple( + 52, + ): list([ + 104, + 105, + ]), + tuple( + 53, + ): list([ + 106, + 107, + ]), + tuple( + 54, + ): list([ + 108, + 109, + ]), + tuple( + 55, + ): list([ + 110, + 111, + ]), + tuple( + 56, + ): list([ + 112, + 113, + ]), + tuple( + 57, + ): list([ + 114, + 115, + ]), + tuple( + 58, + ): list([ + 116, + 117, + ]), + tuple( + 59, + ): list([ + 118, + 119, + ]), + tuple( + 60, + ): list([ + 120, + 121, + ]), + tuple( + 61, + ): list([ + 122, + 123, + ]), + tuple( + 62, + ): list([ + 124, + 125, + ]), + tuple( + 63, + ): list([ + 126, + 127, + ]), + tuple( + 64, + ): list([ + 128, + 129, + ]), + tuple( + 65, + ): list([ + 130, + 131, + ]), + tuple( + 66, + ): list([ + 132, + 133, + ]), + tuple( + 67, + ): list([ + 134, + 135, + ]), + tuple( + 68, + ): list([ + 136, + 137, + ]), + tuple( + 69, + ): list([ + 138, + 139, + ]), + tuple( + 70, + ): list([ + 140, + 141, + ]), + tuple( + 71, + ): list([ + 142, + 143, + ]), + tuple( + 72, + ): list([ + 144, + 145, + ]), + tuple( + 73, + ): list([ + 146, + 147, + ]), + tuple( + 74, + ): list([ + 148, + 149, + ]), + tuple( + 75, + ): list([ + 150, + 151, + ]), + tuple( + 76, + ): list([ + 152, + 153, + ]), + tuple( + 77, + ): list([ + 154, + 155, + ]), + tuple( + 78, + ): list([ + 156, + 157, + ]), + tuple( + 79, + ): list([ + 158, + 159, + ]), + tuple( + 80, + ): list([ + 160, + 161, + ]), + tuple( + 81, + ): list([ + 162, + 163, + ]), + tuple( + 82, + ): list([ + 164, + 165, + ]), + tuple( + 83, + ): list([ + 166, + 167, + ]), + tuple( + 84, + ): list([ + 168, + 169, + ]), + tuple( + 85, + ): list([ + 170, + 171, + ]), + tuple( + 86, + ): list([ + 172, + 173, + ]), + tuple( + 87, + ): list([ + 174, + 175, + ]), + tuple( + 88, + ): list([ + 176, + 177, + ]), + tuple( + 89, + ): list([ + 178, + 179, + ]), + tuple( + 90, + ): list([ + 180, + 181, + ]), + tuple( + 91, + ): list([ + 182, + 183, + ]), + tuple( + 92, + ): list([ + 184, + 185, + ]), + tuple( + 93, + ): list([ + 186, + 187, + ]), + tuple( + 94, + ): list([ + 188, + 189, + ]), + tuple( + 95, + ): list([ + 190, + 191, + ]), + tuple( + 96, + ): list([ + 192, + 193, + ]), + tuple( + 97, + ): list([ + 194, + 195, + ]), + tuple( + 98, + ): list([ + 196, + 197, + ]), + tuple( + 99, + ): list([ + 198, + 199, + ]), + tuple( + 100, + ): list([ + 200, + 201, + ]), + tuple( + 101, + ): list([ + 202, + 203, + ]), + tuple( + 102, + ): list([ + 204, + 205, + ]), + tuple( + 103, + ): list([ + 206, + 207, + ]), + tuple( + 104, + ): list([ + 208, + 209, + ]), + tuple( + 105, + ): list([ + 210, + 211, + ]), + tuple( + 106, + ): list([ + 212, + 213, + ]), + tuple( + 107, + ): list([ + 214, + 215, + ]), + tuple( + 108, + ): list([ + 216, + 217, + ]), + tuple( + 109, + ): list([ + 218, + 219, + ]), + tuple( + 110, + ): list([ + 220, + 221, + ]), + tuple( + 111, + ): list([ + 222, + 223, + ]), + tuple( + 112, + ): list([ + 224, + 225, + ]), + tuple( + 113, + ): list([ + 226, + 227, + ]), + tuple( + 114, + ): list([ + 228, + 229, + ]), + tuple( + 115, + ): list([ + 230, + 231, + ]), + tuple( + 116, + ): list([ + 232, + 233, + ]), + tuple( + 117, + ): list([ + 234, + 235, + ]), + tuple( + 118, + ): list([ + 236, + 237, + ]), + tuple( + 119, + ): list([ + 238, + 239, + ]), + tuple( + 120, + ): list([ + 240, + 241, + ]), + tuple( + 121, + ): list([ + 242, + 243, + ]), + tuple( + 122, + ): list([ + 244, + 245, + ]), + tuple( + 123, + ): list([ + 246, + 247, + ]), + tuple( + 124, + ): list([ + 248, + 249, + ]), + tuple( + 125, + ): list([ + 250, + 251, + ]), + tuple( + 126, + ): list([ + 252, + 253, + ]), + tuple( + 127, + ): list([ + 254, + 255, + ]), + tuple( + 128, + ): list([ + 256, + 257, + ]), + tuple( + 129, + ): list([ + 258, + 259, + ]), + tuple( + 130, + ): list([ + 260, + 261, + ]), + tuple( + 131, + ): list([ + 262, + 263, + ]), + tuple( + 132, + ): list([ + 264, + 265, + ]), + tuple( + 133, + ): list([ + 266, + 267, + ]), + tuple( + 134, + ): list([ + 268, + 269, + ]), + tuple( + 135, + ): list([ + 270, + 271, + ]), + tuple( + 136, + ): list([ + 272, + 273, + ]), + tuple( + 137, + ): list([ + 274, + 275, + ]), + tuple( + 138, + ): list([ + 276, + 277, + ]), + tuple( + 139, + ): list([ + 278, + 279, + ]), + tuple( + 140, + ): list([ + 280, + 281, + ]), + tuple( + 141, + ): list([ + 282, + 283, + ]), + tuple( + 142, + ): list([ + 284, + 285, + ]), + tuple( + 143, + ): list([ + 286, + 287, + ]), + tuple( + 144, + ): list([ + 288, + 289, + ]), + tuple( + 145, + ): list([ + 290, + 291, + ]), + tuple( + 146, + ): list([ + 292, + ]), + }) +# --- +# name: test_snapshot_cohorts[PerfectMonthly] + dict({ + tuple( + 0, + 3, + 6, + 9, + 12, + 15, + 18, + 21, + 24, + 27, + 30, + 33, + 36, + 39, + 42, + 45, + 48, + 51, + 54, + 57, + 60, + 63, + 66, + 69, + 72, + 75, + 78, + 81, + 84, + 87, + 90, + 93, + 96, + 99, + 102, + 105, + 108, + 111, + 114, + 117, + 120, + 123, + 126, + 129, + 132, + 135, + 138, + 141, + 144, + 147, + 150, + 153, + 156, + 159, + 162, + 165, + 168, + 171, + ): list([ + 0, + 1, + 2, + 3, + ]), + tuple( + 1, + 4, + 7, + 10, + 13, + 16, + 19, + 22, + 25, + 28, + 31, + 34, + 37, + 40, + 43, + 46, + 49, + 52, + 55, + 58, + 61, + 64, + 67, + 70, + 73, + 76, + 79, + 82, + 85, + 88, + 91, + 94, + 97, + 100, + 103, + 106, + 109, + 112, + 115, + 118, + 121, + 124, + 127, + 130, + 133, + 136, + 139, + 142, + 145, + 148, + 151, + 154, + 157, + 160, + 163, + 166, + 169, + 172, + ): list([ + 4, + 5, + 6, + 7, + ]), + tuple( + 2, + 5, + 8, + 11, + 14, + 17, + 20, + 23, + 26, + 29, + 32, + 35, + 38, + 41, + 44, + 47, + 50, + 53, + 56, + 59, + 62, + 65, + 68, + 71, + 74, + 77, + 80, + 83, + 86, + 89, + 92, + 95, + 98, + 101, + 104, + 107, + 110, + 113, + 116, + 119, + 122, + 125, + 128, + 131, + 134, + 137, + 140, + 143, + 146, + 149, + 152, + 155, + 158, + 161, + 164, + 167, + 170, + 173, + ): list([ + 8, + 9, + 10, + 11, + ]), + }) +# --- +# name: test_snapshot_cohorts[RandomBigArray] + dict({ + }) +# --- +# name: test_snapshot_cohorts[SingleChunk] + dict({ + tuple( + 0, + ): list([ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 291, + 292, + ]), + }) +# --- diff --git a/tests/conftest.py b/tests/conftest.py index b3a0ab932..4413ea1e8 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -10,11 +10,12 @@ suppress_health_check=[HealthCheck.filter_too_much, HealthCheck.too_slow], ) settings.register_profile( - "local", + "default", max_examples=300, suppress_health_check=[HealthCheck.filter_too_much, HealthCheck.too_slow], verbosity=Verbosity.verbose, ) +settings.load_profile("default") @pytest.fixture( diff --git a/tests/strategies.py b/tests/strategies.py index fcee1c8e2..a2f95da1f 100644 --- a/tests/strategies.py +++ b/tests/strategies.py @@ -101,7 +101,7 @@ def by_arrays( ) -> st.SearchStrategy[np.ndarray[Any, Any]]: if elements is None: elements = {} - elements.setdefault("alphabet", st.characters(exclude_categories=("C",))) + elements.setdefault("alphabet", st.characters(exclude_categories=["C"])) return st.one_of( npst.arrays( dtype=npst.integer_dtypes(endianness="=") | npst.unicode_string_dtypes(endianness="="), diff --git a/tests/test_cohorts.py b/tests/test_cohorts.py new file mode 100644 index 000000000..c4c50cd99 --- /dev/null +++ b/tests/test_cohorts.py @@ -0,0 +1,29 @@ +# Snapshot tests for cohorts detection + +import pytest + +pytest.importorskip("dask") + +from asv_bench.benchmarks import cohorts + + +@pytest.mark.parametrize( + "testcase", + [ + cohorts.ERA5DayOfYear, + cohorts.ERA5Google, + cohorts.ERA5MonthHour, + cohorts.ERA5MonthHourRechunked, + cohorts.OISST, + cohorts.PerfectBlockwiseResampling, + cohorts.PerfectMonthly, + cohorts.RandomBigArray, + cohorts.SingleChunk, + cohorts.NWMMidwest, + ], +) +def test_snapshot_cohorts(testcase, snapshot): + problem = testcase() + problem.setup() + chunks_cohorts = problem.chunks_cohorts() + assert chunks_cohorts == snapshot diff --git a/tests/test_core.py b/tests/test_core.py index 998a26dee..5d4e7ec3e 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -614,6 +614,33 @@ def test_dask_reduce_axis_subset(): ) +@pytest.mark.parametrize("group_idx", [[0, 1, 0], [0, 0, 1], [1, 0, 0], [1, 1, 0]]) +@pytest.mark.parametrize( + "func", + [ + # "first", "last", + "nanfirst", + "nanlast", + ], +) +@pytest.mark.parametrize( + "chunks", + [ + None, + pytest.param(1, marks=pytest.mark.skipif(not has_dask, reason="no dask")), + pytest.param(2, marks=pytest.mark.skipif(not has_dask, reason="no dask")), + pytest.param(3, marks=pytest.mark.skipif(not has_dask, reason="no dask")), + ], +) +def test_first_last_useless(func, chunks, group_idx): + array = np.array([[0, 0, 0], [0, 0, 0]], dtype=np.int8) + if chunks is not None: + array = dask.array.from_array(array, chunks=chunks) + actual, _ = groupby_reduce(array, np.array(group_idx), func=func, engine="numpy") + expected = np.array([[0, 0], [0, 0]], dtype=np.int8) + assert_equal(actual, expected) + + @pytest.mark.parametrize("func", ["first", "last", "nanfirst", "nanlast"]) @pytest.mark.parametrize("axis", [(0, 1)]) def test_first_last_disallowed(axis, func): @@ -1564,18 +1591,36 @@ def test_validate_reindex_map_reduce( dask_expected, reindex, func, expected_groups, any_by_dask ) -> None: actual = _validate_reindex( - reindex, func, "map-reduce", expected_groups, any_by_dask, is_dask_array=True + reindex, + func, + "map-reduce", + expected_groups, + any_by_dask, + is_dask_array=True, + array_dtype=np.dtype("int32"), ) assert actual is dask_expected # always reindex with all numpy inputs actual = _validate_reindex( - reindex, func, "map-reduce", expected_groups, any_by_dask=False, is_dask_array=False + reindex, + func, + "map-reduce", + expected_groups, + any_by_dask=False, + is_dask_array=False, + array_dtype=np.dtype("int32"), ) assert actual actual = _validate_reindex( - True, func, "map-reduce", expected_groups, any_by_dask=False, is_dask_array=False + True, + func, + "map-reduce", + expected_groups, + any_by_dask=False, + is_dask_array=False, + array_dtype=np.dtype("int32"), ) assert actual @@ -1585,19 +1630,37 @@ def test_validate_reindex() -> None: for method in methods: with pytest.raises(NotImplementedError): _validate_reindex( - True, "argmax", method, expected_groups=None, any_by_dask=False, is_dask_array=True + True, + "argmax", + method, + expected_groups=None, + any_by_dask=False, + is_dask_array=True, + array_dtype=np.dtype("int32"), ) methods: list[T_Method] = ["blockwise", "cohorts"] for method in methods: with pytest.raises(ValueError): _validate_reindex( - True, "sum", method, expected_groups=None, any_by_dask=False, is_dask_array=True + True, + "sum", + method, + expected_groups=None, + any_by_dask=False, + is_dask_array=True, + array_dtype=np.dtype("int32"), ) for func in ["sum", "argmax"]: actual = _validate_reindex( - None, func, method, expected_groups=None, any_by_dask=False, is_dask_array=True + None, + func, + method, + expected_groups=None, + any_by_dask=False, + is_dask_array=True, + array_dtype=np.dtype("int32"), ) assert actual is False @@ -1609,6 +1672,7 @@ def test_validate_reindex() -> None: expected_groups=np.array([1, 2, 3]), any_by_dask=False, is_dask_array=True, + array_dtype=np.dtype("int32"), ) assert _validate_reindex( @@ -1618,6 +1682,7 @@ def test_validate_reindex() -> None: expected_groups=np.array([1, 2, 3]), any_by_dask=True, is_dask_array=True, + array_dtype=np.dtype("int32"), ) assert _validate_reindex( None, @@ -1626,8 +1691,24 @@ def test_validate_reindex() -> None: expected_groups=np.array([1, 2, 3]), any_by_dask=True, is_dask_array=True, + array_dtype=np.dtype("int32"), + ) + + kwargs = dict( + method="blockwise", + expected_groups=np.array([1, 2, 3]), + any_by_dask=True, + is_dask_array=True, ) + for func in ["nanfirst", "nanlast"]: + assert not _validate_reindex(None, func, array_dtype=np.dtype("int32"), **kwargs) # type: ignore[arg-type] + assert _validate_reindex(None, func, array_dtype=np.dtype("float32"), **kwargs) # type: ignore[arg-type] + + for func in ["first", "last"]: + assert not _validate_reindex(None, func, array_dtype=np.dtype("int32"), **kwargs) # type: ignore[arg-type] + assert not _validate_reindex(None, func, array_dtype=np.dtype("float32"), **kwargs) # type: ignore[arg-type] + @requires_dask def test_1d_blockwise_sort_optimization(): diff --git a/tests/test_properties.py b/tests/test_properties.py index 73d6ea6da..acf8a9142 100644 --- a/tests/test_properties.py +++ b/tests/test_properties.py @@ -9,6 +9,7 @@ pytest.importorskip("cftime") import dask +import hypothesis.extra.numpy as npst import hypothesis.strategies as st import numpy as np from hypothesis import assume, given, note @@ -19,6 +20,7 @@ from . import assert_equal from .strategies import by_arrays, chunked_arrays, func_st, numeric_arrays +from .strategies import chunks as chunks_strategy dask.config.set(scheduler="sync") @@ -111,9 +113,7 @@ def test_groupby_reduce(data, array, func: str) -> None: actual = actual.astype(cast_to) note(("expected: ", expected, "actual: ", actual)) - tolerance = ( - {"rtol": 1e-13, "atol": 1e-15} if "var" in func or "std" in func else {"atol": 1e-15} - ) + tolerance = {"atol": 1e-15} assert_equal(expected, actual, tolerance) @@ -131,7 +131,7 @@ def test_scans(data, array: dask.array.Array, func: str) -> None: # Too many float32 edge-cases! if "cum" in func and array.dtype.kind == "f" and array.dtype.itemsize == 4: - array = array.astype(np.float64) + assume(False) numpy_array = array.compute() assume((np.abs(numpy_array) < 2**53).all()) @@ -212,6 +212,19 @@ def test_first_last(data, array: dask.array.Array, func: str) -> None: assert_equal(first, second) +@given(data=st.data(), func=st.sampled_from(["nanfirst", "nanlast"])) +def test_first_last_useless(data, func): + shape = data.draw(npst.array_shapes()) + by = data.draw(by_arrays(shape=shape[slice(-1, None)])) + chunks = data.draw(chunks_strategy(shape=shape)) + array = np.zeros(shape, dtype=np.int8) + if chunks is not None: + array = dask.array.from_array(array, chunks=chunks) + actual, groups = groupby_reduce(array, by, axis=-1, func=func, engine="numpy") + expected = np.zeros(shape[:-1] + (len(groups),), dtype=array.dtype) + assert_equal(actual, expected) + + from hypothesis import settings