From 2d3b7ebea4d83f566d4b4dfe9cee358dea4a7682 Mon Sep 17 00:00:00 2001 From: Tanguy MARCHAND <84329436+tanguy-marchand@users.noreply.github.com> Date: Tue, 3 Dec 2024 14:42:16 +0100 Subject: [PATCH] first commit --- .ci/self_hosted_conda_creation.sh | 25 + .ci/self_hosted_conda_removal.sh | 8 + .github/ISSUE_TEMPLATE/bug_report.md | 28 + .github/ISSUE_TEMPLATE/feature_request.md | 20 + .github/PULL_REQUEST_TEMPLATE.md | 16 + .github/workflows/pr_push_validation.yml | 66 + .gitignore | 184 ++ .pre-commit-config.yaml | 33 + LICENSE | 21 + README.md | 239 +++ fedpydeseq2_datasets/__init__.py | 6 + fedpydeseq2_datasets/aggregate_raw_data.py | 372 ++++ .../assets/tcga/description.md | 1 + fedpydeseq2_datasets/assets/tcga/opener.py | 63 + fedpydeseq2_datasets/constants.py | 29 + fedpydeseq2_datasets/create_reference_dds.py | 367 ++++ fedpydeseq2_datasets/download_data/README.md | 217 +++ .../download_data/__init__.py | 0 .../download_data/assets/centers.csv | 266 +++ .../download_data/assets/ncomms9971-s2.xlsx | Bin 0 -> 553082 bytes .../download_data/config/config.yaml | 9 + .../download_data/config/config_luad.yaml | 2 + .../download_data/download_data.py | 166 ++ .../download_data/snakemake_env.yaml | 7 + .../download_data/workflow/Snakefile | 24 + .../download_data/workflow/envs/python.yaml | 9 + .../download_data/workflow/envs/recount3.yaml | 11 + .../workflow/rules/check_csv_data.smk | 35 + .../download_data/workflow/rules/common.smk | 28 + .../workflow/rules/download_data.smk | 20 + .../workflow/rules/move_data.smk | 53 + .../workflow/rules/parquet_check_data.smk | 13 + .../workflow/schemas/config.schema.yaml | 21 + .../scripts/check_recount3_metadata.py | 40 + .../csvize_check_tcga_clinical_data.py | 41 + .../scripts/csvize_check_tcga_tumor_purity.py | 46 + .../scripts/download_recount3_cohort.R | 58 + .../workflow/scripts/parquetize_check_data.py | 45 + .../process_and_split_data.py | 533 ++++++ fedpydeseq2_datasets/utils.py | 435 +++++ poetry.lock | 1493 +++++++++++++++++ pyproject.toml | 92 + tests/__init__.py | 0 tests/conftest.py | 28 + tests/paths_default.json | 1 + tests/test_create_reference_dds.py | 89 + tests/test_process_and_split_data.py | 31 + tests/test_utils.py | 48 + 48 files changed, 5339 insertions(+) create mode 100755 .ci/self_hosted_conda_creation.sh create mode 100755 .ci/self_hosted_conda_removal.sh create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/feature_request.md create mode 100644 .github/PULL_REQUEST_TEMPLATE.md create mode 100644 .github/workflows/pr_push_validation.yml create mode 100644 .gitignore create mode 100644 .pre-commit-config.yaml create mode 100644 LICENSE create mode 100644 README.md create mode 100644 fedpydeseq2_datasets/__init__.py create mode 100644 fedpydeseq2_datasets/aggregate_raw_data.py create mode 100644 fedpydeseq2_datasets/assets/tcga/description.md create mode 100644 fedpydeseq2_datasets/assets/tcga/opener.py create mode 100644 fedpydeseq2_datasets/constants.py create mode 100644 fedpydeseq2_datasets/create_reference_dds.py create mode 100644 fedpydeseq2_datasets/download_data/README.md create mode 100644 fedpydeseq2_datasets/download_data/__init__.py create mode 100644 fedpydeseq2_datasets/download_data/assets/centers.csv create mode 100644 fedpydeseq2_datasets/download_data/assets/ncomms9971-s2.xlsx create mode 100644 fedpydeseq2_datasets/download_data/config/config.yaml create mode 100644 fedpydeseq2_datasets/download_data/config/config_luad.yaml create mode 100644 fedpydeseq2_datasets/download_data/download_data.py create mode 100644 fedpydeseq2_datasets/download_data/snakemake_env.yaml create mode 100644 fedpydeseq2_datasets/download_data/workflow/Snakefile create mode 100644 fedpydeseq2_datasets/download_data/workflow/envs/python.yaml create mode 100644 fedpydeseq2_datasets/download_data/workflow/envs/recount3.yaml create mode 100644 fedpydeseq2_datasets/download_data/workflow/rules/check_csv_data.smk create mode 100644 fedpydeseq2_datasets/download_data/workflow/rules/common.smk create mode 100644 fedpydeseq2_datasets/download_data/workflow/rules/download_data.smk create mode 100644 fedpydeseq2_datasets/download_data/workflow/rules/move_data.smk create mode 100644 fedpydeseq2_datasets/download_data/workflow/rules/parquet_check_data.smk create mode 100644 fedpydeseq2_datasets/download_data/workflow/schemas/config.schema.yaml create mode 100644 fedpydeseq2_datasets/download_data/workflow/scripts/check_recount3_metadata.py create mode 100644 fedpydeseq2_datasets/download_data/workflow/scripts/csvize_check_tcga_clinical_data.py create mode 100644 fedpydeseq2_datasets/download_data/workflow/scripts/csvize_check_tcga_tumor_purity.py create mode 100644 fedpydeseq2_datasets/download_data/workflow/scripts/download_recount3_cohort.R create mode 100644 fedpydeseq2_datasets/download_data/workflow/scripts/parquetize_check_data.py create mode 100644 fedpydeseq2_datasets/process_and_split_data.py create mode 100644 fedpydeseq2_datasets/utils.py create mode 100644 poetry.lock create mode 100644 pyproject.toml create mode 100644 tests/__init__.py create mode 100644 tests/conftest.py create mode 100644 tests/paths_default.json create mode 100644 tests/test_create_reference_dds.py create mode 100644 tests/test_process_and_split_data.py create mode 100644 tests/test_utils.py diff --git a/.ci/self_hosted_conda_creation.sh b/.ci/self_hosted_conda_creation.sh new file mode 100755 index 0000000..37a57a3 --- /dev/null +++ b/.ci/self_hosted_conda_creation.sh @@ -0,0 +1,25 @@ +#!/bin/sh + +# Check that the env folder exists or create it +if [ -d ~/envs ] +then + echo "Found existing envs folder" +else + echo "Did not find envs folder, creating" + mkdir ~/envs +fi + +# Check if conda environment exists. if it does, remove it. +if [ -d "~/envs/fedomics_python_$1" ] +then + echo "Found existing fedomics conda environment, removing" + conda env remove --prefix "~/envs/fedomics_python_$1" -y +fi +conda init bash +. ~/.bashrc +# +echo "Creating environment" +yes | conda create --prefix "~/envs/fedomics_python_$1" python="$1" +echo "Created env fedomics_python_$1" +eval "$(conda shell.bash hook)" +conda activate "~/envs/fedomics_python_$1" diff --git a/.ci/self_hosted_conda_removal.sh b/.ci/self_hosted_conda_removal.sh new file mode 100755 index 0000000..675caf6 --- /dev/null +++ b/.ci/self_hosted_conda_removal.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +# Check if conda environment exists. if it does, remove it. +if [ -d "~/envs/fedomics_python_$1" ] +then + echo "Found existing fedomics conda environment, removing" + conda env remove --prefix "~/envs/fedomics_python_$1" -y +fi diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..5009781 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,28 @@ +--- +name: Bug report +about: Create a report to help us improve +title: "[BUG] " +labels: bug +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Provide snippets of code and steps on how to reproduce the behavior. +Please also specify the version you are using. + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - OS: [e.g. iOS] + - Version [e.g. 0.02] + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..bbcbbe7 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: '' +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..6222fe2 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,16 @@ + + +#### Reference Issue or PRs + + + +#### What does your PR implement? Be specific. diff --git a/.github/workflows/pr_push_validation.yml b/.github/workflows/pr_push_validation.yml new file mode 100644 index 0000000..a1115b5 --- /dev/null +++ b/.github/workflows/pr_push_validation.yml @@ -0,0 +1,66 @@ +name: Python dev + +on: + pull_request: + push: + branches: + - main + +jobs: + testing: + runs-on: ubuntu-latest + strategy: + matrix: + python: ["3.10", "3.11", "3.12"] + name: Testing Python ${{ matrix.python }} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + + - name: Install Poetry + run: | + python --version + pip install poetry==1.8.2 + + - name: Install dependencies + run: | + python --version + poetry install --with testing + + - name: Download data + run: | + mkdir -p /opt/conda + wget https://repo.anaconda.com/miniconda/Miniconda3-py39_24.5.0-0-Linux-x86_64.sh -O /opt/conda/miniconda.sh + bash /opt/conda/miniconda.sh -b -p /opt/miniconda + poetry run fedpydeseq2-download-data --only_luad --raw_data_output_path /home/runner/work/fedpydeseq2-datasets/fedpydeseq2-datasets/data/raw --conda_activate_path /opt/miniconda/bin/activate + + - name: Testing + run: | + poetry run pytest -v tests + + linting: + runs-on: ubuntu-latest + name: Test Linting + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + - name: Install Poetry + run: pip install poetry==1.8.2 + + - name: Install dependencies + run: | + which python + python --version + poetry install --with linting + + - name: Pre-commit checks + run: | + poetry run pre-commit run --all-files --show-diff-on-failure diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e4a2a98 --- /dev/null +++ b/.gitignore @@ -0,0 +1,184 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +.idea/ + +# VSCode +.vscode/ + +# DS_Store +.DS_Store + +# Data +data/centers_data/* +data/pooled_data/* +data/processed/* +data/raw/tcga/* + + +fedpydeseq2_datasets/download_data/.snakemake/* +fedpydeseq2_datasets/download_data/workflow/.snakemake +fedpydeseq2_datasets/download_data/logs/ +fedpydeseq2_datasets/download_data/results/ + +!data/raw/tcga/centers.csv + +*logs/ + +data/* diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..223e5b9 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,33 @@ +default_language_version: + python: python3.11 +repos: + - repo: https://github.com/sirosen/check-jsonschema + rev: 0.27.0 + hooks: + - id: check-github-actions + - id: check-github-workflows + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.4.0 + hooks: + - id: trailing-whitespace + name: Trim trailing whitespace + - id: end-of-file-fixer + name: Fix end of files + exclude: \.ipynb$ + - repo: https://github.com/psf/black + rev: 23.11.0 + hooks: + - id: black + additional_dependencies: ["click==8.0.4"] + args: # arguments to configure black + - --line-length=88 + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.1.5 + hooks: + - id: ruff + args: [--fix, --exit-non-zero-on-fix] + - repo: https://github.com/pre-commit/mirrors-mypy + rev: v1.7.0 + hooks: + - id: mypy + exclude: ^(tests/|docs/source/conf.py|datasets/) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..b48d852 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Owkin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..4cafbe4 --- /dev/null +++ b/README.md @@ -0,0 +1,239 @@ +# Datasets organisation + +This directory contains the data, assets and scripts necessary to: +- download the raw data necessary to run the tests and experiments, when not + available in the repository, in the `download_data` directory; +- open the data when performing a Substra experiment in the `assets` directory; +- store the data in the `data` directory. + +## Data download + +For a detailed description of the data download process, please refer to the +[README](fedpydeseq2_datasets/download_data/README.md). + +If you want to run the pipeline directly, you can use the script which is available in the distribution: `fedpydeseq2-download-data` + + + +```bash +fedpydeseq2-download-data +``` + +By default, this script download the data in the `data/raw` directory at the root of the github repo. + +To change the location of the raw data download, add the following option: +```bash +fedpydeseq2-download-data --raw_data_output_path +``` + +If you only want the LUAD dataset, add the `--only_luad` flag. + +You can pass the `conda` activation path as an argument as well, for example: + +```bash +fedpydeseq2-download-data --raw_data_output_path --conda_activate_path /opt/miniconda/bin/activate +``` + + +**Origin of the data** +- The `Counts_raw.parquet` and `recount3_metadata.csv` files are downloaded from + the [RECOUNT3](https://rna.recount.bio/) database. +- The `tumor_purity_metadata.csv` file is downloaded from the + [Systematic pan-cancer analysis of tumour purity](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4671203/) paper. +- The `cleaned_clinical_metadata.csv` file is downloaded from the + [An Integrated TCGA Pan-Cancer Clinical Data Resource to Drive High-Quality Survival Outcome Analytics](https://www.sciencedirect.com/science/article/pii/S0092867418302290#app2) paper. + +For more detailed references, see the [References](#references) section. +## Assets + +The `assets` directory contains a TCGA opener necessary to open the data on each center +when performing a federated experiment with [Substra](https://docs.substra.org/en/stable/). + +In particular, the `fedpydeseq2_datasets/assets/tcga` directory contains the following files: +``` +assets/tcga +├── description.md +├── opener.py +``` +The opener is a Python script that opens the data and makes it available to the +Substra platform. The `description.md` file contains a description of the data. + +For more details on how the opener works, please refer to +the [Substra documentation](https://docs.substra.org/en/stable/). + +## Raw data organisation + +The `data` directory contains the raw data. +The `raw` directory contains the data downloaded from the original sources, +with the `download_data` scripts. + +It is organized as follows: +``` +data +├── raw +│   └── tcga +│   ├── +│   │   ├── Counts_raw.parquet +│   │   └── recount3_metadata.csv +│   ├── centers.csv +│   ├── cleaned_clinical_metadata.csv +│   └── tumor_purity_metadata.csv + +``` + +## Data preprocessing + +This module not only provides the raw data on which to test `fedpydeseq2`; it also provides the necessary +preprocessing functions, to organise the data according to their center of origin, and to aggregate the raw +data into metadata and counts acceptable to run pydeseq2 or fedpydeseq2. + +These preprocessing function usually create the preprocessed data in a `processed_data_path` directory, with the following +structure (the files shown below are created by different preprocessing functions). + +``` +└── + ├── tcga + │   ├── + │   │   ├── counts.parquet + │   │   └── clinical_data.csv + ├── centers_data + │   └── tcga + │   ├── + │   │   ├── + │   │   │   ├── counts_data.csv + │   │   │   ├── metadata.csv + │   │   │   └── ground_truth_dds.pkl + └── pooled_data + └── tcga + ├── + │   ├── counts_data.csv + │   ├── metadata.csv + │   └── ground_truth_dds.pkl +``` + +These files are automatically generated, if they are not +already present from the raw files or if the `force` option is on. + + +Note that the centers are always indexed by an integer, starting from 0. For example, one would +have `center_0,...,center_3` if there are +4 centers in the experiment. + +The `` is an identifier of a differential gene expression task (and its specific hyperparameters) +and a TCGA dataset. `fedpydeseq2` or `deseq2` can then be run on the data corresponding to that DGE task. + +#### Details on the processed data + +In this repository, we study the following cofactors: +- the `gender` of the patients, which is obtained from the `cleaned_clinical_metadata.csv` file; +- the `CPE` of the samples, which is obtained from the `tumor_purity_metadata.csv` file; +- the `stage` of the patients, which is obtained from the `cleaned_clinical_metadata.csv` file. +this stage is originally a stage between `I` and `IV`, but we have grouped them into `I-II-III` +(`Non-advanced`) and `IV` (`Advanced`) stages, to have a binary covariate. +- the `center_id` of the samples, which is obtained from the `centers.csv` file and used +to create natural centers for the federated experiments. + + +The processing is done by functions in the `fedpydeseq2_datasets` directory. There are three main functions. + +- the `common_preprocessing_tcga` function in the `fedpydeseq2_datasets/common_preprocessing.py` +file; +- the `setup_tcga_dataset` function in the `fedpydeseq2_datasets/process_and_split_data.py` file; +- the `setup_tcga_ground_truth_dds` function in the `tcga_preprocessing/create_reference_dds.py` file. + + +The role of the `common_preprocessing_tcga` function is to generate counts and processed +clinical data for a given cohort (e.g. `LUAD`), from the raw data. +``` +└── processed + ├── tcga + │   ├── + │   │   ├── counts.parquet + │   │   └── clinical_data.csv +``` +The `counts.parquet` file contains the counts data, indexed by TCGA sample barcode, +and with columns corresponding to the gene_id in ENSEMBL convention. +Note that we filter out the `PAR_Y` genes, as they are not common to all patients. +The `clinical_data.csv` file aggregates the different metadata from the different sources +described above in a per-cohort fashion. This `csv` is indexed by the TCGA sample barcode. +It contains the following columns: +- `gender`: the gender of the patient; +- `CPE`: CPE stands for "consensus measurement of purity estimations", and is an +aggregate of different purity estimations for the sample; +- `stage`: the stage of the patient, as an integer between 1 and 4 +- `center_id`: the center id of the sample, as an integer +- `is_normal_tissue`: a boolean indicating if the sample is a normal tissue or not. +- `T` : the tumor grade of the patient, as an integer between 1 and 4 +- `N` : the nodal status of the patient, as an integer between 0 and 3 +- `M` : the metastasis status of the patient, as an integer between 0 and 1 + + +The role of the `setup_tcga_dataset` function and the `setup_tcga_ground_truth_dds` function +is to generate the data necessary for the federated AND corresponding pooled experiments, creating +this part of the arborescence: +``` +└── processed + ├── centers_data + │   └── tcga + │   ├── + │   │   ├── + │   │   │   ├── counts_data.csv + │   │   │   ├── metadata.csv + │   │   │   └── ground_truth_dds.pkl + └── pooled_data + └── tcga + ├── + │   ├── counts_data.csv + │   ├── metadata.csv + │   └── ground_truth_dds.pkl +``` +The `` identifies an experiment. It concatenates +not only the dataset name (TCGA cohort), but also the design factors, continuous factors +as well as other parameters used to filter the data. +The `counts_data.csv` file contains the counts data, indexed by TCGA sample barcode, +and with columns corresponding to the gene_id in ENSEMBL convention. +The `metadata.csv` file contains the clinical data, indexed by the TCGA sample barcode, and +containing only the columns corresponding to a design factor. +The `ground_truth_dds.pkl` file contains the ground truth for the differential expression +analysis, as a `dds` object from the `DESeq2` package. + +For more details on these functions, please refer to their respective documentations. + +> **Note**: the `setup_tcga_dataset` function +> will binarize the `stage` into two categories: `Advanced` and `Non-advanced`. +> `Advanced` corresponds to stage `IV`, and `Non-advanced` corresponds to stages `I`, `II` and `III`. +> For the TCGA-PRAD cohort, we do not have the stage information, but we infer the stage +> from the `T`, `N` and `M` columns. If the `N` or `M` columns are > 0, the stage is IV (see the +> following [reference](https://www.cancer.org/cancer/types/prostate-cancer/detection-diagnosis-staging/staging.html)) +> and hence the `Advanced` stage. Otherwise, it is `Non-advanced`. +## References + +The data downloaded here has mainly been obtained from TCGA and processed by the following +works. + +[1] Aran D, Sirota M, Butte AJ. + Systematic pan-cancer analysis of tumour purity. + Nat Commun. 2015 Dec 4;6:8971. + doi: 10.1038/ncomms9971. + Erratum in: Nat Commun. 2016 Feb 05;7:10707. + doi: 10.1038/ncomms10707. + PMID: 26634437; PMCID: PMC4671203. + + +[2] Jianfang Liu, Tara Lichtenberg, Katherine A. Hoadley, Laila M. Poisson, Alexander J. Lazar, Andrew D. Cherniack, Albert J. Kovatich, Christopher C. Benz, Douglas A. Levine, Adrian V. Lee, Larsson Omberg, Denise M. Wolf, Craig D. Shriver, Vesteinn Thorsson et al. + An Integrated TCGA Pan-Cancer Clinical Data Resource to Drive High-Quality Survival Outcome Analytics, + Cell, + Volume 173, Issue 2, 2018, Pages 400-416.e11, + ISSN 0092-8674, + + + +[3] Wilks C, Zheng SC, Chen FY, Charles R, Solomon B, Ling JP, Imada EL, + Zhang D, Joseph L, Leek JT, Jaffe AE, Nellore A, Collado-Torres L, + Hansen KD, Langmead B (2021). + "recount3: summaries and queries for + large-scale RNA-seq expression and splicing." + _Genome Biol_. + doi:10.1186/s13059-021-02533-6 + , + . diff --git a/fedpydeseq2_datasets/__init__.py b/fedpydeseq2_datasets/__init__.py new file mode 100644 index 0000000..9795584 --- /dev/null +++ b/fedpydeseq2_datasets/__init__.py @@ -0,0 +1,6 @@ +"""Module to preprocess the TCGA data for fedpydeseq2.""" + +from fedpydeseq2_datasets.process_and_split_data import setup_tcga_dataset +from fedpydeseq2_datasets.create_reference_dds import setup_tcga_ground_truth_dds +from fedpydeseq2_datasets.utils import get_experiment_id +from fedpydeseq2_datasets.utils import get_ground_truth_dds_name diff --git a/fedpydeseq2_datasets/aggregate_raw_data.py b/fedpydeseq2_datasets/aggregate_raw_data.py new file mode 100644 index 0000000..6087d00 --- /dev/null +++ b/fedpydeseq2_datasets/aggregate_raw_data.py @@ -0,0 +1,372 @@ +from pathlib import Path + +import pandas as pd + +from fedpydeseq2_datasets.utils import tnm_to_series + +LIST_COL_WITH_UNSPECIFIED_TYPE = [ + "tcga.xml_her2_and_centromere_17_positive_finding_other_measurement_scale_text", + "tcga.xml_fluorescence_in_situ_hybridization_diagnostic_procedure_chromosome_17" + "_signal_result_range", + "tcga.xml_metastatic_breast_carcinoma_immunohistochemistry_er_pos_cell_score", + "tcga.xml_metastatic_breast_carcinoma_immunohistochemistry_pr_pos_cell_score", + "tcga.xml_metastatic_breast_carcinoma_erbb2_immunohistochemistry_level_result", + "tcga.xml_metastatic_breast_carcinoma_lab_proc_her2_neu_in_situ_hybridization" + "_outcome_type", +] + + +def run_sanity_checks_raw_data( + dataset_name: str, + raw_data_path: str | Path, +): + """ + Run sanity checks on the raw data. + + This function runs sanity checks on the raw data to ensure that the data is + correctly formatted and that the data is not corrupted. + + It does so by checking the following conditions: + - The Counts_raw.parquet for the given dataset exists and contains + between 40 000 and 70 000 genes and between 10 and 1300 samples. + - The recount3_metadata.tsv.gz file for the given dataset exists and contains + the columns "external_id" and "tcga.tcga_barcode". + - The cleaned_clinical_metadata.csv file for the given dataset exists and contains + the columns "bcr_patient_barcode", "gender" and "ajcc_pathologic_tumor_stage". + - The tumor_purity_metadata.csv file for the given dataset exists and contains + the columns "Sample ID" and "CPE". + - The centers.csv file for the given dataset exists and contains the columns + "TSS Code" and "Region". + + Parameters + ---------- + dataset_name : str + The TCGA dataset name in the format of "tcga-cohort" (capitalized). + For example, "TCGA-BRCA" for the breast cancer cohort. + + raw_data_path : str or Path + The path to the raw data folder. + This raw data folder is assumed to have the following structure and sub files + + ├── tcga + │ ├── COHORT + │ │ ├── Counts_raw.parquet + │ │ └── recount3_metadata.tsv.gz + │ ├── cleaned_clinical_metadata.csv + │ ├── tumor_purity_metadata.csv + │ └── centers.csv + Note that the `centers` file is already in the repository. The rest of the + files can be downloaded with the snakemake pipeline, and are + already available for the LUAD dataset. + + """ + dataset, cohort = dataset_name.split("-")[:2] + # Convert to path + raw_data_path = Path(raw_data_path) + assert dataset.lower() == "tcga" + # Check that the centers file exists + assert (raw_data_path / "tcga" / "centers.csv").exists() + # Load it + centers = pd.read_csv( + raw_data_path / "tcga" / "centers.csv", + ) + assert "TSS Code" in centers.columns + assert "Region" in centers.columns + # Check that the cleaned clinical metadata file exists + + assert (raw_data_path / "tcga" / "cleaned_clinical_metadata.csv").exists() + # Load it + cleaned_clinical = pd.read_csv( + raw_data_path / "tcga" / "cleaned_clinical_metadata.csv" + ) + # Check it contains the right columns + assert "bcr_patient_barcode" in cleaned_clinical.columns + assert "gender" in cleaned_clinical.columns + assert "ajcc_pathologic_tumor_stage" in cleaned_clinical.columns + # Check that the tumor purity metadata file exists + assert (raw_data_path / "tcga" / "tumor_purity_metadata.csv").exists() + # Load it + tumor_purity = pd.read_csv( + raw_data_path / "tcga" / "tumor_purity_metadata.csv", + ) + assert "Sample ID" in tumor_purity.columns + assert "CPE" in tumor_purity.columns + # Check that the recount3 metadata file exists + assert (raw_data_path / "tcga" / cohort / "recount3_metadata.tsv.gz").exists() + # Load it + + # specify the dtype of the columns to avoid warnings + dtype_dict = {col: "object" for col in LIST_COL_WITH_UNSPECIFIED_TYPE} + recount3_metadata = pd.read_csv( + raw_data_path / "tcga" / cohort / "recount3_metadata.tsv.gz", + sep="\t", + dtype=dtype_dict, + ) + # Check the columns + assert "external_id" in recount3_metadata.columns + assert "tcga.tcga_barcode" in recount3_metadata.columns + + # Check that the counts file exists + assert (raw_data_path / "tcga" / cohort / "Counts_raw.parquet").exists() + # Load it + counts = pd.read_parquet(raw_data_path / "tcga" / cohort / "Counts_raw.parquet") + # Check that the number of genes is roughly between 40 000 and 70 000 + assert 40000 < counts.shape[0] < 70000 + # Check that the number of samples is greater than 10 and less than 1000 + assert 10 < counts.shape[1] < 1300 + return + + +def common_preprocessing_tcga( + dataset_name: str, + raw_data_path: str | Path, + processed_data_path: str | Path, + force: bool = False, +): + """ + Preprocess the TCGA data and merge all different metadata files. + + This function preprocesses the TCGA data and merges all the different metadata + files into a single clinical data file. + + It also indexes the count matrix by the barcodes and removes all genes ending with + PAR_Y. It also removes the gene version by taking the first one. + + Parameters + ---------- + dataset_name : str + The TCGA dataset name in the format of "tcga-cohort" (capitalized). + For example, "TCGA-BRCA" for the breast cancer cohort. + + raw_data_path : str or Path + The path to the raw data folder. + This raw data folder is assumed to have the following structure and sub files + + ├── tcga + │ ├── COHORT + │ │ ├── Counts_raw.parquet + │ │ └── recount3_metadata.tsv.gz + │ ├── cleaned_clinical_metadata.csv + │ ├── tumor_purity_metadata.csv + │ └── centers.csv + Note that the `centers` file is already in the repository. The rest of the + files can be downloaded with the snakemake pipeline, and are + already available for the LUAD dataset. + + processed_data_path : str or Path + The path to the processed data folder. This function will create the following + files in this folder: + + ├── tcga + │ └── COHORT + │ ├── counts.parquet + │ └── clinical_data.csv + + force : bool + If True, the function will run the preprocessing even if the processed data + already exists. Default is False. + + Raises + ------ + ValueError + If there are missing TSS codes in the centers.csv file. + + """ + if dataset_name in ["TCGA-NSCLC", "TCGA-CRC"]: + if dataset_name == "TCGA-NSCLC": + dataset_1, dataset_2 = "TCGA-LUAD", "TCGA-LUSC" + elif dataset_name == "TCGA-CRC": + dataset_1, dataset_2 = "TCGA-COAD", "TCGA-READ" + + common_preprocessing_tcga( + dataset_name=dataset_1, + raw_data_path=raw_data_path, + processed_data_path=processed_data_path, + force=force, + ) + common_preprocessing_tcga( + dataset_name=dataset_2, + raw_data_path=raw_data_path, + processed_data_path=processed_data_path, + force=force, + ) + return + + run_sanity_checks_raw_data(dataset_name, raw_data_path) + dataset, cohort = dataset_name.split("-")[:2] + # Convert to path + raw_data_path = Path(raw_data_path) + processed_data_path = Path(processed_data_path) + assert dataset.lower() == "tcga" + # Load the data from the cohort + # Check if the outputs exist. If they both do, return + if ( + (processed_data_path / "tcga" / cohort / "counts.parquet").exists() + and (processed_data_path / "tcga" / cohort / "clinical_data.csv").exists() + and not force + ): + return + + counts = pd.read_parquet(raw_data_path / "tcga" / cohort / "Counts_raw.parquet") + # specify the dtype of the columns to avoid warnings + dtype_dict = {col: "object" for col in LIST_COL_WITH_UNSPECIFIED_TYPE} + recount3_metadata = pd.read_csv( + raw_data_path / "tcga" / cohort / "recount3_metadata.tsv.gz", + sep="\t", + dtype=dtype_dict, + ) + # Load only the barcodes and the external ids in the recount3 data + + recount3_metadata = recount3_metadata[ + ["external_id", "tcga.tcga_barcode", "tcga.xml_stage_event_tnm_categories"] + ] + # Now create a mapping between the external id and the barcodes + recount3_metadata = recount3_metadata.set_index("external_id") + # apply this to the columns + counts.columns = counts.columns.map(recount3_metadata["tcga.tcga_barcode"]) + # remove the gene_name index + counts = counts.droplevel("gene_name") + # Remove all genes ending with PAR_Y + counts = counts.loc[~counts.index.str.endswith("PAR_Y")] + counts = counts.T + counts.index.name = "barcode" + # Now we filter the gene version by taking the first one. + counts.columns = counts.columns.str.split(".").str[0] + counts = counts.loc[:, ~counts.columns.duplicated()] + counts = counts[~counts.index.duplicated(keep="first")] + # We now have a clean count matrix + # we create a column indicating if normal tissue + is_normal_tissue = ( + recount3_metadata["tcga.tcga_barcode"] + .map(lambda x: x[:15]) + .map(lambda x: 10 <= int(x[-2:]) <= 29) + ) + is_normal_tissue.index = recount3_metadata["tcga.tcga_barcode"] + is_normal_tissue = is_normal_tissue[ + ~is_normal_tissue.index.duplicated(keep="first") + ] + # We create T, N, M columns + tnm_columns = ( + recount3_metadata["tcga.xml_stage_event_tnm_categories"] + .apply(tnm_to_series) + .astype("Int8") + ) + tnm_columns.index = recount3_metadata["tcga.tcga_barcode"] + tnm_columns = tnm_columns[~tnm_columns.index.duplicated(keep="first")] + + # Now we load the clinical data + cleaned_clinical = pd.read_csv( + raw_data_path / "tcga" / "cleaned_clinical_metadata.csv" + ) + # We filter 3 columns + cleaned_clinical = cleaned_clinical[ + ["bcr_patient_barcode", "ajcc_pathologic_tumor_stage", "gender"] + ] + # We create a correspondance between sample and patient + cleaned_clinical = cleaned_clinical.set_index("bcr_patient_barcode") + + # Filter the patient that are not in cleaned_clinical + counts = counts.loc[counts.index.map(lambda x: x[:12] in cleaned_clinical.index)] + is_normal_tissue = is_normal_tissue.loc[counts.index] + # create a dataframe + + barcode_to_patient = pd.DataFrame( + index=counts.index, + data=counts.index.str[:12].to_list(), + columns=["bcr_patient_barcode"], + ) + + cleaned_clinical = cleaned_clinical.loc[barcode_to_patient["bcr_patient_barcode"]] + cleaned_clinical.index = counts.index + # lower case the gender + cleaned_clinical.loc[:, "gender"] = cleaned_clinical["gender"].str.lower() + + # Now we define the stage in 1,2,3,4 or NA if it is normal tissue + def process_stage(stage_str): + if stage_str.startswith("Stage IV"): + return 4 + elif stage_str.startswith("Stage III"): + return 3 + elif stage_str.startswith("Stage II"): + return 2 + elif stage_str.startswith("Stage I"): + return 1 + else: + return pd.NA + + cleaned_clinical.loc[:, "ajcc_pathologic_tumor_stage"] = ( + cleaned_clinical["ajcc_pathologic_tumor_stage"] + .apply(process_stage) + .astype("Int16") + ) + # Add a is_normal_tissue column + cleaned_clinical.loc[:, "is_normal_tissue"] = is_normal_tissue + # Set the tumor stage to NA if normal tissue + cleaned_clinical.loc[is_normal_tissue, "ajcc_pathologic_tumor_stage"] = pd.NA + # Add the T, N, M columns + cleaned_clinical = cleaned_clinical.join(tnm_columns) + # Set T, N, M columns to pd.NA if normal tissue + cleaned_clinical.loc[is_normal_tissue, ["T", "N", "M"]] = pd.NA + # now load the tumor purity metadata + tumor_purity = pd.read_csv( + raw_data_path / "tcga" / "tumor_purity_metadata.csv", + ) + barcode_to_sample = pd.DataFrame( + index=counts.index, + data=counts.index.str[:16].to_list(), + columns=["Sample ID"], + ) + tumor_purity = tumor_purity.set_index("Sample ID") + # Add nan rows for all sample ids which are in the counts but not in + # the tumor purity + missing_sample_ids = list( + set(barcode_to_sample["Sample ID"]) - set(tumor_purity.index) + ) + missing_samples = pd.DataFrame( + index=missing_sample_ids, + columns=tumor_purity.columns, + ).astype(tumor_purity.dtypes) + tumor_purity = pd.concat([tumor_purity, missing_samples], axis=0) + + tumor_purity = tumor_purity.loc[barcode_to_sample["Sample ID"]] + tumor_purity.index = counts.index + # We add the CPE column of the tumor purity to the clinical data + cleaned_clinical.loc[:, "CPE"] = tumor_purity["CPE"] + # Getting the centers info + centers_metadata = pd.read_csv( + raw_data_path / "tcga" / "centers.csv", + ) + centers_metadata = centers_metadata[["TSS Code", "Region"]] + centers_metadata["TSS Code"] = centers_metadata["TSS Code"].apply( + lambda x: x.lstrip("0") + ) + centers_metadata = centers_metadata.set_index("TSS Code") + # Get the TSS code + cleaned_clinical["TSS"] = cleaned_clinical.index.to_series().apply( + lambda x: x.split("-")[1] + ) + # Remove leading zeros in both indexes + cleaned_clinical["TSS"] = cleaned_clinical["TSS"].apply(lambda x: x.lstrip("0")) + diff = set(cleaned_clinical["TSS"]) - set(centers_metadata.index) + if len(diff) > 0: + raise ValueError( + f"Missing TSS codes {diff} in the centers.csv file." + f"Please add these missing codes." + ) + cleaned_clinical = cleaned_clinical.join(centers_metadata, on="TSS") + cleaned_clinical.drop(columns="TSS", inplace=True) + # encode the center + cleaned_clinical["center_id"] = pd.Categorical(cleaned_clinical.Region).codes + + cleaned_clinical.drop(columns="Region", inplace=True) + # Rename ajcc_pathologic_tumor_stage to stage + cleaned_clinical.rename( + columns={"ajcc_pathologic_tumor_stage": "stage"}, inplace=True + ) + # Now we save the data + + output_folder = processed_data_path / "tcga" / cohort + output_folder.mkdir(parents=True, exist_ok=True) + counts.to_parquet(output_folder / "counts.parquet") + cleaned_clinical.to_csv(output_folder / "clinical_data.csv") + return diff --git a/fedpydeseq2_datasets/assets/tcga/description.md b/fedpydeseq2_datasets/assets/tcga/description.md new file mode 100644 index 0000000..bfbcff0 --- /dev/null +++ b/fedpydeseq2_datasets/assets/tcga/description.md @@ -0,0 +1 @@ +TCGA RNA data used for fedpydeseq2 diff --git a/fedpydeseq2_datasets/assets/tcga/opener.py b/fedpydeseq2_datasets/assets/tcga/opener.py new file mode 100644 index 0000000..e6a3586 --- /dev/null +++ b/fedpydeseq2_datasets/assets/tcga/opener.py @@ -0,0 +1,63 @@ +import pathlib + +import anndata as ad +import pandas as pd +import substratools as tools +from pydeseq2.utils import load_example_data + + +class TCGAOpener(tools.Opener): + """Opener class for TCGA RNA-seq datasets. + + Creates an AnnData object from a path containing a counts_data.csv and a + metadata.csv. + """ + + def fake_data(self, n_samples=None): + """Create a fake AnnData object for testing purposes. + + Parameters + ---------- + n_samples : int + Number of samples to generate. If None, generate 100 samples. + + Returns + ------- + AnnData + An AnnData object with fake counts and metadata. + """ + N_SAMPLES = n_samples if n_samples and n_samples <= 100 else 100 + fake_counts = load_example_data(modality="raw_counts").iloc[:N_SAMPLES] + fake_metadata = load_example_data(modality="metadata").iloc[:N_SAMPLES] + return ad.AnnData(X=fake_counts, obs=fake_metadata) + + def get_data(self, folders): + """Open the TCGA dataset. + + Parameters + ---------- + folders : list + list of paths to the dataset folders, whose first element should contain a + counts_data.csv and a metadata.csv file. + + Returns + ------- + AnnData + An AnnData object containing the counts and metadata loaded for the FL pipe. + """ + # get .csv files + data_path = pathlib.Path(folders[0]).resolve() + counts_data = pd.read_csv(data_path / "counts_data.csv", index_col=0) + metadata = pd.read_csv(data_path / "metadata.csv", index_col=0) + center_id = metadata["center_id"].iloc[0] + # We assume that the center id is not present in the counts data, if it is + # present, we raise an error (it should have been removed in an earlier + # step) + if "center_id" in counts_data.columns: + raise ValueError("center_id column found in counts data") + metadata.drop(columns=["center_id"], inplace=True) + # Build an Anndata object + adata = ad.AnnData(X=counts_data, obs=metadata) + # Add the center id to be accessible within the local states + adata.uns["center_id"] = center_id + return adata diff --git a/fedpydeseq2_datasets/constants.py b/fedpydeseq2_datasets/constants.py new file mode 100644 index 0000000..1c8e482 --- /dev/null +++ b/fedpydeseq2_datasets/constants.py @@ -0,0 +1,29 @@ +from typing import Literal +from typing import cast + +TCGADatasetNames = Literal[ + "TCGA-LUAD", + "TCGA-PAAD", + "TCGA-BRCA", + "TCGA-COAD", + "TCGA-LUSC", + "TCGA-READ", + "TCGA-SKCM", + "TCGA-PRAD", + "TCGA-NSCLC", + "TCGA-CRC", +] + +TCGA_DATASET_NAMES = [ + cast(TCGADatasetNames, dataset) + for dataset in [ + "TCGA-LUAD", + "TCGA-PAAD", + "TCGA-BRCA", + "TCGA-COAD", + "TCGA-LUSC", + "TCGA-READ", + "TCGA-SKCM", + "TCGA-PRAD", + ] +] diff --git a/fedpydeseq2_datasets/create_reference_dds.py b/fedpydeseq2_datasets/create_reference_dds.py new file mode 100644 index 0000000..72ce26d --- /dev/null +++ b/fedpydeseq2_datasets/create_reference_dds.py @@ -0,0 +1,367 @@ +import pickle as pkl +from inspect import signature +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +from loguru import logger +from pydeseq2.dds import DeseqDataSet + +from fedpydeseq2_datasets.constants import TCGADatasetNames +from fedpydeseq2_datasets.utils import get_experiment_id +from fedpydeseq2_datasets.utils import get_ground_truth_dds_name + +ALLOWED_DESIGN_FACTORS_TCGA = {"stage", "gender", "CPE"} +ALLOWED_CONTINUOUS_FACTORS_TCGA = {"CPE"} + + +def setup_tcga_ground_truth_dds( + processed_data_path: str | Path, + dataset_name: TCGADatasetNames = "TCGA-LUAD", + small_samples: bool = False, + small_genes: bool = False, + only_two_centers: bool = False, + design_factors: str | list[str] = "stage", + continuous_factors: list[str] | None = None, + reference_dds_ref_level: tuple[str, ...] | None = ("stage", "Advanced"), + force: bool = False, + heterogeneity_method: str | None = None, + heterogeneity_method_param: float | None = None, + pooled: bool = True, + default_refit_cooks: bool = False, + **pydeseq2_kwargs: Any, +): + """Set the ground truth DeseqDataSet for the TCGA dataset. + + This function is given the path to the processed data. + Then it preprocesses the data and initializes the DeseqDataSet. + WARNING: by default, the cooks outliers are NOT refitted. + Afterward, it performs the Deseq2 pipeline. + Finally, it saves the pooled_dds and all the local_dds on the disk. + The local dds is simply the restriction of the global dds to the center id, for + each center. + + + The file structure for the processed data is the following (result + from the `setup_tcga_dataset` function): + + ``` + + ├── centers_data + │ └── tcga + │ └── + │ └── center_0 + │ ├── counts_data.csv + │ └── metadata.csv + ├── pooled_data + │ └── tcga + │ └── + │ ├── counts_data.csv + │ └── metadata.csv + + ``` + + The file structure output for the processed data is the following: + + ``` + + ├── centers_data + │ └── tcga + │ └── + │ └── center_0 + │ ├── counts_data.csv + │ ├── metadata.csv + │ └── ground_truth_dds.pkl # if pooled + │ └── ground_truth_dds-center.pkl # if not pooled + + ├── pooled_data + │ └── tcga + │ └── + │ ├── counts_data.csv + │ ├── metadata.csv + │ └── ground_truth_dds.pkl # if pooled + └── + + ``` + + Parameters + ---------- + processed_data_path : str or Path + Path to processed data. + dataset_name: TCGADatasetNames = "TCGA-LUAD", + The dataset to preprocess, by default "TCGA-LUAD". + small_samples : bool + If True, only preprocess a small subset of the data, by default False. + This small subset is composed of 10 samples per center. + small_genes : bool + If True, only preprocess a small subset of the data features (genes) + , by default False. This small subset is composed of 100 genes. + only_two_centers : bool + If True, split the data in two centers only, by default False. + design_factors : str or list + The design factors. + continuous_factors : list[str] or None + The continuous design factors. + reference_dds_ref_level : tuple or None + The reference level for the design factor. + force : bool + If True, force the setup of the dataset even if the metadata already exists. + Default is False. + heterogeneity_method : str or None + The method to use to generate heterogeneity in the dataset. If None, no + heterogeneity is generated. Default is None. + heterogeneity_method_param : float or None + The parameter of the heterogeneity method. Default is None. + pooled : bool + If True, We compute the pooled dds, and then restrict it to the + center to get the local dds. If False, we only compute the local dds + from the center data only. Default is True. + default_refit_cooks : bool + If True, refit the cooks outliers. Default is False. + **pydeseq2_kwargs + Additional arguments to pass to the pydeseq2 and fedpydeseq2 classes and + strategies. + + """ + processed_data_path = Path(processed_data_path).resolve() + logger.info(f"Design factors in setup_tcga_ground_truth_dds: {design_factors}") + + refit_cooks = pydeseq2_kwargs.get("refit_cooks", default_refit_cooks) + + experiment_id = get_experiment_id( + dataset_name, + small_samples, + small_genes, + only_two_centers, + design_factors, + continuous_factors, + heterogeneity_method=heterogeneity_method, + heterogeneity_method_param=heterogeneity_method_param, + **pydeseq2_kwargs, + ) + + pooled_data_path = processed_data_path / "pooled_data" / "tcga" / experiment_id + + ground_truth_dds_name = get_ground_truth_dds_name( + reference_dds_ref_level, refit_cooks=refit_cooks, pooled=pooled + ) + + pooled_dds_file_path = pooled_data_path / f"{ground_truth_dds_name}.pkl" + + # Check that all centers dds files were generated + metadata = pd.read_csv( + processed_data_path / "pooled_data" / "tcga" / experiment_id / "metadata.csv", + index_col=0, + ) + + if pooled and (not pooled_dds_file_path.exists() or force): + # -- Process the data and initialize the DeseqDataSet + dds_file_name = get_ground_truth_dds_name( + reference_dds_ref_level, refit_cooks=refit_cooks, pooled=True + ) + + pooled_dds_file_path = pooled_data_path / f"{dds_file_name}.pkl" + + # We pass the default refit_cooks to the setup_ground_truth_dds function + # It is overwritten by the refit_cooks parameter if it is passed + # as a pydesq2_kwargs + setup_ground_truth_dds_kwargs = {"refit_cooks": refit_cooks, **pydeseq2_kwargs} + + _setup_ground_truth_dds( + pooled_data_path, + pooled_dds_file_path, + design_factors, + continuous_factors, + reference_dds_ref_level, + **setup_ground_truth_dds_kwargs, + ) + + for center_id in metadata.center_id.unique(): + center_data_path = ( + processed_data_path + / "centers_data" + / "tcga" + / experiment_id + / f"center_{center_id}" + ) + center_dds_file_path = center_data_path / f"{ground_truth_dds_name}.pkl" + if not center_dds_file_path.exists() or force: + if pooled: + # In that case we need to reprocess the data + _setup_local_ground_truth_dds( + pooled_dds_file_path, + center_data_path.parent, + metadata, + ) + break + # Else, build the local dds from the center data only + try: + _setup_ground_truth_dds( + center_data_path, + center_dds_file_path, + design_factors, + continuous_factors, + reference_dds_ref_level, + **{"refit_cooks": refit_cooks, **pydeseq2_kwargs}, + ) + except ValueError as e: + logger.warning( + f"Error while setting up the local dds for center {center_id}: " + f"{e}, will set None for this center" + ) + with open(center_dds_file_path, "wb") as file: + pkl.dump(None, file) + + +def _setup_local_ground_truth_dds( + pooled_dds_file_path: Path, + center_data_path: Path, + metadata: pd.DataFrame, +): + """Set the local ground truth DeseqDataSet for the TCGA dataset. + + This function is given the path to the pooled_dds and the path to the center data. + Then it loads the pooled_dds and initializes the local DeseqDataSet for each center. + Finally, it saves the local_dds on the disk. + + For the file structure description, see the `setup_tcga_ground_truth_dds` function. + + Parameters + ---------- + pooled_dds_file_path : Path + Path to the pooled_dds. + center_data_path : Path + Path to the center data. + metadata : pd.DataFrame + Metadata of the pooled data. + """ + with open(pooled_dds_file_path, "rb") as file: + pooled_dds = pkl.load(file) + + for k in metadata.center_id.unique(): + local_reference_dds = pooled_dds[pooled_dds.obs.center_id == k].copy() + path = center_data_path / f"center_{k}" + path.mkdir(parents=True, exist_ok=True) + with open(path / pooled_dds_file_path.name, "wb") as file: + pkl.dump(local_reference_dds, file) + + +def _setup_ground_truth_dds( + data_path: Path, + output_file_path: Path, + design_factors: str | list[str], + continuous_factors: list[str] | None, + reference_dds_ref_level: tuple[str, ...] | None, + **pydeseq2_kwargs, +): + """Process the data and initialize the DeseqDataSet. + + This function is given the path to the pooled data. + Then it loads the data and initializes the DeseqDataSet. + Afterward, it performs the Deseq2 pipeline. + Finally, it saves the pooled_dds on the disk. + + For the file structure description, see the `setup_tcga_ground_truth_dds` function. + + Parameters + ---------- + data_path : Path + Path to the data necessary to initialize the DeseqDataSet. + We require that the data path be a directory containing the following files: + - counts_data.csv + - metadata.csv + + output_file_path : Path + Path to save the DeseqDataSet. + It is expected to be a pkl file. + + design_factors : str or list + The design factors. + + continuous_factors : list[str] or None + The list of continuous factors. Factors not in this list will be considered + as categorical. + + reference_dds_ref_level : tuple or None + The reference level for the design factor. + + **pydeseq2_kwargs + Additional arguments to pass to the pydeseq2 and fedpydeseq2 classes and + strategies. + + """ + counts_data = pd.read_csv( + data_path / "counts_data.csv", + index_col=0, + ) + metadata = pd.read_csv( + data_path / "metadata.csv", + index_col=0, + ) + if "center_id" in counts_data.columns: + counts_data.drop(columns="center_id", inplace=True) + + dds_kwargs = { + parameter_name: parameter_value + for parameter_name, parameter_value in pydeseq2_kwargs.items() + if parameter_name in signature(DeseqDataSet).parameters + } + + ref_level = ( + list(reference_dds_ref_level) if reference_dds_ref_level is not None else None + ) + pooled_dds = DeseqDataSet( + counts=counts_data, + metadata=metadata, + design_factors=design_factors, + ref_level=ref_level, + continuous_factors=continuous_factors, + **dds_kwargs, + ) + + # log the dds parameters + logger.info("Creating a DeseqDataSet with the following parameters:") + logger.info(f"Counts path { data_path / 'counts_data.csv'}") + logger.info(f"Metadata path { data_path / 'metadata.csv'}") + logger.info(f"Design factors {design_factors}") + logger.info(f"Continuous factors {continuous_factors}") + logger.info(f"Reference level {ref_level}") + logger.info(f"PyDESeq2 kwargs {pydeseq2_kwargs}") + + # -- Perform the Deseq2 pipeline. + + # Compute DESeq2 normalization factors using the Median-of-ratios method + pooled_dds.fit_size_factors() + # Fit an independent negative binomial model per gene + pooled_dds.fit_genewise_dispersions() + # Fit a parameterized trend curve for dispersions, of the form + # f(\mu) = \alpha_1/\mu + a_0 + pooled_dds.fit_dispersion_trend() + disp_function_type = pooled_dds.uns["disp_function_type"] + logger.info(f"Dispersion function type: {disp_function_type}") + # Compute prior dispersion variance + pooled_dds.fit_dispersion_prior() + # Refit genewise dispersions a posteriori (shrinks estimates towards trend curve) + pooled_dds.fit_MAP_dispersions() + # Fit log-fold changes (in natural log scale) + pooled_dds.fit_LFC() + + pooled_dds.calculate_cooks() + + if pooled_dds.refit_cooks: + logger.info("DDSEq2: Refitting cooks outliers") + pooled_dds.refit() + # Here, we must change the replaced genes to a boolean array + # As AnnData does not support the series version of replaced + # defined in deseq2 (issues when copying) + if pooled_dds.obsm["replaceable"].sum() == 0: + pooled_dds.varm["replaced"] = np.zeros((pooled_dds.n_vars,), dtype=bool) + + # -- Save the pooled_dds + + output_file_path.parent.mkdir(parents=True, exist_ok=True) + + logger.info(f"Saving the pooled dds at {output_file_path}") + with open(output_file_path, "wb") as file: + pkl.dump(pooled_dds, file) diff --git a/fedpydeseq2_datasets/download_data/README.md b/fedpydeseq2_datasets/download_data/README.md new file mode 100644 index 0000000..69b7c81 --- /dev/null +++ b/fedpydeseq2_datasets/download_data/README.md @@ -0,0 +1,217 @@ +# Data download + +Repository for downloading the raw data necessary to run the tests and experiments. + +This directory contains a [snakemake](https://snakemake.readthedocs.io/) pipeline for downloading RNA-seq data from [RECOUNT3](https://rna.recount.bio/), +tumor purity metadata for TCGA from the [Systematic pan-cancer analysis of tumour purity](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4671203/) paper, +and cleaned clinical metadata for TCGA from the [An Integrated TCGA Pan-Cancer Clinical Data Resource to Drive High-Quality Survival Outcome Analytics](https://www.sciencedirect.com/science/article/pii/S0092867418302290#app2) +paper. + + +## Setup +The only configuration needed is the list of project to be downloaded, specified in [config/config.yaml](config/config.yaml). +The gene nomenclature is "ENSEMBL". +By default the pipeline downloads the data necessary to run the experiments of the paper, +that is the following TCGA cohorts: +```yaml +datasets : + - LUAD + - LUSC + - PAAD + - COAD + - BRCA + - PRAD + - READ + - SKCM +``` + + +## Execution +For execution, you will need to clone this repository, +and go to the root of this README, that is `download_data` + +Note that this pipeline requires a working installation of `conda`, +and requires access to certain `R` packages through `curl`. + +### Directly running the full pipeline with the `fedpydeseq2-download-data` command +If you want to run the pipeline directly, you can use the script which is available in the distribution: `fedpydeseq2-download-data` + + + +```bash +fedpydeseq2-download-data +``` + +By default, this script download the data in the `data/raw` directory at the root of the github repo. + +To change the location of the raw data download, add the following option: +```bash +fedpydeseq2-download-data --raw_data_output_path +``` + +If you only want the LUAD dataset, add the `--only_luad` flag. + +You can pass the `conda` activation path as an argument as well, for example: + +```bash +fedpydeseq2-download-data --raw_data_output_path --conda_activate_path /opt/miniconda/bin/activate +``` + + + + +If you encounter errors, we recommend you use the step by step protocol below. + +### A step by step run of the pipeline + + +To run the pipeline you will need to create a snakemake conda environment : +```bash +conda create -c conda-forge -c bioconda -n snakemake snakemake +conda activate snakemake +conda install -c conda-forge mamba +``` + +To launch the pipeline : +```bash +snakemake --cores all --resources download_concurrent=3 --use-conda +``` +- `--cores all` specifies to use all available cores for parallelization. +- `--resouces download_concurrent=3` means that only 3 download scripts can be run in parallel per physical host. A download script has to be run for each project in the config. It is limited due to some weird behavior of the recount3 R package, and because the download speed is the bottleneck for this rule. +- `--use-conda` means that each rule will use the corresponding conda env, as specified in [workflow/envs/](workflow/envs/). The envs will be created on the first pipeline run, which can take some time. + +### Options +See the [snakemake documentation](https://snakemake.readthedocs.io/en/stable/executing/cli.html) for all useful command line arguments. + +## Details on the `fedpydeseq2-download-data` script + +### Overview + +This script, `download_data.py`, is part of the `fedpydeseq2_datasets` package and is designed to download data using Snakemake workflows. It sets up a temporary environment, configures the necessary paths, and runs Snakemake to download the specified datasets. + +### Prerequisites + +- Python 3.7+ +- Conda +- Snakemake + +### Usage + +#### Command Line Arguments + +- `--only_luad`: Optional flag to download only the LUAD dataset. +- `--raw_data_output_path`: Optional argument to specify the path to the raw data output directory. +- `--conda_activate_path`: Optional argument to specify the path to the Conda activate script. + +#### Example Commands + +1. **Download all datasets**: + ```sh + fedpydeseq2-download-data + ``` + +2. **Download only the LUAD dataset**: + ```sh + fedpydeseq2-download-data --only_luad + ``` + +3. **Specify a custom raw data output path**: + ```sh + fedpydeseq2-download-data --raw_data_output_path /path/to/raw_data + ``` + +4. **Specify a custom Conda activate script path**: + ```sh + fedpydeseq2-download-data --conda_activate_path /path/to/conda_activate.sh + ``` + +### Script Details + + +#### `download_data` Function + +This function handles the main logic for downloading data. + +##### Parameters + +- `config_path`: The path to the configuration file. +- `download_data_directory`: The path to the download data directory. +- `raw_data_output_path`: The path to the raw data output directory. +- `snakemake_env_name`: The name of the Snakemake environment. +- `conda_activate_path`: The path to the Conda activate script (optional). + +#### `create_conda_env` Function + +This function creates a Conda environment based on the provided environment file. + +##### Parameters + +- `env_file`: The path to the environment file. +- `env_prefix`: The prefix (location) where the Conda environment will be created. + +#### `main` Function + +This function parses command line arguments and calls the `download_data` function with the appropriate parameters. + +### Configuration Files + +- `config/config.yaml`: General configuration file for downloading all datasets. +- `config/config_luad.yaml`: Configuration file for downloading only the LUAD dataset. + +### Example Workflow + +1. **Set up the environment**: + - The script creates a temporary directory and copies the specified download data directory to it. + - It reads the configuration file and updates it with the raw data output path. + +2. **Create Conda environment**: + - The script creates a Conda environment using the `snakemake_env.yaml` file. + +3. **Run Snakemake**: + - The script runs Snakemake to download the data, using the specified number of cores and resources. + +4. **Clean up**: + - The script removes the temporary directory after the download is complete. + +### Error Handling + +- The script prints an error message if any exception occurs during the execution. +- It ensures that the temporary directory is cleaned up even if an error occurs. + +### Notes + +- Ensure that Conda is installed and properly configured on your system. +- The script assumes that Snakemake is available in the Conda environment specified by `snakemake_env.yaml`. + + +## References + +The data downloaded here has mainly been obtained from TCGA and processed by the following +works. + +[1] Aran D, Sirota M, Butte AJ. + Systematic pan-cancer analysis of tumour purity. + Nat Commun. 2015 Dec 4;6:8971. + doi: 10.1038/ncomms9971. + Erratum in: Nat Commun. 2016 Feb 05;7:10707. + doi: 10.1038/ncomms10707. + PMID: 26634437; PMCID: PMC4671203. + + +[2] Jianfang Liu, Tara Lichtenberg, Katherine A. Hoadley, Laila M. Poisson, Alexander J. Lazar, Andrew D. Cherniack, Albert J. Kovatich, Christopher C. Benz, Douglas A. Levine, Adrian V. Lee, Larsson Omberg, Denise M. Wolf, Craig D. Shriver, Vesteinn Thorsson et al. + An Integrated TCGA Pan-Cancer Clinical Data Resource to Drive High-Quality Survival Outcome Analytics, + Cell, + Volume 173, Issue 2, 2018, Pages 400-416.e11, + ISSN 0092-8674, + + + +[3] Wilks C, Zheng SC, Chen FY, Charles R, Solomon B, Ling JP, Imada EL, + Zhang D, Joseph L, Leek JT, Jaffe AE, Nellore A, Collado-Torres L, + Hansen KD, Langmead B (2021). + "recount3: summaries and queries for + large-scale RNA-seq expression and splicing." + _Genome Biol_. + doi:10.1186/s13059-021-02533-6 + , + . diff --git a/fedpydeseq2_datasets/download_data/__init__.py b/fedpydeseq2_datasets/download_data/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/fedpydeseq2_datasets/download_data/assets/centers.csv b/fedpydeseq2_datasets/download_data/assets/centers.csv new file mode 100644 index 0000000..ad933b1 --- /dev/null +++ b/fedpydeseq2_datasets/download_data/assets/centers.csv @@ -0,0 +1,266 @@ +,TSS Code,Source Site,Country,State,Region +0,5,Indivumed,Germany,Other,Europe +1,18,Princess Margaret Hospital (Canada),Canada,Other,Canada +2,21,Fox Chase Cancer Center,USA,PA,Northeast +3,22,Mayo Clinic - Rochester,USA,MN,Midwest +4,2A,Memorial Sloan Kettering Cancer Center,USA,NY,Northeast +5,2J,Mayo Clinic,USA,MN,Midwest +6,2L,Technical University of Munich,Germany,Other,Europe +7,33,Johns Hopkins,USA,MD,South +8,34,University of Pittsburgh,USA,PA,Northeast +9,35,Cureline,USA,CA,West +10,37,Cureline,USA,CA,West +11,38,UNC,USA,NC,South +12,39,MSKCC,USA,NY,Northeast +13,3A,Moffitt Cancer Center,USA,FL,South +14,3C,Columbia University,USA,NY,Northeast +15,3E,Columbia University,USA,NY,Northeast +16,3L,Albert Einstein Medical Center,USA,PA,Northeast +17,3N,Greenville Health System,USA,SC,South +18,43,Christiana Healthcare,USA,DE,South +19,44,Christiana Healthcare,USA,DE,South +20,46,St. Joseph's Medical Center (MD),USA,MD,South +21,49,Johns Hopkins,USA,MD,South +22,4B,Mary Bird Perkins Cancer Center - Our Lady of the Lake,USA,LA,South +23,4H,"Proteogenex, Inc.",USA,CA,West +24,4L,"Proteogenex, Inc.",USA,CA,West +25,4N,Mary Bird Perkins Cancer Center - Our Lady of the Lake,USA,LA,South +26,4T,Duke University,USA,NC,South +27,50,University of Pittsburgh,USA,PA,Northeast +28,51,UNC,USA,NC,South +29,52,University of Miami,USA,FL,South +30,53,University of Miami,USA,FL,South +31,55,International Genomics Consortium,USA,AZ,West +32,56,International Genomics Consortium,USA,AZ,West +33,58,Thoraxklinik at University Hospital Heidelberg,Germany,Other,Europe +34,5L,University of Sao Paulo,Brazil,Other,Other +35,5M,University of Sao Paulo,Brazil,Other,Other +36,5T,Holy Cross,USA,FL,South +37,60,Roswell Park,USA,NY,Northeast +38,62,Thoraxklinik at University Hospital Heidelberg,Germany,Other,Europe +39,63,Ontario Institute for Cancer Research,Canada,Other,Canada +40,64,Fox Chase,USA,PA,Northeast +41,66,Indivumed,Germany,Other,Europe +42,67,St Joseph's Medical Center (MD),USA,MD,South +43,68,Washington University - Cleveland Clinic,USA,OH,Midwest +44,69,Washington University - Cleveland Clinic,USA,OH,Midwest +45,70,ILSBio,Canada,Other,Canada +46,71,ILSBio,Canada,Other,Canada +47,73,Roswell Park,USA,NY,Northeast +48,75,Ontario Institute for Cancer Research (OICR),Canada,Other,Canada +49,77,Prince Charles Hospital,Australia,Other,Other +50,78,Prince Charles Hospital,Australia,Other,Other +51,80,Ontario Institute for Cancer Research (OICR)/Ottawa,Canada,Other,Canada +52,83,CHI-Penrose Colorado,USA,CO,West +53,85,Asterand,USA,MI,Midwest +54,86,Asterand,USA,MI,Midwest +55,90,ABS - IUPUI,USA,IN,Midwest +56,91,ABS - IUPUI,USA,IN,Midwest +57,92,Washington University - St. Louis,USA,MO,Midwest +58,93,Washington University - St. Louis,USA,MO,Midwest +59,94,Washington University - Emory,USA,GA,South +60,95,Washington University - Emory,USA,GA,South +61,96,Washington University - NYU,USA,NY,Northeast +62,97,Washington University - NYU,USA,NY,Northeast +63,98,Washington University - Alabama,USA,AL,South +64,99,Washington University - Alabama,USA,AL,South +65,A1,UCSF,USA,CA,West +66,A2,Walter Reed,USA,WA,West +67,A6,Christiana Healthcare,USA,DE,South +68,A7,Christiana Healthcare,USA,DE,South +69,A8,Indivumed,Germany,Other,Europe +70,AA,Indivumed,Germany,Other,Europe +71,AC,International Genomics Consortium,USA,AZ,West +72,AD,International Genomics Consortium,USA,AZ,West +73,AF,Christiana Healthcare,USA,DE,South +74,AG,Indivumed,Germany,Other,Europe +75,AH,International Genomics Consortium,USA,AZ,West +76,AM,Cureline,USA,CA,West +77,AN,Cureline,USA,CA,West +78,AO,MSKCC,USA,NY,Northeast +79,AQ,UNC,USA,NC,South +80,AR,Mayo,USA,MN,Midwest +81,AU,St. Joseph's Medical Center-(MD),USA,MD,South +82,AY,UNC,USA,NC,South +83,AZ,University of Pittsburgh,USA,PA,Northeast +84,B6,Duke,USA,NC,South +85,BF,Cureline,USA,CA,West +86,BH,University of Pittsburgh,USA,PA,Northeast +87,BM,UNC,USA,NC,South +88,C8,ILSBio,Canada,Other,Canada +89,CA,ILSBio,Canada,Other,Canada +90,CH,Indivumed,Germany,Other,Europe +91,CI,University of Pittsburgh,USA,PA,Northeast +92,CK,Harvard,USA,MA,Northeast +93,CL,Harvard,USA,MA,Northeast +94,CM,MSKCC,USA,NY,Northeast +95,D3,MD Anderson,USA,TX,South +96,D5,Greater Poland Cancer Center,Poland,Other,Europe +97,D8,Greater Poland Cancer Center,Poland,Other,Europe +98,D9,Greater Poland Cancer Center,Poland,Other,Europe +99,DA,Yale,USA,CT,Northeast +100,DC,MSKCC,USA,NY,Northeast +101,DM,University Of Michigan,USA,MI,Midwest +102,DT,ILSBio,Canada,Other,Canada +103,DY,University Of Michigan,USA,MI,Midwest +104,E2,Roswell Park,USA,NY,Northeast +105,E9,Asterand,USA,MI,Midwest +106,EB,Asterand,USA,MI,Midwest +107,EE,University of Sydney,Australia,Other,Other +108,EF,Cureline,USA,CA,West +109,EI,Greater Poland Cancer Center,Poland,Other,Europe +110,EJ,University of Pittsburgh,USA,PA,Northeast +111,ER,University of Pittsburgh,USA,PA,Northeast +112,EW,University of Miami,USA,FL,South +113,F2,UNC,USA,NC,South +114,F4,Asterand,USA,MI,Midwest +115,F5,Asterand,USA,MI,Midwest +116,FB,Asterand,USA,MI,Midwest +117,FC,Asterand,USA,MI,Midwest +118,FR,University of North Carolina,USA,NC,South +119,FS,Essen,Germany,Other,Europe +120,FW,International Genomics Consortium,USA,AZ,West +121,G4,Roswell Park,USA,NY,Northeast +122,G5,Roswell Park,USA,NY,Northeast +123,G9,Roswell Park,USA,NY,Northeast +124,GF,ABS - IUPUI,USA,IN,Midwest +125,GI,ABS - IUPUI,USA,IN,Midwest +126,GM,MD Anderson,USA,TX,South +127,GN,Roswell,USA,NY,Northeast +128,H6,Christiana Healthcare,USA,DE,South +129,H8,ABS - IUPUI,USA,IN,Midwest +130,H9,ABS - IUPUI,USA,IN,Midwest +131,HC,International Genomics Consortium,USA,AZ,West +132,HI,Fox Chase,USA,PA,Northeast +133,HN,Ontario Institute for Cancer Research (OICR),Canada,Other,Canada +134,HR,Ontario Institute for Cancer Research (OICR),Canada,Other,Canada +135,HV,National Cancer Center Korea,Korea,Other,Other +136,HZ,International Genomics Consortium,USA,AZ,West +137,IB,Alberta Health Services,Canada,Other,Canada +138,IH,University of Miami,USA,FL,South +139,J1,ABS - Lahey Clinic,USA,MA,Northeast +140,J2,ABS - Lahey Clinic,USA,MA,Northeast +141,J4,ABS - Lahey Clinic,USA,MA,Northeast +142,JL,ABS - Research Metrics Pakistan,Pakistan,Other,Other +143,KK,MD Anderson Cancer Center,USA,TX,South +144,L1,Hartford,USA,CT,Northeast +145,L3,Gundersen Lutheran Health System,USA,WI,Midwest +146,L4,Gundersen Lutheran Health System,USA,WI,Midwest +147,L9,Candler,USA,GA,South +148,LA,Candler,USA,GA,South +149,LB,Candler,USA,GA,South +150,LD,Hartford Hospital,USA,CT,Northeast +151,LH,Hartford Hospital,USA,CT,Northeast +152,LL,Candler,USA,GA,South +153,LQ,Gundersen Lutheran Health System,USA,WI,Midwest +154,M7,University of North Carolina,USA,NC,South +155,M8,Ontario Institute for Cancer Research (OICR),Canada,Other,Canada +156,MF,University of Minnesota,USA,MN,Midwest +157,MG,BLN - Baylor,USA,TX,South +158,MN,BLN - Baylor,USA,TX,South +159,MP,Washington University - Mayo Clinic,USA,MN,Midwest +160,MS,University of Minnesota,USA,MN,Midwest +161,NC,Washington University - CHUV,Switzerland,Other,Europe +162,NH,Candler,USA,GA,South +163,NJ,Washington University - Rush University,USA,IL,Midwest +164,NK,Washington University - Rush University,USA,IL,Midwest +165,O1,Washington University - CALGB,USA,MO,South +166,O2,Washington University - CALGB,USA,MO,South +167,OD,Saint Mary's Health Care,Other,Other,Other +168,OE,Saint Mary's Health Care,Other,Other,Other +169,OK,Mount Sinai School of Medicine,USA,NY,Northeast +170,OL,University of Chicago,USA,IL,Midwest +171,PE,Fox Chase,USA,PA,Northeast +172,PL,Institute of Human Virology Nigeria,Nigeria,Other,Other +173,PZ,ABS - Lahey Clinic,USA,MA,Northeast +174,Q3,University of Oklahoma HSC,USA,OK,South +175,QB,Emory University,USA,GA,South +176,QG,BLN - Baylor,USA,TX,South +177,QL,University of Chicago,USA,IL,Midwest +178,QU,Harvard Beth Israel,USA,MA,Northeast +179,RB,Emory University,USA,GA,South +180,RL,St. Joseph's Hospital AZ,USA,AZ,West +181,RP,St. Joseph's Hospital AZ,USA,AZ,West +182,S2,Albert Einstein Medical Center,USA,PA,Northeast +183,S3,Albert Einstein Medical Center,USA,PA,Northeast +184,S4,University of Chicago,USA,IL,Midwest +185,SS,Medical College of Georgia,USA,GA,South +186,SU,Global Bioclinical-Moldova,Moldova,Other,Europe +187,T9,Molecular Response,USA,CA,West +188,TK,Global BioClinical - Georgia,USA,GA,South +189,TP,Maine Medical Center,USA,ME,Northeast +190,UL,Boston Medical Center,USA,MA,Northeast +191,US,Garvan Institute of Medical Research,Australia,Other,Other +192,UU,Mary Bird Perkins Cancer Center - Our Lady of the Lake,USA,LA,South +193,V1,University of California San Francisco,USA,CA,West +194,VP,Washington University,USA,MI,South +195,W3,John Wayne Cancer Center,USA,CA,West +196,W8,Greenville Health System,USA,SC,South +197,WE,Norfolk and Norwich Hospital,UK,Other,Europe +198,WS,University of Kansas,USA,KS,Midwest +199,WT,University of Kansas,USA,KS,Midwest +200,WW,Wake Forest University,USA,NC,South +201,X4,Institute for Medical Research,Other,Other,Other +202,XA,University of Minnesota,USA,MN,Midwest +203,XC,Albert Einstein Medical Center,USA,PA,Northeast +204,XD,Providence Portland Medical Center,USA,OR,West +205,XJ,University of Kansas,USA,KS,Midwest +206,XK,Mayo Clinic Arizona,USA,AZ,West +207,XN,University of Sao Paulo,Brazil,Other,Other +208,XQ,University of Sao Paulo,Brazil,Other,Other +209,XV,Capital Biosciences,USA,MD,South +210,XX,Spectrum Health,USA,MI,Midwest +211,Y6,University of Arizona,USA,AZ,West +212,YB,Spectrum Health,USA,MI,Midwest +213,YD,Spectrum Health,USA,MI,Midwest +214,YG,University of Puerto Rico,USA,PR,South +215,YL,PROCURE Biobank,Canada,Other,Canada +216,YY,Roswell Park,USA,NY,Northeast +217,Z2,IDI-IRCCS,Italy,Other,Europe +218,Z5,Cureline,USA,CA,West +219,Z7,John Wayne Cancer Center,USA,CA,West +220,DK,Memorial Sloan Kettering Cancer Center,USA,NY,Northeast +221,FD,BLN – University of Chicago,USA,IL,Midwest +222,UY,University of California San Francisco,USA,CA,West +223,4Z,Barretos Cancer Hospital,Brazil,Other,Other +224,XF,University of Southern California,USA,CA,West +225,YF,University of Puerto Rico ,USA,PR,South +226,G2,MD Anderson,USA,TX,South +227,ZF,University of Sheffield,UK,Other,Europe +228,HQ,Ontario Institute for Cancer Research,Canada,Other,Canada +229,H4,Medical College of Georgia,USA,GA,South +230,GV,BLN - Cleveland Clinic,USA,OH,Midwest +231,E7,Asterand,USA,MI,Midwest +232,PQ,University of Colorado Denver,USA,CO,West +233,C4,Indivumed,Germany,Other,Europe +234,GU,UT Southwestern Medical Center at Dallas,USA,TX,South +235,CU,UNC,USA,NC,South +236,BT,University of Pittsburgh,USA,PA,Northeast +237,CF,ILSBio,Canada,Other,Canada +238,BL,Christiana Healthcare,USA,DE,South +239,E5,Roswell Park,USA,NY,Northeast +240,GC,International Genomics Consortium,USA,AZ,West +241,K4,ABS - Lahey Clinic,USA,MA,Northeast +242,2F,Erasmus MC,Netherlands,Other,Europe +243,GD,ABS - IUPUI,USA,IN,Midwest +244,LC,Hartford,USA,CT,Northeast +245,SY,University Hospital Motol,Czech Republic,Other,Europe +246,5N,University Hospital Erlangen,Germany,Other,Europe +247,KQ,Cornell Medical College,USA,NY,Northeast +248,R3,CHI-Penrose Colorado,USA,CO,West +249,FJ,BLN - Baylor,USA,TX,South +250,S5,University of Oklahoma HSC,USA,OK,South +251,FT,BLN – University of Miami,USA,FL,South +252,YC,Spectrum Health,USA,MI,Midwest +253,LT,Gundersen Lutheran Health System,USA,WI,Midwest +254,MV,University of Minnesota,USA,MN,Midwest +255,6A,University of Kansas,USA,KS,Midwest +256,79,Ontario Institute for Cancer Research,Canada,Other,Canada +257,V7,Medical College of Georgia,USA,GA,South +258,RU,Northwestern University,USA,IL,Midwest +259,J9,Melbourne Health,Australia,Other,Other +260,YJ,Stanford University,USA,CA,West +261,ZG,University Medical Center Hamburg-Eppendorf,Germany,Other,Europe +262,KC,Cornell Medical College,USA,NY,Northeast +263,VN,NCI Urologic Oncology Branch,USA,MD,South +264,YH,Stanford University,USA,CA,West diff --git a/fedpydeseq2_datasets/download_data/assets/ncomms9971-s2.xlsx b/fedpydeseq2_datasets/download_data/assets/ncomms9971-s2.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..a0b13b48059c10ddf08b4a9b972b9a427f772ffa GIT binary patch literal 553082 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ℑKGs505I*`F@Cyw#xnq7;XqTt0FabAFAUq}X!* zxbmoYCaF!+s*txV-ElKQf)#p(RbJ=lm{qaQ!)>)EvRv7^VV%a$^U|%94p}%{+5vaP zk9lzXit>9ZRgPM{Jt96@!DRTZYU=CIf$!`aKUe%(g?G3C?6AH4fyybGQ0T_*Tl$YQ zx~!y2HOnon&!N(l$hHs+y`m0eM%z(jeu{5=`=!c3f*dqvaEE&T#ns^sAG><|lyNv$ zV2yU7yC^x?7%yYut?Dl^(fmW)d!VTV7B+gV!)B}LfZ!)kg0|W{+y|TFl!xy=kp1BO z6!&}FKcJFPBd^FuA+L{R=xDvWaxU7mDbH3vTjOWD$MWO9k`_Pji5rO1 z1YBiA7U0#ST&HpX8Uk_s9X#9hnZGB(nHI~0=Gqtt-crJwRKdj%q=w*!!Lxy-S3&wxbU=AMBw@PV=FDKtWN;ke&YtmEhHc9n5Ix-mh9u9;+ z{)thoo+$3wVxVG68b}5kr(p`?VDZ_?DJ65jjxw0_M@BjV1Y3XfIK;z21T4Q6z$?S% z$o}pi6!80qSv|7$lmj_Y!0+xD1 zj${NuR3m4la?Zv!LDs7X!~=ri@e}?-?mhh<#oMcwVW|uT_?oxK!t;Di0N$*TmTAF_hh0p<*vPZNMzh5|Acybj1lb z3#@WRr;AyCyd9_%GBs^r=geOWZJvu@V@s7ZjwCxHSN*3BjdSBuo>B%lfcsnctpqU8#D@y7{q-jZxc)nA`5Z1&%OAwaC@xMQ^95E z&lM%v3ySWmSF22mHAyH;I`Oy#b+Ogc8I&r&v_eb8b1$W0YZi08dHuIyH?jTV7DwCr z$uo014)P8dJF=AXR0?GB(eJ@ESK+J#@`H3gOL@pT`V+7<5Aoce5W+`?Lj+1WydV-T&`toW?(!{U#~Xswkq?;vXw7zc9ApptnudR=m$qc@+v2ax}<=Wh3Me z!$bRzt~{|dkg2)N>Abe%h>JN8wl}d*?|=zmzP<@(NLR8TzS$(r+GBCfiek!z|47l5 z--u$%skyy{;m~-mSp z$Wjr6CfwGFEvQ<~ZTJM_!JHWCGAE>e(>!+q-gN>o=py!^bqu1E*6aN`%xv|W!p`7n z>fk<^yRb*Co-*pOorbv;Ez^N$c!6A9Rj|wbXTS#8j?hxt%vW(6+Q94G&AQck7zt+S zK_*=~GN`0Qrm(X1D#Y0tFaeR*Z911zNgF*GtXtL)H;_nD~-|rsK$=~DLNFhGa(+aZtePY zaHw5qoZBh-{x=XSSgcFns$qbgfjaIV-u#rgDX9d=B~!*3xaHoRrhVx^$AV4SfM?pr zAtE%kzx?tokej&(?)6VQ)*k6f%)dnxMTF_@b8C#}UrnvJ#1{u79$!(?W|Go(r7)u- z%OLH#ghTL>2_6pEc5;iMs%11KsG*3G6M$b@R)4ieZ$Xh3EbS1XjYPcTL-`TkG9*>g z)cHU??kMvKF`~=ou|L^EjVC~o05lyq-Stz}Gx~xAaNwoajM>s1Ijt$SRp*CK487)n zPVxD{oDY_7!J)kEAL|@YSNy}o?-SJn=3x`|y+WLIyZ+NT0#)?q zbO%dKHPas_vPKs#nTjtx8*bfF9i0#ZB!hx43I_w8QO3DMgHeT3JPa_r{Vg+V2(T3^ z?tE0tYOH1me>P~qKzm)w+)}@ysp;#e$OY^#`2shF3jLfX#A4m|KGj(zc*}Fkq!h{3 z<ZSJF+vW+09E+l6^x|<#^2PS}M^4-sel=Zy&%7>$t`|pqGjZu(VO-Q;-ZO z3KZEtv{>uV`^J0<*k-}VS$6e8!mirOzQ+%yQx7P5^JQ<}n6W62X1DH?eFrEB7BKRj ze$ytS`uY0x^6R94sob?D12yns2^}@>m?8<*I8Zv+1`C{+`+t&J<7ZOx?5{wlQD^10 zsfC0t!ym<`C~Wn|^#FxAsIgheq1J~x(qCZU~UKx;FGIqTCK z8hh;i2LM}AfU7LAR~MV>waT=;C&)7gh)gT>N~-)CYy|}EB0amb!6@1beDzP5&DMQg zfsZ%k50I<8hxJ|wRqSSK=V7TfdS_)iwxcUQ%|q_>Vtz?KW!xR&ynGupJg5JP1)rhIR6zs~54@2Ej#x(V{)A`_|Q?qG7DSA00nr-C|Hf6V8hJ!uX&YGSU zcepwCy$0k6*_(>X*g{5W0|pK~=U@|i$^u;Nv8nvUy=;H*2THZxd{}VL7tIgf{V8E$gv;@~eIbA)- z<;bbZPYhw78opPp*C0*#`Rr5htf#=N|9MG5-?_qNfq~jf=7D^J;py`S+8Qi>ruI4g zyh2^~3U2D*t3d2C&gd%kt*6`LZ(e?Jt&`pWiy|9A45doXR6h%fpUPh=EaDZ#tEQr8 zDGLv`@6D{S9UO@D0QB_8mslwW%H#8pnPCBpWD;%z3x+%km&@J@IRmN&hKXgstgn$hBgmLfj^i7&T`LNz|N;G;8x1_eGRSX5gMA3#u}y+Z&gph z(+Q_*Zvk75kd@rV{EcwarnyHcp1vAH`F~1TYL|*bwDfBYe2-(GltinNXJjo7aAF+M zm`3_Au;9alBv!WB-iclc?47%0+$QTPAO5GK28y%PO5NbAkJ#sMkLnr>Fh&;SN=)Vu z_5H=ESYwopu#5;s_)Zf=d*Sb2A|b-p{`}avUm0M)*T6E;1UrU{))L)VCmA4Sn}spr zF!2frUg9rnf#t9y13V5aRJp(<`L$A|FG-F4v z-%#Y3Bq}MQS%AZ1&^NfeIHAzg?xwbfY$W(y3DGMueof^laihJ2~*bdJo?~+pPEef&F1bo8)9aDn`Z0Hz0JxwQh>0$kkM3q z9)=G;lFT}5R$wy+Ao$@U+pJI#15u_Y5PBv&`PahGd)~n1h zTIw^v|NG^%a@maBf4Q8IzkWzduLZPB2t$b}0R+VIC~5el=CN>Asmo|V&|Lj^-}#rn z7y9}_KI9LyY}vQj$)-a-U(E^SOT1qeb|ULb_ZL^1iyqH6(3&n`E4_*sra?V@G^8o` z9tZjG^_@o8)Mu-1oRrU%XU8%(C!>PPe)jqWu zkrP-FI!WQijH{sHap~0buw$Q?*d#JsRaSa^2i8FI8e$6-h6F@+w1bjVph&A7NJeGI zq)>5PQWj<_ifCy$F;-E;IUl8~*)okt{99i_%x^Gk%%b1s5z^W%UlT)I0E|&+JK0JU z2$#3VP@6mIBD_@N<2C7`>SajqG>>T~bywYKpjVZuNvIg@XZuENIiV0OXVpwur?bHW z3H4Rx89%n(rdw#lTVSk;v z)k!_q#^-tuct94>M3OKQ*?!^@So22qY!JO#526nh^WkJ8_IEZ4)Qg$Yx8)YRNKp3@ zXR?LU8=CCT|27rid{%+Vp=LBRpj|!Ah`|K6(TdS>W7NM(tg%TH;~MWmY-}gf--XS0 zBniUb;@ZEyGbOXVTx{7{C#$v9E??G&uX4DSul3c%pB>`FT0F8?L zDXKn0gy$tg=W23)p@ zzHf-N*Lx+QTKD&2uy$GdY(>ayi?v77t=)mxi_XOes&!tjJjc5?vG#dmW4AHw3X6Gm z&dR<0U$IAV&0q~?mq;)6;-Ki5ByuqCmngJOLp86S%V@#uA`GP1NcM^MdwwJzs0e5N z1e7M=%>BTIoSw#n=GSjNkwne1b@w`${c+aC*g(`(6VAO}YGg-0TVp9v1XDy z|A=VKzy}{*+R^Z$Vxan__co*tz*_4rI@iL)zz^c?*LNAnlKGsxUrrOZfHE`jR*tLk zLnkV_Hi@YxQX3_Ux)6^~_cfeN_qu$3iv(O}XZB;8W#0cPFKZE~?2C?oVRc*pg{PRX z-0{bGkmJ?lyMc$6&lxXRxjn2j`{FaJB^(F*C7=dAV(!zL=pY!UB%4Tm>;jv>gpo@E zf$TW5=qQq$hC!Xq|6VOdKL#T`%k;MX*{Gv2{koCi;_pTSzd}WcJql}UWMGCTSP>?$ z{+3Kf2d{kG$?}fjDI?zQZ%S;j0~X z9NUmr1B}+7r$QA<0UwJ@32@>5Y2%kdX{Lwt3QZd%#VmL5lB2g~BAKArNJLoFVs@Ivel;ljVcF-P8ovd|VPU5giQ z*>WP`t6!#5i$C_}H{{N$BOdI`rqladZ%AH?5-W-9)D|yg2cJv$J0;O)8Sh^Wh7zqs za{pL*@Ej2<`a=4b;MzVBe*;Dr>RG0=$Rj@dJ`h#o(49G}Td~@1u<>z%N5H|cm6>r8 z`BM823_D7fwn+0{S7uc1LG-TOPXO&*7NxUS+Z{DHnyu<1zC}E8<@k`oPwimDjbk4W zU!UpVxoyOaY^sQYy~7!y$y{xsU}nDY>dx$TE_dmhjD`<^gzznVAYn4VI&ZFOC%N=# zn(IEG4jF8S3A|Qw97u0nsE3F|es6J&s}2J~&v1wQOckGrp;qsYw)5A-gX9`+`8u3X zqkeg+C%-%R4X?`qaZ=45W0rC2LXE>><~vqQ2>>64c&vL(baUIg$J>M5b9vMcT}}>v z{d$l5(tzm%MlD`4H2Tb>vvx?b9goTzQJT;W7j&v@0;rp5XGhMU@&Ukaf<5lBI77YX z^*-&68Fd;&<~=j9@)Y9-CUHmt9hHj>pU&G;v-${7t|} zD-!l00SzS;V5#!U%ZXujTVCODdRD)-lcs(gq;~>1!yO**reAoe zmSbw5uQTht3wsiZwXV#lAa2|cJ(!b2yLkhA0(%8(Ew)!;h3KSD=O;+CY)%H0-mO?F z?oVi`^AT)X)aD1lJ z3Mz*b&btfIfBxI|Nh&Z@Fkhk-n2**u=4w)o#aITGtiiR&upZB%4a|Yr7$SIlJaQ~r zg1_)~HG5OckR23x{@@BIFASohz>4n;^7epvIe&D)3XG4jO7)D8@=(W6BZGi^6)vtM zg~G=EpgpTYBg{GV_1x#RCq(gN4R6^JT8l~R%zI1QFukw>Bq&@{H&cCB?bfy5~!CJ`_pDZboKlM4>cv8Pvza&!_-C{m@QQseK zi`IHaK-oa^8ARz`s3w9(O;2w;6kLomFe}qX(4Zc<{^pqz#S-Tc!W}zW!2V*aRK;`u zt@>tsRLJ~TIA@bX9+Hu^^J8Z%xReZ*>T6sWU-HH_UyvBQ<*Q(kw=fy5^`Y2)t~VJ; zE_IbarXi^GjCPSV?YpHOglVQ`&uSIfa|bo8UWoiM=^Oq2Ge)&!wxLo&AK+C1Moc#M zU|^B=z%hU~un1Qd4XsMK#4wrXCS_Zt)tD8sX zS=gGDY4?EP0ZdU96b=lqgJgb9h_*Fvk$s4UR6TjnFDjq#4B>hEy4uvnkqf8V>Su+u zgBchYnje^o{rgNCHa;_}NpE~D*i9VITi%*Kcd13d2}Qd3eAyEW`9ljgsFPQVkG!uP zXf9i%Q@A-9`poBU4-FhjskZg)s(Aaa3^&iQ_zR!OueFqc@t7bX9iHdG-4E_btp!KX zK42Z%X>BcD@>)zcJbR>5q7XBP)lc>N=!)u41mA@viQHMXLuO+^0E`5k1Y}e-W6b4@ zf*loz2w?Llszm3nB!#?w%Y(Sh)W{z&Ut|S%z3)5wyVK?}V9etE+?Y5+;*g&&APNSa zF-U3c+ds7WC7v%znjbs@dEVwZ6M{%<6|+!x1S6q)AUEd1dqt8Xr0z0kRQ$U~AX3>i zW*wAH1_b&Xj%47u+vXYYvzjUWE`7MkKIKr3`h4UQ*0ZQXzshQyzNQ!725-;323_E5 zLPMDx82ZoXkD4Q0&Tpm`Y{6D1ESjIdk&j$iB{ViuGE?^Vw)owL?)~Cji!KV~&<+e0 zG;q_+0O&#+C8v#SYdY5_@-|o#G8Qab&e~Zb6PNc__xyM z@PXFUmniCR)wJe3xH?rn(Eco;%+zko*b4stN7Hu)vh}_H8$s+KM$L%5O6^r6R#3#= zMT?>+s!B@{u}35JPRwX)lp1Z-R$J{Ftx}_umZGgu{I2)s`}_aio11%{^E|KT^?IFi z?w}C1I67y_nXlXk^9EyEZ;X@!YLK=m5CtA~=`fq0qBFVIQhMWT5O$!mlX1*su|LET zui9IL$UOYWkeDG;Gey;pV-o83(v*Zy56?{R=I#Sth|l8oDFM$n`S%emo<0Pi%Slyw zY2bvx9s(zQP*0gevYCL8z=tlAj_|h)wmx=bTF9Uoy`_(%pRf`s|HCVnmj+Jdf5>?I ztZ!-G@@IQ!;n8&?W<-CIR788Ywr}P?*DsC#=+7$no4yI>ld+60?2|YPR!z894`Ot= z;*CEVdM2}V0vOydTX?L8rP`+@revk}{pv$IBvQUNR@=_Y&d?51#isDU#u7laX^EZhUV2?nho+r5l{HNr>qUGOqLr0h?~iYao6TkC}Kh zG)+DH2N)zhh1P*Mz_Q;`wB-50 zxVSxV=*==T)$uL{nLEzTOuYeun>SprnXYm57aoB^mfbUzW3q~3B&C0-+p#B58r)XH14Tlau9Vk1di6^B(NJPP4Nb<75{7B z#vsbuX9LZdc^(Gmh{Tnan?+Vy=PG`-5_g6oKxc<(|Bn8?e2hv1pS6tTzWbaSa@tWf zStt?wN*_oHPfFkamHEMM^{rA`zHCimRMu!e?}G~)Z~K`G41jfYy^&(x_j*zbQv1f8{x+;SKxu&)?X&yLzvJAc zBkZv@n{G$mQ(W`n*B0`q3bXyaEIvh{y50^C@66z?bF~}cSB3_jcJ!(CQkx}nJbT05 zl8S2j0FFIc3(Ovobv(%PFrWOQL}i%k?~6@sZ#&l4xF&DpW30_AT;>7Bd&hVL8dkOK~75Xqb8DwdBjWEQJHlE&!k1Z4eC=RAk<$Y-wjvw{*^0r+c zub)}g3IJ_AiNy~&n9d`gdQOL^6r2OKZg=oEp7uA)j(BZBBgJUB8!d02=&Jqfh;zS+ zo-jbWLsAPYn?7L6k6w*9E0SvCghoNYfE8Mydt1?hMh{|QFW>26!$Chu^>?fHw?CZ1%V&DNd?Qo?-PteX_>gd z309{m$W23itFPVu8@+mfRD4&9S@?Xrk6zelVVsH0ZKcTh*EP;k;JoY`88wyL=er&% zJX$4pe&a$e#BZ=>TgKPmVg8hQq*}yIqyf7r zIgUi^?eX_asE{_4Vz?o}#Gl|-d0dn~3v7-0X$9`_o{h~dK{DY*`4hDLQyzE;grDlO z>E3kQD|>-#2d&W^v(V7$5Z^S?OyY#DmXK~MquirgT9QWqLxipnHT|f({5&1I^`~~a z=MBwA7_HxjQL*mNM6~Ch4OY$WgpOGd&8x^hIn&@ClwE+uU^mFvyik-oU~=GnaNp^I zN=P6YD|fOUkPCx;{(aktF>5b&d^(N{WK{n^^vA&RtprKYYIlFMea+^o_`Ww9OS4pe z&5>uZKGtRW`ppb7=z>c4oUw_YgcdcI?eB@5tmp=O1+I$Pvk4v*q-8AU%)-`6lVndO z>Yn+dLO%(j|D0a4iByTe6lu$d6z!G}o>%^`d^!q#>fL)D1eryWXZzmpbgr+a^kF}L zYUqsqNm}K!C+vj{pdGJuP7Xj^b%52vVmU88wC#mfSQchsD)<-a3)GDK&8}`6ShqLM zz067H&gnvB=dURCXnp=ry@8zd^f5g+_b~R|ko0;c_z;o0Kncnq&*wBO4k(CgyLnBW z)Nl`3L!N*N3V1{caG+X(y1UAzwokSQNdxdjsO(j%{O?rHHLNslWDO|B+FHt52YKCm zDJU;>Gs5q|Kjt~LS}w_mtqBGB3}5w{3ndNO zPj1>v1i6EeP19^ENTCOE3w|N(Eo|?Ks~hWdV@tX4H5t+h^jQ=hSs*jwOG1#Ay#NJt zjA153`NK)?s!QNNni0elSp6_?OC3en)RQ0ZE`dae&%((Z*|J|dPrbLe^%HFV@xNyz)J zlui{6-|?8DAEq7q#$O`Qv?#>XGc7yniMKMi1~Gt2@OmMbfu4^WB27)*F;h}=@js&! zpTQZfhzk-Py3f?UoOJ+M5$A17AZ}DB#bstq9gi+|p)RP8FOgejeqcLT(_7hV`{nes zIsZZ1%G-&gq$V&CHT6`g+g9|=e3}X8H7mA5YaFu6S7$w{-P5NkGT&oVvdi{aMHM%=zvXcU)|Zk z``USmc9*s7EKB9&QQXxts!WRMlSbjh0V%NIXz%&KGFel=u4?kv(EcSF3U<8b70(7p zlK<{S@6#Z^@x+%EarwpD%@^N_pOti;b_V{2^F<~2qUH{8@zaMRA0J6%bBcR^d-m%? z+{WX(6UhZzg6D?Ryh84yW6d0*wB1P~Hz+c*-M)+OQ)ezGWV6Bz;_=h@s-mxA1p3*$ zqIAHGkEM5!Oh0MsUMg)X!PvN2tMkPnD#OLBU24z5$+e1?Vziv%R|u{)66h+cedWtL?zWW6QA&H>@XA+%#{txt^o?}U&^>d<30>Yr z)rdxY9S?1z^wH|~Oa%p66+ z2XKSAkOXu@(WP4QJ|Y(S^7>B_s-cr@wd&^8PISBhQyGoBcP6W}vvuGc&d4NM7iU6P zPm39#;)a_{^L&}LRT_9|j8ar2PZ_Pv;T->|h5r8xY-g%JQVk$jA6bwTYng8p1tE=%E0qOiZ z!zA>EOyP{59kR1$Mbd?isFKjTbA7tiL9zMJIGt1c91KeHQaoK z2tFa{zRLC<+TLhZIM-+O=JE3Miuf+iQhI5RnniG~`mfNF46v>(4Cd5~yDC#AU zR@Ot3ka7}N0~!(}Z;c7Zuh)eSLbW03I@NDlN6lJ8v&?uH{=|_#JcUN(8+`fa`=GtJ z*Kq;0tmW1pjZ-tNp858CC)2F~ACJqXW>pkX#>ZQpJvUa=(if{+C$;`OI{gPdxnVZ_WN$wyZj6^w{9hJTkJ%^XZuz-&<|w z(?&DOK{V9JUwC>BRvqq#E+6vCCGAOrB6pAzr_1Pt$`b3#f4ghwDU@rm%4eGnyz4@& z@%Ag36Js~c8aB8SKa30O3F4_rFC4GalNNfKpk`9`qFuah73dXT$pK3d3GR*v^5F95aZ&|n zSP6U6D?`$eG^i`qi1#z(UBm6GWN?M|Lq_$k&qz`08Ohi;UD^yznEWyIXpkNiA1N8D zPc!>$0z3ayq0st$@gC48pWgDItGRx;R>v4aw}*<~bH(`O?~v2Y)UxV+EW;+8?uScb$OV`p2TreUPFd`Q@7Wc$afE*9!9&pO9+ z(ixr8tPEQp7!`JQzyIdB^;f&IMYzKP0~~oBFmbE*p-=wff90T-rwJ@;)3Umq!@?ri zU_+U0Q`kOrx@)k==;}BVp;F|O6b?OJg2TY+&2$hHnlY2&eXw4PYZtGO67z_UUO-aJ z=kAe2%w6%j2@U2kmRO3DNm{Vzo0Y}v6Yg8eWK2E_7z%jirvSQ2ML`Anbc(FZUZl(- zL*OtsB54o5;==@2jRxWJS2c(JP{ax>h^hi5airpHyg z-~MXkfxl(V=(Z?vhmqBX{2C*W>j^_O7VAf*{=^ zByawZjJYh8U45q%pXF7$^YZw1+vDkn4YGxU=`F=jq@x64 zikJxLZfzDkEjMjgSIvi|b0cN8u?gW(f(?Qzju8Gwv%6+ag2%TCYd>h$# zxbQ0Eq8wB((%_e+NQb8&&2j>Uf#exi5{p)ObZgU1V0Yx--2NoGCLK5aJx{<=zJuSI zpiUS^M#f%&f9e&{$&$K;WW!iZ!U^vIILe=Th-}GFt<&?p&8po9L@T&z`2A~+ImX)y$V-%hzyy_jFg#}PhQC_Qm zDnBLwL5N~=vc`#ay|6jF%%L=Sf^Ql+5=F8vYrW;n{>eyZUm^AAPjUY4%KP-Q_C*9T zPL(%C6*&OJvsh;lcgH>CZhk@ka;ek$S%vS$UF|e(lcx_!`|j*tIf8h z)X>^UsAOLj$>-el3j;Nn;Q_(se4!`{sRyV5MAuIb-uweHsE-4YOf++OAoG=nN+jD2 z8w<%UU-I>+LC?yHjHS4{MWmttoQPFF+^^+Z`6k*CYBW99aRi>Y^2Jim%y&rg=(+nN z#O<=9Mu*UT(#X_9qq(T`JINXz&ng%|d17rkWEQmrAas7w%$?h_i(ef%tFDDuIVAZj z!JdUD@ffm2+~qPw(f)03+@zo1{F6wfP-Ju42L)o;_syEAHt?;^6NU+Tu#Bie{)19C zjzTOFJd)XOi4`2vls=xk2ia$z_;C{g7wjT>Wq%l?OQewaY@xdTM9cVdFzYb}bfyG%g=Dbyzfg$R0I`|w!kz6^?u+qyx4fZ$<|vdCKp(S-36A9?E!AN{G$eoR`z(Z=lR~63kxph4PKx!&apHQ>(GV1XF7E~E56MAdj}&^O{fHKnY!6CPIVpB)9@Gjl>wKSiF)khI$2 zSDtj@-~e2UkXlqn)zXVx^>N(dmsEHN+(N~S+))`OI+#W4G`U-Z8qEEYUS46$yuz;a zL9EMfyJ0cC%=KqIo&c2BOSqyAz!m7%9`7*BDv|8v zd_?!3i=9WqwZM2!Kfq~y(yZ@K0n*&?UfW!Y)nuS+S34?hG+u)-yX@5lDQ#(@ye=!H zW5qJ5wMLg#5Y^KxktsH2_)2;SMYP(qkt*Gb?v1SvHb2+hsydvzqcA#+a#kDQ#%rm{ zK-xv{&vA2FWCL5B{+wbijLtvzrH1+l&0=;Xm6gf;maZ!ASwEr9Rp~(+8|4d5&$$xm z025m7=eNR7Tb4)wSoc=F6D9Ey9TiQ%xO&S+;}B}UAaBLy#C#n89qR35vBn}kxUsZG ztLqpUO{4H5sINFl`}+vP^&&dh#F)v$N5d54W+o%}@wUyJx5EK%T=NGEt+a=}7HR{S zSvTabvWq+Ad_D;KOlVuR?T!JBtDW%}9T^kOgHq-on_@;+xRge>EFTWw{`o}>lew@c z63Fxpx3T!Olqdvrhg-q}Ipl~i4Aky%>rxO(XMX1UaxLnvetYTSTS|pS5I2(c45rZ* z4d200JJvs7$VJ@;*FjgZs$vKaj^OT_7Bg@U?&}q z%DT`|DWY9Qlu?!$5vz6c_rkyZ*#3L2^O9#{O>B3YnD2H!WE;UBzum6{xfoh~w7Wj^ z3CrUJ|MlS_=gR7i^*RfUwiMq`tSp|1!bg$0E-M&nS6?IR*yZAWZmH#ggTlL(Wf`#)$%VX>>(gj|SK0p^V$=Y_uG= zb-Y3z60?F~rT9QPa_ACM{+%e+zs;0b>&PyG537> z;I;iDy<^|islfJExHtsci1rhE zR)r1jdMMk!rE=-INm{?_$JF7m`F75+eigP?E^h>Bv$Ec0Mgboz3x-qPtxTi*iy!}R zM3Uh1(T4&e8Tv{sH~*W`XVo#HpO&OuRXGpZ{s(OoaWRht(si1xo$^zAl>2!V2oJa- zL?u6d0}Ck^U9D4Sqy(V7N;)O+Q4GDP7LfWtlkHNp3r|SsO}6P#z@LEHjiZ@1Kthql zEVN^ZPMWN-pkFFCv@S;({hO!I3aG{yOxkfd;5jnnLtUBPZNU#~^aCk_cN=2<~P&e3CYcYOo3{ zv$Ov}GPGASxiZ|vwmAhLwJtK(w7qWXR9N&-vs!3`+t=g6bz}1*tkd;_zX55zCMzrv z%U@r+qw-bQ5TYW#JB~ zJez(bBxUWIh+;pkz*$sw?`B6KycTxI=$dd0}^*V)GQ=%FDl5j2h|cD7GYI(M|jxOEgDYn-ITf>;VcmMAmt?KZ;~S~Np!vP z!9c9g3E%-q|~TZyk0p!hQ!T>^R(aQRQHY5$i2Wef@l zXy!eWU!$)GqP~gYm3}u2_hL4bY2bXQgkFt!(Q?lN`f9<)dpp}oOMZb>Lp0~mi7jW- zmzUH9J{`vmzQh76CNfz4uY%aUdEbHIE3%_cXMa7Q9VCyg3%cbv9F3f=R3t$n141g^ zr#N-cVJTuV1+`_Kvqr#TX3kgj)_%NhuOUj3@-yuiP?zI=vP*_?$TeJxR67V;+&@lf ztdLc69S0`ppb1)DNM)VViu=WYxDwG7Y6r^B&lo(YbTXY z`?mZy#A!Fg!k)M`M_bshfQ+!3BZc1^XWgR^qg~bj(L=!|Ul@%*W{cI*$5I?*hHJ|# zqKM@Ii0HN5^IE1}RdOhC{-IbolMSRDLeUhc#V3YbsYvs6%l^T? z0TOMJ9+dp5rX~jL8F-sXwK4RD`KGc^tF5lGO@kiSImLYDKlRIJ3j)t}XKXYtZmp5i z;+Ho80kA>1Z?6$nocvw>083_tIH=pX)uk?^$vC2DB`#Ko;+N|6u8Q%<%Ku?Zs;-|| z@vN*H-A^pv_`++^@}lQ>)j;mP#GlANJogqwP4PK>lNQZQ8$@b8lddE;p0!$VhS!-Kl|0-9t*As;kwi zR+gfF5p>Fyf0Mef4B)Q7l+RMhX)>MmmMSS1>7s!-5oq+DH+LpU!yjH!3AX3m?;YM= zI5bl2VR#CHs7>ygoT%Oic=f7$qo5sr!$8)R?S*B~5uTJj*9a`)iu@NKmFMfT24>>$ z`P2W<8zB9t(glGfb19Lj4PQnX|6Ud~ zyS+X7Agk!NI_kju7{h;a#FQ?E z7&sk!{GjYXXB$!S<@(83y;ttS-jI2|(S{!h<59gi`X{Y%`BxiW_$qqnq-LA;r`U1q zcf5?-r&K_WDfoOLmLA?sABpMki!2 z5}RN@r~7FAt_`L#0=JnH6X9J%pH)8$S2!ArFGXL>Z+ zqHZzlg(deQHX=y~xOoP|bX0Qw_Ybp`B^Et=jAHPYA9lpDegQ2YK$4;c{`td%vX1RP zlF}$dJRk!MUTHM6yjQEtDcX^Cy)r9dA<-rr(+3b| zLb&aI2Jj?u)@MjhQE0;7&H1rV5oF93X={d|M ze^o7uq?B~j8Gz`q>JZ?_XPqR!ERwA0X``si>A*}u&w7Bw*!g^oJJS4-<$on!-%4B! zWA7&uen|zRS#QdlJYAu+B5nn86M>>DF1g8dCn~x$`LinatX`}UM#N2C<~k~nLJ(wy zOKSdheHbanfbjJIa=>;N55RdPgR-QKC+V*%I5>;Sg7oC;fIdCrKFH%$av{A79${i8 z`hN`bj!SEmx#OAb7Hzw=uo#2v{0 zCLQ`;AV68CA+H9e@Jt84BGs)aC+|Y{zl;I)&na{KQ_7TJ1m0$wY&-_DTLY^yGnuv= z#UT;5P;y0o?5P5X4}!VvYFSc8irtkY%b5z;Y1zc*)5nW97_wl%+&JQq7Mcz&AqPtB zP8W;d2rZj>G5d7e*#j~AdXymNGvmb9is5CKoIZK_Exo0`_D6jdh*5qo3rvDQ`bSD? zu=)J}Xi@-c{3}6`c9kJ?I(!Nh+uO|x1JWn+WZ&O--u~^W*!(A=d}+XEN$W=QhP^Db zI86I+urcTZAX3o=T5Aqpee(alil%OZmc79Uv$}x%kLW9aNmrFlQn^!WVyydRg+l(< z^*X5Ghmjl;Jpg z%xfpKB3R}*y>351lZIk7!Z}~WP6W~vu){PGV|>Ucc>84hwMEsyvqn;DKt>KZpMn+syCagx#}{kGs~kqXwRAR0 zuE8DC-P2M}NR+)EHJKu%xJPHSd{dTpc(4IhfQ$MM*-!y2$4}>_U&r^4*F(qUh+BN| z-EyMc1g^wxPf)S8370esF?j5|Wmszbox_onkQjn|#Gjk`^~00!sLdZ4<0G=c69rjx zivTE=7Wg4zhrlR=tZdW?3CUj{KP!(&N#!mcpuU5Z+^lxz|4;h9p1PwG`dawL$a{9I zm9ZjUyW*C#>p(pJ-SV)Whd!K}BtpJ0v%n(ND^U7OitAaDz@TWU;H%OBdwKS*!hMA0 zyq=m7O%yJs*!|<@uc9QSo*}39TqLC+TW0X8i6}ju!anPhzSJ8xI1hGaL>EJj5^89( zzq70`WAT?0XW|Y|Kcj9WM-jcxK`7C#cUPDJr_&y>@2Yd$I2BNRkgG(z7IN`Kp5{ZcbTiM;K0;^9C0UP%8uFyNe z5a_KH+62s|^VDHJ6AWSEC>{+K8Zeipw?7#`cNitXbNv#y_iV*Vdb*Arj0>PzfGiWX zZ_X!t_~fdWMm@d?7X+?!c*?lxEy#;7O?fkPtfF;9QoT0Ow_QzLDU#7k$x9rsOoaj( z@x2gtYBMg%adfNERp7BCJdlqA+87DXwQEXTh`&hB>a0#BgnNJ7NOBZdVN@ML02w;m z_ZI^r`Q?LVeq6kE`);tP(Rq>-?z)?v5B`!kkg(7i;h+7aI%iki{M(k@`2z7_&hep1z0yzP^g7b9I;YG z4?~QSrbFI&lbG6#8nWqHTd)$|#|@C0ONk{P?!8n|Da1@qn4OR_Ck0gMi^kXZM`7|6 zD?lX}Nrfjb>{Bg}dRKv5(Of?XSp%ML4sN?lF`h0}SNL315QL=SW;iZ4??*hM) z1{Sg%KjYl6oCHWrFu68BBu9=8y?7uqfDnEF@gbMpX`I}u;m=SiYXebXH2803FNl=iDwUIKv4 zgS6BIY?=N{t<5h;l4iQb@h~Md-^utsHG8jB-zz^t3&G?7C&0@}w8irk{2r@f9N0@+e~2P7BDRfimh5ebaLHb;-)k zS1b|&$eVUJu3(~~XXquo5|(}wu9M0k*_cxil)imE;2&1rz$=OhZEb>28AywGIHe3uWHiv zmQ>F#jaGs`81(fzs>~iIBPZnRpIBg8oV))9`O@L?LYDyd=7{*8DEE?3|9y7B*4>)- z*YC>02$f$Ber3U(V6E)Y9hOsVR}#k6Z{BoolY@BHhUKX1)K6>8eam+|c7gm9d9eSJ zefqF*5D?JZIX_3h3`c>k5c6>-NFE;F1IugCep#CnO4CRWcor&YRCsa9gDj2o-2X}) z8XiR%%>ho)!5zpQT7??QR!X4|78mM7N*d*b`WI*-SX4h>#vTCBu`eLr>ffDyt<&JG zjCnHa%ba=yI5&*FzLStajrM$n$TK@RMdd{L?nsd(y;j!(ifHC?v~q-#`L*wKD1i1K zN`q?Evwayv4xVAyXV+U&;Bt(8BAH~mUk7FYxCKL>z1uQ2Yy`o8Yjx*d-(0swh9p?V z<^OQ)x9Piw?DFo4{JAMxce}(?oU8o^{iTf7Fc~ zrM)EKMPYNMd4S`G>M0SBUEHXS?>#GGpizi_tvx~i;*CXXA@RGoqeGduzwZU3MpCw# zIM5U)I_b6k)UtC`TvM6S44i#4J&mGPdz!IuP5AKLd{``n-?mvgOw1fiA5TG@Wu;pW z?Q==DTw`Had(sMe_3)kS9B}MG(%RJrl72ioAFI8`l4~vZkE$e)&3yrOdniK%cE$8eI`VA&+X= zFG^XJr@QAHzKKQx)(@Sf)1UL+rmqaa$G_-Ra)AUE1Q2;ArJMQUCe!+VqlSd5eDs_HDUV`6z zbS$!XSLGXhB0!?4>&Yx)iO?Vf8nm}?)2ZwL`d#VX_4r?vdBgc#Aeh&;&5X_IwxtgZ zZ554NS80R96O&z=S1bVPinjXene$S_p~=cfapujD#Q&OxB<_PdDxp+D%Hu-e0g2t{ zT%$jNxqhNnswxDCJX6(IVDFVQlP>}@=8>`R)J@U)q}yNc!jmO~-?Kl9a1W zU9L~Hw9ndcro*|M`3_WHy=%(e(hUC|PHM(=WUfD&sml!t9#vs;vYO=RdZEY^TsApK zO^NH`y18Lx;TzSh0%#G=cZ+z~7P|f>vObKw4tAj)&Cuv8H=*zz_LM(Pa#umyQyH$2 zBh#s<=fUeBmjZ2q{ngP3J=;qTEb~dsMLYLbncDJ=w`94B06l4`_rA2S$4g7+vWG-M zTka8_ZOqL;8~aJSx4uJPLJkw3 z3mwrdn*Wb}9wMbMs*N0e7yI-VTRSR@e?$=qWLW+q0;S~BBdzFsgV!y^eyOR|3^YHu z4J>`W7T-+dGPbo3upNv697tG(*1Kyuj|zY3*Z=c%B4tjjC|P=sxfE4O@rn$!%(#cw z)v~e{F_+jT2Gr;uaUAqUu;=Z%pA5K=H}2bEC~T>mN0-&Z*`W~lMHredM z2-g_^pB9I%|MjC@v9Gf0H%^))&X&qMV${^TC3hTh*gsj~xC!~Q>*PQ4UZ-VOC%IU{ z6r?ct-6m!o$_SCN!V}(xj`gd$*)RIWZA;_DxfrZ9=p(Wm*<}s^gHxnI(od?v=>pe( z9GxGA(p0+9cZ@;=a(zgwXp~7IR=em%>GeD2tge_!0-YcrAA(>^0Li!+hBTc!5$~Xr z1*oz+Mv4NLR9XFNyNx{zS@qIquMT@MnrZoP5=2c|OlQ!PFL=IVyWtzHzt~ptc--s( zx&IaKWZsLzyX=ja;*70hcC*b#HRTVBC>RIbZ30yXy9*@>j(gBIj85Q}KC1N4Ij^&`Cl@)uPGF}+hO`4}0X2IgL>ik57+ewf(ABK}J z1xW08buq4k_7ezTOsh9A^bNi@pY;=75-tE~kgI}~s+sBu(D{CNQiydPr2(ZH`8ogaT%JXr}uo820PDF5-I-&!le*OO)OVwJ$* z$pcMi#Opp0*r8nTJ^dtpR%9adUX%aiQM1T*Kc1)Po=K*L-+vlUda|3mzK-KY!Sp`P zbx!xbKay2F)9ux#RYo;>G|%ZKM)pTjobp%JCkliyR|kRVDFa%V;)b@yiz#)o%w#~@ zJ;v$G*NT3V0$P(oazOllypG@4IW*&GWHL+Hf1Lh4fIvm9+LZ{9HipF0q3>IZW58tj zfu1*c^$lPFOlXEsr=^d2+_WWxY?(Nx1BjXTy7?16|1b&37-bG1X4BnM?oB&qPJi)aePl*>%lXEX$)C**)qMv-L04U!+S7{% z8<=_AlZnY7)Gue@uwc)o(x-0+M4-r%`Yq4cXtLNb!zeO6WQeuFgbEc3Y~shIg$HqM z?bkPfE??*Z0(h86R-$b5IpJ;dSWC(cD=o~ttqIaFaKXn18gnW+2_He&{Bz9gtZ&wif z$5p$r*~2^N2%~H`5WUL?svS9I*k`_zvyc+2wYVplWC{P0BsmEe=4)Qxgys1zZ2mrY z)&naTM*`Fq6{#*cH)A>@1B-nUHr(#3&ZD2nsqvMT=hECZYpOv3^KL%88gJu9f7~8Y zHJjR|BT#5&jpzZ{muS&X&5tuUN-pdij)U;~{K2#2WpyTE?B?43wO3Ut9#$buPnI(a zJ0bQc>p_SA@{wsRdr3Zonm0_%@XnhLs40o)4=7BFW`pblU4$hUjjm{yGhMRK62yMo z#?TeGg9%cd5`+*8E#oo{%VFVnzW3g=js{oaF|6+c?+i?Eu}Xr{Rh(9LdalFLZ++hD$(ES?6SoGY z_X6`k7DpZgPqgj&iP4OX1?gaHRS+mYAreG+gTA;-DuS$(`<;xE{hotiAmHNvcZKEJ z{qHs#Yr<>UND~oE-!i5Ea7XucngCpm{aw-%6G9-xVF7M?T~NfsVoJ*nxUT>}fEeeO7_IZ9497B8mG?cW!K|LVW_DQatu~|Ox8>eSX52>U0fx_)#jAcOc`IB zJ_P2IobFu5KohVx-n=CRj)M3TC0f56h{X%bN*XR3wg6^^aBB-rLKuA(c{}Gk4rSwd zEj*fLuqtvM^gn|wx1w&h=-BF@MG3(naIQhfWbyXmMMl-hXGgwe8$FHQ#F6-Nm-3^g z%a8ogzgmjf#lf(LpJoAeRzBGAv*=!RhCWpMBgX!3T#XZ6o}d+%7y-S)uq}?lSKezS ziFGhE0La)YkF282+B~{zH^8#YqeQFrL_p8Dq(J5Of+iM!FLEaqBJtk)jaYiD7Yns! zgJzvFGvYZ(F|KcKH0-#dax{lRK(C?n5cGeJNbF!itzWZ7wOoEqGXz_l^-uY?8Hd}&Sk#0p#PEbo}r68v3018gv`@dU z6MiIMsl?SipgqbT^dB8=$6Yd}&2%+COPV+-2Z*g|S-LlnhzVC>Zy-8)n(2cxSqv%7 zH+<#oR51X=$hd1e+uUFQTDnj*7%j?2Tzue`{8fp?iw+ zi3Z8+wm<5EDgbJCioCrMPd{&FRR7^z2?{vm8sGpbCQJ@cQ!pFu_#<^BA>RrS4mbXGVrq4A1f04>V$bfq~^g0k36A=up&9fSE>GToG5qRI$WQh=yg zzzzh}xSJLi5pFK1-yj4yfy3Z>=D(99P3r(}%%7|AP2h#J{Dj_YzzA`2Sx)pm>5fQ-b!)X`5 zY}CBN_h5DnB&W-k!lIJ!EQ3QEondvnCfIenbm(PafXR>87GdG%`3!8z^hf-yK<{_| z0S-&1p{tw-TG^yRT~_|*V6gQu26FsmHF)p6SOcFuPp+QZYUT5$Sd~^f1x7wE9hUin zb7)u#$Y?60|Ifu*#X0CaIwe$3gCuh+4OLxIHp=K4bo+IxlUnuu)U& z^)0^p{t0hJvNgSR%O`bmf6Fvx(e?`KqP1>)cy{7H_R}^uvC!~L>P7-D`&sDh3B7Kq zYJn9SUo^_=>X$Sw1no&uuYMxQh$04<@}hPEl@Ij>D#t{w;#Ug%e$@blhP_l6UEJn$ zjgz7iF@;csl!EKxJbsT6hpk|;3*R72D)=YaKDo2Ad%vm zUTqntZNpLWa$@*Cwe0AD$y4^K`?C8MQ};N5I#N`ZZ#W(hn}cHcgukkM?oVZ^GkUPt zq1Org3#c8lSeNhpd~zD@>g@VoZva!@)UF0lMCxqS6+Z6yjglg!)zc)V+s>yLHFKtX zv=fD@Svbcbs`%dYSZd==c;`g?fccr43(QL5+Bb4>Nw3f@GX&apb*3WdYkrBOm-M8- zOrCpf^0LMH)D1XO#Ab#?n57n!xW)BOD;mzdm;FO_TL}V)bq7&`y7z|e1-Vl&r_3X_ zi!T@#C>u98#CNfP=PT{a=Wo}Zj!Fyq4C-GbhlG!=Tzoli>^c#{(fYp??*I+Ma`S%Z zFe`QW#<-Tu`>%(Mp+vmXDERS}HQSp{YI-`4$2d<4Ml*}*);+Ml!#!Ux4sL*qYrdVP zJdn8H4F8mQQ@_)tEWC1KLQl9lam`eAUQOKmaoQ1!*Ab;2J~ZI_zjbaojOY8Lf3-rl zI(>DBLseVaG>N;P*G&=?u7J%O-!)C>+p#QjONJgANh_o~26TnfXXRCB2z~?lE2}^D z-)+v%30UDp?Sge>1Q~OGW0apwgaC<)%TX?v?m=Y5=aKn)g7XU0w(Ea1R zZFA1f)b zBFb3I#;KuX+>th}$YF`;(4si_SgOzQGVZ)QRdYl5iLYUSzOJ|!Q0voU+|3F;=k$D; zUa1)b%;!HW^Pv0%DFNzo`_A&CRHW2DR?9IQh9>uM6t}b5%>HwtzevAJecJf-*A_q; zGUq>m9n$t5#%_}rsyVNXZt=qio{PNVaNSovf~W3SNzrG5p8p9jdZVw5|2+BV1X$fG zw_2u2a1MzIq%wfBFwVfI+t|HtP^brGkFqkH0#H;Ic@pPV9`;06efASC5vy|&t%*lW zkPr8@J!!Wo9Ovea)!!?6iCtg+WFKHULHrr68kvveMkH*$M;LOyP8h~LfTZLD6^kjRYz$gk_!>X_YD)%3TEBFWtyPM0emy;MedAL*acT`eaj% z*KNc6l3XxAM7fR9!r&G=X3ARl8(?*~SAeS*PPL|BDeF8&)m!c`6uqho|J%DDBnR-1 zqloDe{V1b^r9-u)%awz$dR#Yfy*L#}ky+mDj{Aj*na_73Hu9_AJgGRL+K)ms6PA2? zOr_6lcuZaoGPnRT_Bkbgji9OF*)U#vpt}0|zOw+`gjv&c09Y;Oc}Ky~Qc^odo#L*D zP)?)>wW~2Vo4Yl$0$`2@af{~xM@s627yb_Wob3-#jlw6T18C`!4{%EH6Eo_Yxil*S zop+wpyH?_&s68Do7<0YXfc2dI``lS92TeFkrOQm(dB#2Xm-xf?K%w{#+avaEChIxC zv{%Jn=eQdB^-znO6c$G5GX0H_{^LhYrm$%Lss`tB$AEk?xnzC(9?fFn4AiYe$|_8p6)+C5 z<+n)$eWRLe6|+`-q9ivf%I$$T93Xv{ zLTB2_5q$Am+l%2KdU`Kp{~>KIBlN_c1+T@#8_kw60W{J^gJu6c-Y9P?llLUQI$l4h zz5SG3KcIk!(Z9<8Bc!kRIS$mf2%J*QLwnq{#f6>&rrumDab-QD{Z=kq$*js<7BWjf z_=eNpkA=JMGXHdc&Mrf!{KXYYEi_;)!j+!*90-q0TCErwDV0p|-B#)-S-APbea_8r_2 zjl14RA<7?0?Uave-XRyuM^6o}v|msEZaEcThcYp&x@^z-buKyc@S|RX*|)ynK>S8j zPaSbIb6~>VlJl(Uny=`fuQ9adg7(>Kj|WL|Tr!I%F6)*TF)J%Icbu0R_;)lFq@IOe zhf_`crf0mqo-=jsO@39I%b=>o^59ngPn+SN*{a@!qFJ8ZzU0Iqk*H^%j3PDQzi@T# zS{_v}EbQ;$u+=gbe*>~@=LDT#BrB5Z=Um4f_+9litoB|;5ql$ugShqg0|{kPz3{+| z7AXFYZ?bra3_nkA7b=lmu`ilhVK_eWgEz?y z(eBTh9&e@}Ru{@ls~5{m_vWeRVP4B~AZUxl#j?hyHx#JU6)Ys2_jW7=fThz2!K|J& z!sdRZnu?<99;XklfUZg5;6DKBFi5BrjYq|elg6jE87+69v3mDl(8H|?G&~_9eF#Gt*aF5U4C=aHjm+s)bIUuo^Gt`RxqbEDon)PaK^Bxp& z5cz&gQVsY2So#WwCcpP>13^Fut?U7=?r_s)5@mbXz;0Zu?im;YRx$k&#=D0mU+T+Q~%BBKqg``0OdMVnAN z?k+Mos>!yC-i@$QKLFdJi-E9>uu?A{`wq4wvl^{p{c)AI5w@zJ)Av+1tJ6+KEB*D~ zP5bfTkVhlV)GVe%jMc9(FqWm5!^74FS_gv#W`1v+*EU@x_NKFT|8Au=+__35t;hsd zJx(&}`}qJ9vDzvn(s~7d-tl-JxDSrhT0@q8CYW*)taILHoVtvs36GZW#%TzUx_`4q z#x%1@uU#WTLivNuL}iX+81{r;i3xh);0#=Ntb^z$2mwsgCf%(s#8_h$Jgi2f^u5rNFV zt(FqU@fNHNr$SNG@XC1?xkU)czc?T~X|7d2JD7`#k~sVRRKfbT-D0Qq&(89Vx37{9 z5C~W}UFU?HIlxjYjYL_)E_mpbdEgFuF(Y0787M0#%6G`t!1)fw#z4-R!)uVHzjK72G&C>Ert2IxEvOd!N(XzAY zj6w?ZhDLFHt!fH-Y4564u0Mwj6Mk-Lsqs|t2~h{{V#?+>?B}OHoN3arM^jCUA|MJz zY)C23)MuebtOjjtLxSas2E`v-m}ZVhh}ae8Fj|FPFMbAgq)j{{$MQqC1-I`T4&$lG z-d{CxcsSQ0`M}_?owJ{lcxLZWG zH>MP|Av&_X7$E*NT-OeD9|hnswwXCte^WfVX^9o26P37=qi#8ELl4{eLu{X=l`tAH zo)5xlNO%i`2TzZBB_cr~nHtVf$?wSsRt-^U{ok=aOSK7jAwvi}V^Rk3sYR7-dJ3u$ zKO3%(1hE5G+#xZNL-iFc$`U|}PgPqrRp0~#&dx2DLt0qGzT0=anX1;kqpN|7hu+$w z?!k&ZS@$EpdA7=*W8Q3Rj{G%O6MB0Kv;=P}m`(FgoyhvJ zqJ`zV&(T~2ohPWt3CaMl3w|$IX~uU*!+h#3|6RX=-^t5XrS%t~(Gq6~q%#UEP;)Cv zN1Axd1c|HR=FdOp--%0Bv4(6GnrQo1Fhxfb*aJ~Pj6Ha_e6?Uo<4c2=gcPXF{-nU7 zo7+?pU9Fg$TD~Iy+R%EFWcle#e4L zd9#HLI=$~~C(z25PuEQ{|AU@(;CW61=Zq2bl*2u)YNek$B4J=3JnOz;1Whu$vF^Pv zD|kjs+hFZ0W&n?dtip$7YmA&&F;1sGxfJPFLFdkv3o3reD?0F-TgjUt!>Wi#h`?@- zW%FHIz7=vg|G{we1kJ3|>(?Oumqz{jmA^=5#1}13lNgt!C3r{>9}a0P;px0wXnZE{rmcMIF9y>1WYz$AtOu=IXw^Da_+e2!Rgq}Qr{iAWWUfa z@f*K9jIqza=Tzbo*?r4-9EKq4m2M12vtlNPFFyM&)=;XL_Gv^JPG3y#lYf`D|F_i_ z@ig$_yvL?@mcjqzx1f$zu)Rhsj|`C)(7#BChvlH_&U_1^Xap!I?)zWry8zcn%7B4_h48Zxjul_)p9qF{uzYrs~VwZQuP_gcHvd#&#T6qlQtkeWKC%DLwtUdd!VnX0o32Uwlk`{k!sDJg`bKbm*k||QgQF>G)!bWPbAt~`#E*~cJlO7kb zb!6#$!CXi^S3d6~w}>|qep~IQ?gLvPmYm=yRG}HH23nrUj}XkH)AOJwKoO-vl_NGf z(z(V3?KL^kVRb80=8J^K{zuq%1v$AxwF`gZ(zYn({#r2gg#L7QE@^lBGkLC^FFO6u z`uY8mWCvX<|EhbKXSNdP`Y-cPE2GXAx#`0`HDjAx+C{Tsf``nUzqWAcV}05ld{SVC zwn8sKKOZ_Ius~#+C0!P@r1<-@4hlsuZZOZ>4#)C&#DnjWIrSqp6`I>2_C@|5OBkfS z`O^0~`AGLqIxGQ8tGDwXu`!B5$(xCFc5|*?%9kGuvulFzT$dJj4A;NPs^s5%=S)JL zN147cSin{FRid@rMTU86If)q#k*eS`&R5DX97e!bA$duu!U5ODZ2mJyfu6A^#94Lj z4;J-=K$m`XMTWr(S*mPKU{9jf<=_y$K!fz3TK_AnYHYOLJi#=04RB>6yI(fX$Oe1^ zZXbuUvXBB_#HeZACVO~U)X2|KNUcz%mm#;vt;wU{NS4rx+afHkwD2_M+!lwP5Qg1; z#i+U2MgrSvGs4Hfg2gbZOY$=EpB68bcP0sTZlo3SJZ9|sRHz)&h=;TK4usaXdjDpaGHQRjKbmYhKb$#Z-8fCE<*HM}HRd#oan$t&lOfBhd0^ndAU z;`p?aLfLkF#YH@|R!uFSFD&L&+6{?`f1Y7F(&Cty*MsQA#dJT3v3$QRDzR}6u~7e_ zntAd!hi|E=5{<>Chq?b}Tm0#O?>&`&T2s0(8`+M4wE2BT&pngPL+V2-m)CFhgnN2b zZKDdB8-0QO(ZgBTo9FAIt)+cN<3VB zHMQRW6}R)x!RR4La&pKbd2Ou?tVadYweHAWnLwt6-Z$}UzOU2XD|Rhr z9FFW#f@TqPBguU6`{1t|-cA!($tizCe!dD%zzRyr)E~27qJFgJ!T_!+BgU+)=zI89 z`uHrI;zjZbGU(^61-S3-#Lw>Gd@2|4~ho3e|H3mePkC6n6qf*WhCZ93KYmZ zl6STqDx||FAMyCxWEbUlKe#8otHRme)W!dKc6EL=O!hk-!P3I>RDHIM{q&cEwBFLE zw?zdnHvwzuxTrnM+FDtYcG+rE`#W9%_4zbKd4a@cyCi3f7bfk+ z?6-S!+}LOT4G!R>NZ8&)X_-p%pH7tc$4S6{yP&vu8O-qRC-Q%!B(P7**LEAIu^r3E zupDw&V=OeJV%U;JYj`{xk~+d@A5tmoU%I7xWXDjtySoZB>pKkDz(E z(h*}m>#?4>#U$ssH;5EZ_yt~Pn~%uz-dVZN7c;MU7_9GVT!0dANj>mR!QzcfhVC3f ztQ5;wIhN+@LGgyd>nPI(@H<7HfgO)&NhQkC6&^LOF3X29VD6ns)0M{{UP<m;KqYKH zIRWPVWZ4Qt?;3g3BXxHi^{$@*6=0K$J-tNXvRiKO%CLqkfZ#*p5XB_dYof|Gl1eKl z9*IPn(cP1?cW5Dhq!1FO;cQ!2Vjhvb;liF0yfvRJnPQ`#_k4bfj_J1`a60m8guFG` zi|=;IJ|KlwzcD1NOnj1;evoZIUPPAiuLRW-&bm0AE@{oA2L3ocF5d#LRaB}@?(pTL zdfs8~%wHF@U9M%ktN&@?S;6P}CyC3(?|oHPw^B_7cXGI5x-F%tH~*;yuwOwqMSahy zVuS9p(g1k8H9J*{5uY&3UEwWvL_BmP!ueh-r#XrxCq+$hxg-rMuCsBEmWhgekacC_ zCTO9CrHDb(4JoXM8M&1z~02{H_+GWeJ#uVP#ALom; z?)7HydLRvjeE^;|6b^=YId~(en$$msxwfb ztG_6zi!@+5Bb03Xq@Ai#1vMB^I3i%+aH}R^5enNI%bah+Fd6ZHb@!o63Rca11YAik zj84)HHr`!=hx0J%)66Vcz1&Q{By7T^wOPOS505xtTRJ+8rwJKemGwg89N4xWZzn^1 znq6yxuTlH*gckE#Ro;?qoyp2h!QKETS}T23#QJ{)+;UGj+B6KAscN@6K$Kd; z7g%35Zv%oCZBV|C^23_bk{B~2s}NzH^Pl|Ijn|}T8DBQ4ReJl2{eUjMM5K(|b&YX^ z-#o5#8(uTTw4njYPzg9P`&EKRhs#<07T4N*OcmIsBd0Saq_R_?$Thi{sID9 zHmfmcUs7Q^75lgQl6qL0b@T=ZRqHyW>#JS^#lTNn$bp&D_#%N%vwbL&btZEWdt)kxQrImJ(Rkh98UZ^B zab~z{2gBn{ScPrGrL-Z!tOJhWh{gZ%#?#ho`1P;9cU2{J?pmy`vj42q2^Tl_3bj=aN>d_k?wjqBwupdFCnig> z<}^GwWLWtgvof@ zkP3GtZqh%Cfpvi=*bF|m>}yF%2PUr0=cqla7HpR~(%#!D|pD#Kip8}%PzU=JoFgK4=n?YduoHUE0S=T|Ls=V*^m@$rGav%+Mg z!QQawVqaqYm^gm|f~6EI##iLi8vAlJElUobCzW+_B$3tY+r_FV_P%)^Xkl(=RAM(j zi1Q0V9^SSQpH6GLrN1s3ZBi9CfP8j6PsB2ohOA-KOU!vCk&xhie*SKnlqDl3%#<7d z6@T~+Ro+r>lVnyhQuVu$BDRvABo7I z^3N2CXU$L9w3)7H(cjsiT?aZLt*VB}&!y($Pvt|D$GY&GR~GmN>#&1V$zlioLWpm*3d-9P>(y@R#ce#5BRfCto(?PmH`JzY5H6h!eW&Qy$yax31oeDF zdqy6ulD;B!%0Lv26x)1*KHh3q{S5hd zs6_-_)9Qg)qSO%VeBh?Vfsr2!#^pnSP4^rz@XK zN-{o>_k|-ptr-y|Z&9b0C;8)fCAEqh%@oq3=Wa*P5oa7CifvgnF`(ovXxg9f0VMOg zz&XO!JgxHU!f{u`1!#iM^-J2pmGsC(LTkIbv>v3^R~ZXPj?(<5@&+7t7{n4&4(k=S(} zlK`$}erQw5#VJ#1^J5(@gusaH7+JF%!&}MGRH0CCB21-X#N15K^I}^u!(%hM)G%5} z7>cprOu9J^EruQNWg$ta@S6;%`3*IQQ5-Jy(=_TCrA*n$sXd*7`XJhAq>wW6^tl(~ zPL#a#^3{(0V1XtbYjkX-zHngwPiq8#3stZ+Iz?Q-fk>fuut#h^F18JZRT>!;u#NnbR&GfZqVo^cKx=7jcVyVe zl(&61dOgLCn(P+!ejYO8#@(TZ9D@ExL}NT9#I8*waU$ zt2e;M2JVSS9#=goew1Dxosgt{MUGZ^Z|UscK^ncmO4Zh~bX7YL3$>P4$Lm-kBO#qt zL6A_P=^vmz2tJ_Bd)L^$GQRNr3`J~yB%AHMsx6X@lIIt4wj+#$W`;SPzMI{OrFKnq zB#caFr;>(O{9z3Ns?QeZXo3g^@h+{Emx|Vkwqy}6OJB7yVt!f;KT9k0zh4rFMkB$I z`4Yki2*K2@`$$Z(wT2D~#~a-6T8ZDZGQnESwmYzAX`OT7H`a6?r|g2p3v-r8qpZOg z=<0H^)nmj7B1Ui9QeOOX(2}PDy=XKJPWq<28<&A|q?MxZOI3GHY^0xSM+~+O!n-H2 zzS#D2?j|>f1$rvFXcz-13N+Z7P&XSUyNm6#^IX+UF{H7hol4SeMeu@PG-=zPcZbD1 z3k<&PsWyKfnus*7$WK)KrKB`|2fd_i+g^sSBtpMzd%WXwaDX}HLToj%f^IoT9W2K` zeE6_0Y|i_L@+@;ox2tApd^PaJ7?L`c4EXFBG;>HrMU8Ya<4!H9;9F9XNhB4wjd+hr#U?xIelZ6+hhaw4;8>FO0eB}~ zhAh=KlllZN;yn{#@o-k*=GKRg5r?p<;NyCy*a67?xKc4Vg>;XJpM6fuewd7RnEE!O zN#hh1;|o5`S2Z|oRr8jV3hdcPiX8*l&vtHt@>euGLV;|2XA@llxjrneC3%wqN=R8( zoaTO$FM^>VxoicYjh+^#9leB+?Z8AfDI1ajI`|at!HvdJUBJfgI%8v}$U~>+%czZD zaSr?+pVP^`(hTVM@mFG6MILdZPv?5>g-Lz8mqg9Kyb`$6QOdwCs*(IEy!C~09qT{t znDn!sv;C4*uAdRVZJWxYpJC}0e&x>MCnW@G^~69opxbuGLES%k9~7^hG^#b=%TNj6 z!er8cm#a6aq#PG~lLuN*@w{UErcu%sw99qCHQml!RRcHb^}&wWscO}!;% zf|rViGAZL`oU8+793+%MTG>K7U(TuE>*MB3pNm&Q=O%fkfzlE`$NcfXMX=&fv=ZXx zqloQtLy^LRw*c`p+nCF25!44YvhYbDCuN~|-3sbyH>P&P z!LU@!emN{o%h{%VHK3!8jQQ;r$hIb#{9koP0@<0aaDnP>z%*Jkj$}gh+K7T*X=Tj>dzFLHYY6MFWZF}~HI;g^9|%y@%3+dP4C$^) zIYc_JE#cX>?PryohDs}Y9*JO2xWw<1|9&TlxzU)>RT)_&vPy9}1cMLwJxRB3$H&~d z0+U;+Jg7Is3n4enTGsD zk-_RIa`AfR1Yd|t*WSfz4mpRD)Gc$;M1h3aqO5jh9$ng4VusV9u*dt5#%{+4dr}joLC$yd1H1NyaQw& zZE_JoK=yKa+K=XRpG~nf*irPWLci>A%=ZYSXFOJPH~+FcUG?Kk`5kz4%^U^Q^0Y^d z7_b-`$DG0t>BJf)LFHKJ*NM8=nZSA;)Y{-&!y5A*g~K{P6RJW6@qdXR1YPtP{olJC zW)XAp2`JtQnsWjyyZiX|IzX$|<9!+O!U)NQnw)j|q~NL3uU{9Jx2WxDFJ_xS$|eV0^HWdKm7!%cXjv%igrF_X0 zOo^F>zR?&mOggS1H5sv68w_T=EUAKW;w9A$xL-{t1)#_vbe+jG`y@sEHLden)f#dApCDtzpN4h)yOVPv3*->JNLP(&x z(>(B(wf*&*y4Kx+Y|zJ@goMw&BQjeC#s31&BtZrQ@TnHSY^w5z8fw$E-J=&G=d-&E zuE?<8-=Q4ln{J2H{k$s|?$nO99MsEJ{R}m}^=~;`k)FYKWB&X{2C?cd@eG5 zHvO)g$G&%KM(@xEoiw3O6uJeB|6%_1vxIe`Ko9|%5%pst^6eXEyKf~0+jxPeNk?91 zOVy5UZ)mY@Vmmx1tQ5a^09~D+VluYtZ5EH)vN`xH|AoZ=t>=99Nu!o4>*HBPR;Ih$ zq4Ql@rUc?LUKHk)KvDLNj+#bVK?~jW>(WtQdNhw)KL+&xGEWqNc~7=+qcd2wenrC zYaB?AUvQ8|dl<6|in2H;G;5?y`C`)5N^U-S?)x3hI-MJaK!wX&JI8HQ;ZA|0)eP2O z?md~ULU$%af7s0KP$G*Tsb}BNDFt%Gv1WqmpKAG&+Fr%&boQqP zQ*wf!U-ctR`qfNTIAzRlohP)|!xu-teupBYn2UgJbNVr^lVqRL0|csw&e%~uz;q%` zK48)iKS5r4UM=@T6oF8qIo~)rR^@jccVe=?XozKouYaFuMuqwd05NO5^VC@P!rG{- zqKFyw5G1;E<9>z3WG(e2+jGvjaT(A(rFOA#5LXAqrO;oVx1r`wNLe(vrc?K-$cnKk*`kGUyB8x{VT)BcxOd5~PLWOjqZ&k}}ZIT<;oZ$2c8+FNmM4gxJAWm}D^ zZ*9`lB>?`T(UwkbRER(111Y8r{(|cV3!{bWKip-4Gunka%1c75A-SaWuRP@IXpm`) zh*O8J7tYT7{T5(7zv>S$kZ!PmA}A1S`i@^wgE+>dz?Ce37Q&haou4K5Wt}TM5XpqA zxQ?!}M9t@9+X38NOR+bvZGxUKNxw~rv;VEIZp&V9)c~Y0MWKbmDXw#)Eg4x=Ng0!N zv7*4mlGNlBgf)J+cU1kff}ym)()V}#A;Dh*PU*n4-FW7uvR4Ua5iM$4Rl~V1?Jl&9 zi%4>1^F= z`$&?fpItz2&#qO=TLpejYnEfVlD#T@e}ug+hK;=miqJkBd-+S`x$T=P@L{Wn#!Y1DJ`6C;@!BXGq zhAb*xwu$Se-eIv1dA0$t?{mWkNU)=^tzS*sZPXug!tZ6|6OImdCmhY@g}WlRdh;XlfJ1kAZ?rYgd0ZCJab?o709P z^)%-B*Gm6B-GsXncYTSs%_4~hy8~LHD6_J3cbo<_$sSTD+hQFVCOU|zm&=EQ#!AAaPjA z={M9S9#VZMewocY^2F#ZjC{KAZ6n(n(;#gI1wxjr{irIu?RwX zt`dZ{2-VmW;^l`TtxPUGeY5m5da5T zyF}%83Z6YDSL3c}%O#UM@tMBwXy59B!Q8O52I$aaZ}O08MX`wCWMbFK_Z(kfe)^(5 zD`!~`r-htH4~JWc+4Vf(g~*&r_kbLAgXHSc#J1{BxKd3rMd(eIrIJaPrxx?Lme@B0 z=f)iDlZVwx0?TIrXvj#@d?eIcr0dxZ;;6h-lJ7_z-ErNVmK=;ry6@wmSzYd=CukeQ zZLAoNDt|5hQyY#wc|Qw*rC>G_+a4nG8BM7YR6vix!Dy> z;IhK0QBO)i9QQvCk|((sm1%rdRpR+P)XEZX#I~()iD5$cFhT3v7>Cc`bAXli;WR>> zgLrK#a^bGY<@#4~HNOPgp#VgnS;_yS6Ii_h$o?kiVI|=JvX7cd3$lCbr6yJr+lQ5G zKCMf%k~Jx?4;ni2IA6f031x4PMC$B{6U|4wd?e~^N^->UP;FraG&d%2Yr(|5~ z4ZqGzWo(guDYT#^iRUnhs5OFaMY%?qu%p)g_@j>#V9TuueD51gyoGJ<`m1%yg@GWd z(&M#~CzE}xI0ocb1CeHczgx9#T0$+3U0+6*&0WlIO_Z#CIyXwi#(ISRhS|=zjbvPP z$|zh=X=U1@NVM2cN5EX#(hZqS5W*Lmif3+_IT1}Xw5gRD5&>!D{rlOnRD0%AFBR`~ zH47!xvb~3^$V^g0SZ;Gi71$g&ufY@GycW+3%Z>e`jH4M*iD?Ish&%(}i0x<7A!2#IRX+SRH%6JfO!3H?a~S3WxaQUdfZPVmmfZlcNbD z*$^P89@kx`d31~0IDtcy634~a_6J5+(NCLV&%ZaUb)A(ZcYjyr%VJ@bb<`VO+@IK1 zo6@%t=-jbul*@H4i{G?0^GS|}YW~37S0)p9jz)Tt%koQpPgCm^QGHhnkFfP3Hzi51 zQu=%v{oU(kM{mPzYUC)Het$qTLDRVXi>dvk zwZR5N@zy)X`Nrt{tJy0tp$iTO2?H+`8hIIT%c>IVQfJ}Y;2Pf2ZWGs84^Cuv(*LhP zIYH%TUBQrGjCBQ_6-E6p`!`0z5g{EanGuif|59W$zQ1H1ylwA9LH8G z+G_<=#oWgI*A$qjTC(b#wdLLt$D3@N6U9TWw2)N-z~Y>0_yOM8=2q%d1)>mk=M$WE zErz|I8PrA}!+z^6u#NFOAo#p_OFQ_v(7CCIG-j(EZ(##9?|D}LE6oH{R%H_me>^cJ zQ@Fvjv!k~Ob|7Y^4)&5bcn>tIWg}C5;iiqRI<0yahaqZD0!K`{*r_G;GgTFIE<%eb3i|iX>T}Z3!G=XE{sKBM{%JA0 z!Ef$qWLWXhpBdFQAmVeI8SUash|C_oZ2>r{Q5jn$)$LcK@+K9a)lWPcMux>cqmo=x z<9CbSi?+6wljP6I%WzDRov-sXD=k_s8^7|D9h6|<*Mq%y_G+E)QAxGMlQ@2h`rBXY z*nA^G|Y-Vq! z<&$;hIu(_48zf!4>uND}WIc&n^wZ*C51lSCdzKyw%nUcz=b@VrWS|a;nOQ)R%2AylT_We`(1{HCXI@H0L*DT@(3W!6WZZ~S)V#iAAO=kNps8N`7bD6JHj)}qUOSNDh~gxzR&6XA7V0)k5tanVmjXM(P7@|qEjsAJYr%6c+1aDr%prwxheXNMI#JELSYH~C5uxAK zkJQn}Az$MwkoX{tw!t=xY@6QYjI@Bj+6V>rue%y|Qe6^NN%uk`Ug*6HLozf!<{o~jfhok+k(iy=_ger+b zkF?=fm+N~w!U@?jBl8s`QIM_Z`oYK2{>^_lz`FR!xB6aaZgT%qc@o1|FF!OIGH8gN08ivQk3qWmp{aKul1&t%PvY;gQaeo`{9GN%55pE`Mw@O6B&EQc z#jK!ncmG+;*z9JKBqy2o+%K()_+rdh;mMHhMLS*H9Ve>5nNXSenGF0EECOOxvYM~P z1RLRj6t~6H@ecz|q~9|scc<2_R%E?@@b3*Z`JJhC^)TsY{`JlJ3-yeNpS$xQRlRri zzL>o+7buciW;b2YWS%gKc!q(sbAkERo1RYCv2J!mtmS^~X z2F)Hw8Me@Sza+8|1_WbpUfv4&3ajOTC&kUZ8gA31qqwR3`+<*}k|^5`Z(jQd zq&N(rrp%a}v9nGo6tvmilX4)5ZPZ^>@aKJR8Ye9|n%xL1!w28*Rqrqf%fz#x|Bd0y zErl976#K4W2Y*z<{wD`qIm-PxPb}+vI4n9BR|_6L11P%`nhXJ;dwoN&wKJ+zJaKE^ zF#12M@k5dQjK2KI`B7f_WufA!ihozH%Ur4#Xf(F7KN+D zZbhnEPc2c917mHXw>1H+m?f#G5S5IC!vzgsETjNpkf!T_=nYxGqD-!Enwq#zPu`9( z0DN#TQ)kqp?=Ivam3rsJ+^N{l-4WRTCvN-1tL_&<&g4vPG-bM8^~B(ISzsjgNxtmv z4$lC2;M}(DBWkZ-g*T|=O>O!nK}1b`P`U3Zep^eGp1uCTFd$M=T4d4M^kJ<%gjJWQ z(y|Wh+YA%>?o6j`B1ghGRASHI#?PZ}eiB`i`bH+rq!` z;H#M}j|d=5s)$`&{!*{8=YC#vxF7-l@Fgt~_F8Tm%nV68mm4PQa3W~}_oW_mNTPqy z&Bi1Nb&%XnypWrpB1z1=<&(x|PhAxw++PQdUk=Cs-6te;dR)3BXD6?zIVYZ;Ajz)K`h{azDRGM2h+@l3=q{ab|4~ zu`k^ZH#Of)<@|+*+8f6ZWjEwyiLmADJ)nQSsWz;Cgb?R&Hh)2(I`LyBT?XLKgb(Kp z{2WXV-7g1cSvm|FY{vjgOpAVRY~YU*6YQl*!pr+}1D%KfL!7xK24LpDr+uHir?XJ! ziU~XNb)>Ro4oN{YJG_6fEot@Hqf0b_d|2)9z036+Tq({Za_LNO2e&|Aah)kuJ9Qgz=E;>(!S%o-+U&S~hCq`NxLlMT=oy1J)_tDw7QLm%c-^VM}8rK-t`^s+4oN z0WuhA^N!_5@KK;WfgPZe?in5N2)CE)WxFXb=|$gNconZ_0@$l>zzyv(G=cAs_uIgM z5P&I6YQn$j<~O*SiJ)5EjsUIz?r~p}JQCFS!aK^=zx5WfY*hc;mUHLNWh45DP zs6>P=+GTdZHpg=T82&C7iy7E88j$}Z#a>~A`Y zE%$bO@1e624^_i&JA(zb4o~v8ruGf@^VBBUZlNR!V zZt>Gfg8XX{zhp51gXC$mgGF3tNt;f$-t!l97vHaGr&LO|U+n;trD5}8Af*d#W4K(B3*#@^ji_XtuE6b3vY8|yW@dY&m;biGCI-D@9mAt6sgrK_!+e(d zBi6M8p+3Sk#yK?)=71_|)S3NFKJP3n!rFczfF2Kh%pEqK0(k0R2T4@?YnO@jhIYch zOruus$g)H{n{&-Lt?SdE?Gia95Da3`;^?}+F?qkp0|6akm%FhHva3eWXz~;f*E8NA zS^vLS*lWRUFkTMFR`_R@AT3(l4obI+vv`wiMPd~ z!)BbT1Aw@0OL|5=trB*6QO09#Ny9?f_Un$Fi|W#}^{mTIJ)8o*-00G_F7=e01W)hfY0s_?2^m4<+^dYT{sVPc(s(;_IH=r9T`? zb1o&|jIeeFiqy2G_!>Br-x;KKhDm`24(+EK1_jkVEbJ zfEVyL)OHb{&2q>$Pu}?AH#(u~=#s`E2XHkwV6oXgsd|=LDEeX@?mE+=KMQ0irNQ?W z2miH(6&WalWV+KoAd^r(dD&-veVL%71x%#oL2vxFa#03$IDLwcMl`Pirz2 z>Y;tNv1I<9g;I4!w*d$<#HV<5kLV90^ZsuHZF(c@YIs*6ysXoXHa&ndYs18!*{`aS z+_~p^Qnlo-gss~Xn94(^B!r(ppxUG)5rdJW#k$^~$FXJ1L{!z3^L_vsq=4bZ?74RA ze=>j|f132?>~U03T-Pf+q}pA!+ZN@pJiX2Bwmkd7Ii*ky*_~xwe2DLl)6(9*{{FSa z=02y;48H$JC@kx}=*h6DYS9W*Fh1)MA;=@0vftg*R(iD*QLEpU4-(e8`n@hBp6ubf zriLBIQ}k_$3lNxm_x|edc5NSrrGJ)9&^4;n(zGLYMNVMaKx7`X#Q4fr@dfa|(Z4vC zhYMRtFotEMmoaHHd*XKG3iy_iQ)M*v=WzT1qPwYlSZJaDlam-}Z-3B;@T zQn2`;{BI3f2s^ilz0!>$M5GopC8_izIrLg<>Sd}0G0ahl>}Mu08Ug0D0RnLp+AUXa znZq_+iQ)Ruu`teZvpr>6gU?MkfoophKgr;@`lMSGVPV|viH!@fjD%(A`zuwSWnpNv z&yM(?xOhJ?6-l6An2sd!b5*Y24^VIX0N}%VqZ1x}ChNXxn?%(G>P!iZhS``ZNuQgK}PVZ{LwF!Brq* zdr~};X5RLaqN!7TxQ;7!T5dfF+dO*ldxVu=VdX-#*oO~Q*dJkQ-vG5Qp>pv;A#HBe znPY38Zr8#}qX(zZDsp*G7k)4hJW6J4crn_HPdOY~X^drLD$x+X0-f2XW#VQ>o*Bga z)_yencAzKX;+f5x@sJ#6^tvUZ`^fpXomUS=G~&dg5%GR$5$U3$?(#2}t*ja9qh7Ht zz>3$b8BnPq5Hhrud%x{l%W5XdwwCZ-N{>;mm3!f{O^|6s__AwJJ9wPYP1T!B~kvkJEmO& z?4WRQ#H;7w*6BH#4f5hdfr-Q`L1MQQXd6L_o;(LSC#k(W^O8z}$yqyME<&BDj?|I% zfOJK4C~sSa`Oo3V*Z|}9#x*7fdLg>lEu-Er^y)4ES>_)HRWsA0v&wSOxeo?DmFF9dN?_d7E;GnN zDB!dy29Jll4)`-QP3=#L`zd}VB7( zW^sYR4-wgNlc&_gc3F>H6NsZjPff7IOxO8Og;$Qt2b|$dL~*auyn-oqQyn2ufFS#2 z!Krm6u+tE5RZ@ljclbtmwxvi-m{mKj-Sl9L!q*Pqc*4nFe7;L@MJ~{ER)*o_RYC~@ zh!!R}CJO9JnDFhHW}oiN%mSAiWT&tI_D+f2gl#nv13kXO|D0>0@kcb6|I5ae0t7&d z=kd4-|Bt4x42Yt8-+r(V6_Aqdr9m2LkX#T@x|Z&iPC*5MrI(OK>8_<)$t9&zK)SmG z1mCm%{_l5&nVmUt-&Y+nB+ianUofR6`_kn5L_yHD%QmsAXT5NZ*rGDagL*Hta65Dq z^bt1TI3ctzD}IcrgdT7K`4%AF{FfEXXjKH5CHF?u0 z{)-E%qIm4PN(Zud!S<`dqI%Egn8g3H4=5&pq{iXM)o_{-%qM%Jf6!v^_0|E6k5Hg=py=R~DLw%oV$d;`y2M zxj3I`1a&TRT-!gt&peR}?j>HzH62)MR4|bOMk~Ht0;d^pb)@ctlImQB;c;pyd}nZ^ z4wn5TMtR0?(ZfvdUFI~(oy^f(n#D`HSuf6BMUlk4H9{G}a)KVM5b-b5@NA>PP+5UB zvUyP6bg*)n5wxTkD3&?j^I%Cfq`p0E1x13b@1S0EusFVa+y?*!@@c-;TIl1+47N#HG*=(P+*pTZVPv%U_p3ll<77!}(z( zt+r3nyJkREd~%ridiR!FQw4-3wnYp+4<9r$r>DL8mVyv}hFeHC<#%vq^fqn}URfVP z3f|aSy9nt_xVg{UAE@)XPKCTd1tMP}UYW8^U+M@O*W55|Wp4ZAxpH*X2OY|LPD?g( zSZbEWBNA0&LWiB4L83txQOgdoNps`s^V7}h)T9MEAI7kp4T2Nf7Jk|&Xf`a6&<1sW ztZnO{vj6TwXdW!P!JM94ytPVyOh{ctYPu*Ekg+VUf>iZ$JlyKU@0rW&#lYc-fH6c-bmWkw1vv@;TQhEh_o*+PZSgH znn&2Em+b`Ey=R$=*7nn*w?YbS8M85TXYbpWxgD|+26M=gr_>r>&A&w=6bE^}E0NC_ z;2%BsaI9*_+^dtd6nmA?DcdmaV?d%@X?0a>L@yd^;c9S=|x8`pn-ZO^aP<>Q_ll!Cer~ zAM9{v7`L)NP&uP?#mX_Qx{Tlxg+g8Wq z5W182Ct`Q``L2Maq(EhMDhz&9AX3D(r%%*X@z*PdYzvy47ui5JC&t+w{+L9X0% zJ$`Rr1i$p!9x#eVY>iW*Du|0gfdE9*oR1FCKg|RFStd`u_;eYG6Jf|H%`BJmb6h1&pp|c-~aV{aouOZYNh<6 zE;cIj=&uin#>cI?+zDlZiI=C)trB&G!q7UWQctppuMUV2=&wc z{uP+w!i&tR5FTs49s$auf0vQ`|I6Aack9zO4yMOo(hQ&t{#o(LK%($116hL{F(X;> zKJ(HX^_6zKjB8Bi@3hQFcF+!j%_4+VmQ248N0)x;PcWEszQ&j5ergk$t7P&tDLk?m zaNd-_d$+YxKt+GWVEWc7tK$L2FyHqg1G7@${8fwvTGuB>$ z;2c~38gexGeT;D^q^@M2J1-K#{P~;Qq_ZF5?0Cth!F0Qi6VID@s8d>?#6fT6HJ#w* zf)g8C_ub1%_%Er8(IqDzzsBY;j4)tSZWGiM@QZQ$XlXFDE%b=@2`i6Dea%Y?(4=6J z{@Lpq8g2#e?1^Qlg!O;jR2GgI)myJwB1jFExI zH?@5h5xaZFSukcJVQY#b-337=M#YA*&#mR+HmKmsgUsUi334bI5Ab+>`YoLJ^?Req z7(IUL^&x_O=s!NNAP8w0RHnYx>S4Y|_RQ{ebXX8JiG8pj48gW0`~=c}zH~M+RsY#b z<<69CUkUT#ovI} zG-Yx-f_qwJMR82)d!@)D5_erZ2MZ+BdEZEneQxFUomW*RcWt{;a+Y)_-I;(LpkcBm z!=fsWL{iyQ^*{AeahmI0>wD`b)Ac5gMGX*wMZ4nDOiz-_AeL-iSi9(QcG5(OxvN@@ z)`tiH*=QHlvLfc&s-&>gWqDlx_BqUO`CjUGSFSJ*#Iquo==D+`>PgW%r^S~fN_D7u zQfMoBOuV@EPWFJ67HS~womBVpbm5Pw+CiOqUByp^#WuLa)@X%;2LfT9wU1&=%p9AF zyAVXS2f?k)h2=qWs%yvJ`>#2*D;6YOPjOH)lcc|Yg*y)| zi?OZS>g$heO-qkl77`?YaAw{}WhQM?$nzt+fGOT_Ay z7?(>Z&^=#-+~i~_nA1;zX^FrJ+BZ;{o){blk+$EKT-;Ie-(xG($E8&J5^vjIByUKq7bjuia-uGg zfn45wr-7{Idrq>wt?u~UhC0{?Phsu$dfVi8i++j>WGcd9lalg9=a|>{)nk3y`Z+*g zq9i4Xyz#5O=>U#GTwgK%dvkEu)>4t9N5GZT%GXzP;EJ41JNr$_QaZc_xi1V)lMk^k zmb!tR5P$kr5$&z;{W{`9J^=^2-RkYaJM?=+s)1X>AHQ01am+Ymo zJhh#5RN(6fgD)1D1@k|=Robl#l^=C`<7LsoV?%Cr;a>&o=pG-TtsilvE=#mS3Kbe@ zkX4Ptci{4jCnW0fA5X4(Ufk8yE)qt-R=B*(i(;)%WWE)K8;~RYGUxwdM=-d0%zSLI z=M>f<{;Jjks1nCZN6cPO^AC)scqlf+M1!SYVCAY0I$EZhLSSjBeB+Kepr}5lWc_#nq4BDbvkUao}?xb*-3k6hU$kpr^-Dh=Wrj> zU>Y2`dw{EbV|u(*erf7Q7wv*QK7cdx=E-=O-6;+dVfT~?poT=7;9t*VjV5Jc?aA_? zxm{Yg8m0h(Iz7gEwUP6WVeJXq*KNT^1mmF7bVXDGqP3n`3J|-(Ptn9KR82epG?YAn z)_wfXF{;2;lrU!?JoE+pp8it3#2p|RXncD%2IhWKfv9CcmVpdt5jA2HFZ|9S6r`?0 zac|ATv3Fg50w%aS*L)$q*Yl|zXW5+xieZCyqJy6wO2uOYdn<8iHSqXZk2=v|JOlU1 z$NG?Gf02d_6asSB|79yl;QrO}Y+#Ito2}8aj@YdeZr^<59z?qY*JX)w9Z`KKUDog` zgzL&#E6h%*@XG_!J^y~EZnB8~+&iIGUGc_;pB7 z%+}EgL*7&`uyN_gu5oqX5hMOJ8*VF)*&bhg!4(5}7=lcrn<1pun~C3(E@=oR&CYvT z1jG{gR2qr8+9Tv3)HdK2atdAjXD-j!RFY+`GTR59t6{nfK4bq#iJ%3(YEHg{B5q$cEc<(ox~gM7XH?vfLZzN2kKFmI zm%`d%HMUVLhbi@*8SbTFQ90|acgv}nP~5<=0bbHye@~%8H8z{>Kwvo0u+gOGIJXJ$ z{QF7z(WucXc9#OTVjVlxCbJq}QZF6B`oP|&U7shB<|dR#XR6rX=dz{{X=GB*ctX)1 zl3?K-#bW*}^)g*Wk{eW1)k?t^9D-;IX(3r(9zA%1sEXnQYgnbKer-|@N?Pg&w%_W7 za<3Oo>zHz<~bcvLK6Q@v8?E&I-v?+KM%Oahdyh?iuybODeFk z!q8-@8^OC#vDyCLhxI{V(WTHp7eiE>T1}C8#4aX%)N|UNUFOW+D+&FW6fT41dZF3W zOer5SYiz&D1~B5tb}=0ZEH;wG2&y0_9(@Lqy6pa5ydJg4)^7gMlo?v>FN_&l33?q5 zgv0oT5nKC48|g-QRS#!Gt38fT>j(eD0IbJ8mByNU{Y6|#pZ(J?%cBs<$2iZ)e~~>)0Lp)ju8Kp9r@mDd!yg%1vjO>(#PNh zamE8~H<~S1&!X>JhvSVit&l%deZBU@>PR&2AsCvu8yvfdyiNqF$8ZyepCa&)m#UOpAi2{t~^cA9=7 zHCTTE&eX#UbB-c3Z_HE~ZCgVrWM?^oKevp9UI33aT^3FXw#}l#^DSb1 z(2~k6`luuqB$e#bva#WU*{8hzozqfn_(SlLTHah@+l6kK!fKA3>S=%IJr{g{*WlTF z-t$iSHS4 zd|Er1*J9waaaS!Dwz7?(oc!i|dohTmIAYKmmb8Dr?~Pc|ck&S^{WABE9zn~~LS#`$ zmjbQk?X2m4bfIAfHcC%@fC6>^Tmd|_IvxUU-17?$2q?)gD+bBI@QZ)k5PHl zOv9B;BqL^VM{f3z97;XREk>Dd5Uo<~=3z9o$zj zLi~l@sb&tv22C*D9lw8;=Iw?+Jva~rHni;Vof+7 zU&a2)O;&+|sbTwm_fzkl5sTGOXe#YkD6!iq=SHVFVw0k^fpw0On(drx1OgI1(uQeMkzy$oPzt8Kut)kW z2dl66&Vi8foU-=^Ipba$Bi8Ac9$72@&7Oi%hl|0t3_&hufiW+W#Z|G3Z%WT0G2kw& z#^_}}<~fTzO)f>i-@{KJiXiaW2r3wvH0hqD004Cs33FfZcRIS#`T)t&(U?J+!{_e* zBNyH1hkB{DS8`BtWepf0SK$2QWM}RPK>f+sY;_P=oVAk;kjOYkSp$yjN|!y#FaPqV zitr9HCf5p_YyOH}-6aK&)k_J1e63;`2T?kB-{W zl*m0^sj{imwa;u?8q@X2vJ-M%1(xl@*(UpG#c9j)$*v(c@NAqL4nDus6<)EX zgOq3xkuHjVqYx!ktL=Ayzk+v?1M}qL5j&buYPw02C(`Im85th#+%?2~6307eCZ$eP zUlEdTP(UL6J`dJ5CF^(b_$$kt_lLm7Hx1pNWG3UcmikK93{PnQ{Z|zn4E%PO=MGf# zWLUkJZO!%p+;8y)UCwrt`H*7Vg`!3WQuI^fasaQg{E2fTG?Qk|(Pu@PIvlg9istfT za!4Gkkt&!#(p;Y3Y|s40F`64;vZ+dBX{sJl|87?A!^0lN?K_ zEV0=bU@DLg00B&$dKS$HNQsb{AmqHG;a^*WGjrG2CgxlVd(&z9f9Uo%84G9MD0rOd z0?IwfUaz((V3x@2(TqkCisifz*#hG)p9J9hPw-LA2u45HgEuGl=;Si_x)fjj@1?B~ z_P48}oBc)8ZduUxJYc_rz_Pe&U!u2*k5V|wO8JbTi?^W67_-lP2XP)WS>@07tu@nZO1iGU*AZ#6?dLluA}&I zr1^MgJDpSkau#^ZL0+3v!DYqAv=+Xt7tBaV_RpnW%_KlWVT}@Q)+iq}jP`xLOp9>? za`%5S#|5CKTD|&z3icX|5A*ytqJRaojQ=%CKOq_jF&Y?v8x7>VIi5(sVHs#U)&~oJ9m-6u+AQ0j$$$3C z|4ul1IiB69VX;d2uOZPhT_n{1O_r1_;LBxA?2@VW^^-%lv^z|M~Bu z1SK{l%aNCJw_bysG7G8(*80J}d4K;JgZK_oUOdi$-3I8k6u(~X`4B|HZcMzHyXs*_q#Z9k2w7w! zQy(exy4{k|DNynqL{D6puBMNFTDJ&o^QkO+av*Pp87Di7IDtj$L1vxW=G=A4fYp3Q<}5P1LB2q?LU_tB-3@#bc4po zwt+3@<8w1Avsq|xt9YBz&n}&B&nKd5aRoI;cZi}tjbJ1T0njlhS)H*t!q%Y5CMw4@ zw$+g22_pQUiJr@~Ea#wT=05Et^}F*_)dsnM6)*b1up%;nj%OTn$u5!fPnBmX4z$x> zjS3bTls^tOCd#yi70zpZew-R|W=F7bL|v`9%)1y&5Mp1Rda%R;34^&Z&^fcG7Jfee znr5$Z^^BpWg!;a(C5Vo>MnKjEFJv4_3zzD8$gU7{^OYxFKN>JzH(Yf=D3dE_dJju> zG5~HutXUJG0ukH-MNJfBeTN>C1?ZG7|I6`@cw|8=+2@W)N8oW$yXN}X?v79)tQvIO=;b_XBVVwL^){8;wfE}qeg6P0-(Bmm3@}$4umr2f!^V{P2{N00Q z-fRGzhx1cR>Ac70pQgDGYSj8kyE;sAm5lKY3&De1xfQNg|c-J$_5-abD!n@KwBvgvty|7V|y!>)1Ip_spp~0 zF@d|Xy;5kn63vbE-KVncAwIzZLn-J-bIaptY5nsmlwlq8tH)WjpGV+~ap+1bzB7XI zdW9}dC7LMYW9;Ri5}okyVb)hb`hH#LN#tK(h>aVn8HI`3=BCA`dq+Sa97eynit8*5 zXbKZqNBET*0ibSXJE6!g|hLEXLl% zLWZB&PvMF@^(J<4Rzan> z%qNa;kQ=tok?%YVEGgvbxaTy(wP-aqXomuXe1e@tgO^6z)Bo-5ML~uYJ--B5K=stx zw2ho^^?PaXbGuj0Bwc7Vfef6Y{_jY zxrgQk*}~)ayH#raZgiR?xLD~537lZuYV!I4$71OCAUv3v!uP-=Nd5_2OBKfRa z#m!SrspajTaA}t91QSCkd&tNZ295JJnbkRCvGoRoSIC6pdVttbnUl(W!8s=XUyY!b-5RDjX(l%C*OG38UMMBzf?;`6S+tAt-qU2{Jc-y^=4f}P5p z!{wBt>KaJA9%-*LZL-n{a(EDG1LQy#cmt$|k7{j=&^5K%cg^&jR)+!=ve;biD7;{$ zX@=uvg+>@A2~n5R=!Sw)e3x)&Q@P+SF7Ev-U6H1b?v6X*YcHKRtMQc3oKQDncCcS5wGWp;%lVNn5 zC-Ok@31|OAIpk`Xhmst8&c>;*x7;bz5!P1`yTBv28M0`bJw@YC^mgj7UZWOMfNXP0 z1Q~7Z*7+0by}fzU3daR|7~pt+>#cF3HIZ0GLBE^a?2CWPQ6MdyWI0*q_TY4Zdz^YN zDIQfVh63diR!F9V4WM5&SC?OUk{OgmCDY}?4{ZGjEI?^LF}E1_0Qiz7=py^Iraqak zk_mN+vJi~B;#MIAdebz@iMGK+9Z1+N6*m5Hy|?^HvH_=V6S>5{?-c!2hTcX*6pwwb z&gLs)DR`!Hy_x4!?pCf0zQz7iJ7b>o5#fC$2a+~EJKm_cbe|(VV3`@gPCV6)|^7}Dr^A1Q{g{- zY);VRRf-s3{bF4|`!jHdMf4(0XRV<>7_V>N-kFmIyFu=*f;40N0g|aC0roO5p|QKG z83>&bFUZ!p=Sz#@iAR^~3g3NYnR*xU)uQ8$Tz}c-n54Q%R*j@OaI{^}+G42iG4J=3w?*t$j7@^SD*xat5CEgmY70z?h}f+4_l9 zVoavhH)1E)4W;sEDwg?+?N&0DJyp+zO;sF;-)mBxF~vUIcJ5sV=`lVvo+d-1iZyM%y#%Z+)`EgK=kg*$rYj|}V5raZHuq6IPSC9##r98&3MW=uN zNM;*NaaiekA-Eo9U;g?pO5lNT6st?R+)pI!23h0@A7i-RU}J8$Ce_4`5I9(0{2|KT zJ@LxanhylPUlGk@l)#2>=_pZoF!~?KtVk2*sCk^JWQ(FS!mqiV!X4KyU`!mC(74Qtsi3Dn(z;;CVeV#R8XrqPi@9-Y}P(YvktSK@S-3A(~eY(ysx=PI+)%uD* zPr$a6c-_c3g*o}*Le(ri+fjqaoy4!tBfPwIvP(gO>C8^H!|OQ^N1Qbkg_wL&BIlb8 zX5ThmOHnUWqGwszByEVh15)wS$$EpaZS0K=LqRL`NdG?fzZv?exNn-xqv_$068+Zr zCQ3$~(T{s_j4>9SP@D@ky0qTl3inPKSG9I6#R&QN5g5x7>xpl$adrBU2=!+65a$r@m-5M zwjcluosaDz4sDf@LM#SsjNPaNuYJlt0kOL#1%$gi6xkI|H20mb8X=R6I)r0y$6%bh0;Zuah$eBzCU3@ zVFhAUdPOo(UT{~Z4SPA3I2 zCLz179`x&W1~)02wdBr|E2mEx%^b-Mm8-SCtD9yYq*{x+=xLG;Jlt41#iBsv6Tya| z&w#4;RZkqd`=s!dk^WJiMS?lKw)Lqs;TDSQ4VFCPYC~c5#5Mkq!goE&f5~ku(?y!W zT@AG|b_PX_^QSuBqa+~`m5Dj}fR5vAnW+`CU~ch;TbieHI_>;V%@S8E%W zDOVgB@7y&L4bo;nB$#8*`K=%w0;FF2L}2X@?Pb0*DE->OYQAD$mcX>~@&$;|jBHqc zn*W5ZEg8Yd^*8yj^KRW%Yv?_?H8QLyKNflr^z~0Za)zF-1sc_FWbeR>~WH* zpy}pSVqW<8hi1e8g2!ad%1$bkbBIEyP>0R58&tqQQwPyzx*42u+DU(k%4EVb^%A%J zK(mL8%gj^!e9h5PR2EHj6Kh_4DD+2T;O|NbGR~C9EQdfO$6!bKud_}o+$8WPfL2?VYKO!`e zTW|VGnUm$2=EHr=Jb1&{hryyc*61|03K|w)r$Zq!;*Hlgf19l55q9iNu={c6}>1-?gtjkN}6Pu>;5F!_iWGT0M~l=(>r@$>6=L% zc<#pEug^bt*uG&(tJJVQXPJdSy)!PWwNm~MEGIbD<~~3D-ra`9fT%|C zfdQ1UW~0!2@r+gzOPC`gfFoW>0@*Wb`$Az?fehcjeBI|%;G(RVzAr~#7tFJ^q&#Kl z5n*Xn`3opXfVAu*rN9Lj1kwa10G-45LaE58v_R$P00Ib-N~8XzBM`by2>3RaiRUm+ zEzO(FaJ5+xBmz_$fkU-FWg$JU?3-KN4uD2EISZa0RcCFJS&*gZ0FkcjcyCZR(YAx5 zS%%0^N|mUs$BhZ{=R?F`%ew78d&}q?`%OzAQhvTFr+*R=1lc%Q8mq$#r!0W21Sw?M zm-}_eQ&^lmK>mowlCbwg3RGJera{URSkWK;WLfc8iPBvSiCv;;)i)14m(S-;1iDdw-#Wc_ zIkP)lbZlxU(ck*(I11Eq>B=Ja!idkV|460Tu`V|SNd=8C*qo9MZTuvnzNr6H`82%{Jdyhptg_V& z!_98L1K08Ne{^$10tNDQ*t(_f<(*G7N_>w90_jIkZhsGnuh~L)?Ql|vQ`^o&_~;IR z;9@%a^T6qSW5fs0IlwSLZNKN;@pkrh`48N(!N(N{X7|4=o>&^3n!7%2c~M-9UUu>Z zKW*lAEK;4VEw*$j0N~m6Ap`l$A^g1pQc_8ve}Y`yH+=@D5DYPd_9J0+rFo3{)=9DPlv+?%6Mh>u__uqzdDM zhp_d>u$%H*aHLcaWICqD_Cf*K$*PRHg|I}tUae_EwtuKnhx>3GaFoj=5-siur zGtOVQ(P53>^!wGyc$OGRWJ5rm-~X5DJCMDIEU?zp@*TxktKgH|@1KPb{TmbA`+qa} z8HA%n(rq_uvb!{m*EMo*%Rw_V=m{AGMHSZ;$}PZD$vWUwJ7ap>L%AEC>?*qEx$k)3 zH@PW#WbxnVbwP(z7^YxyihLH*TX`NTmpQNaKw-X!e0Rw>^ z9O4a4mh-eI0_vl*;Fq$K^@gGW$yAjuXN81RY^Q9qfpcm_aj&e;in($DGr?NW1R5@W zR~VE<@;Sd5s!ViSK6R?rzFr&*ppE`%JXob#JUqOfe?Dqg@L^IkkGnQO_@t%w;%9}< zNP?uftk0Fta6R-J$ilvp&XeAM1WAwUt}z8lp2R!ZCEgKk5TQyb4~t^QUQK$A>$^7N zoRwZ}`MPO5Hvb@Lf;?gNK3k&7agks^|4VfSMCQVvI6YG zb+mSCPRl|Huy~%TRrpez7YJk%&1I2zN99tJ7YiyW*L9t2=+EhyasoK2(NXZA{vO@f zO@AVLX>qzF$Pei&4fAJ-DKS0^f)v{r>|$Am zYJIC`_HQ!mwOaW2CYp#%JKm3o=IyKJ{&;IuO}^Wxwk^Jv($w$~AnGE8^CsEEAHjyp z29MInyY4r#=4c1-r*~-|8U6M5VZ;ECruANWUD@|;PkzdS-37@q4~|SaEZhXMSf&K; z&BSA0poEhNL5emWOsG?OwU2{E8~@Pv=Axs@);bhn~_}GC1aj!A=B$Q>=oN`SW^7n>9X&k6(1> z)im#z#1sI*`#wmaUIVZnp+r)jtI7)iO}z7*rJA-~SR^bJ=iM9t4EnM0Qteg=XPBRe z$5mtIqCE$F#0mXZo2ld>m9Noe<9J5Yw0_M*iYdKzz%L5%xeb%Qt<<6EPgb_MBSAxo zuxGxp7ISBC&l2u6<{S&o-nRh}kfB8yOsyZb4A?s#IxcIz;n>Jdl6&NO?P$7+4dQGl z&7Ef6dK!rl{N*SD`F6glO#?hu81G&LC4CKC^T`l5xfV#_R$#e%tu}%C7LN+8AuW8?=zC@VN}?;#h{+PiK!Za!=0J z4Wry8=?Pe~lE{oyfshcZ%3NRF*P9;>);Q}NF>Wr340~Y4aSa2ic4>$G4jMfGA~%Uv z$>jz3cLn=cpiLgxx^EZv{+Ged!RIGO(LsQpThc%)VjaKt;fK`~ig4!rQ7)|G9+^eE zX$sY<4%=4nBMVHjci->Oi};L!bl6C>)ZZziDJzwr-fDQ3VcmCr9EPwnev<{tPmwHL zRX=}ggZxctW^E72G0o@n*IWNnE+#CmMbAGxU&<}Y%N3wWd33Vn^z$512Q%Y>kjZ|Z zRZJb#jRZnx(g-Qb7TmQ_ee`}whV{BR8adf1#BH~lvKWdNX}?$rW%j`qiHC)N8T{%% z*)yYRJ?Eop&%iKyJ%2L@a8ceGnwytfm`L$NCkOFOqJop%efQyvfCR;~nX(tRseP^i ztUvd&W0EU%@xuPGp4O&grsVd^K5@W9mxH#OsYVpW+-w!XLYVq3uDjzLul21y+p8dn zKMh1E!|Xf?fj5gq_G+o=O13>tIhtrgNi-~IFGLxB&mu1hCY|K+4T#E?aL{YZ{p_;j z5%|9jWDDvg-sbmC+6{Abs}ji6g1)y4Pd0A5=f~Q??u;U~K5&{{Ik-mt1WR6!>d3%m z$-{|qbcD_9iT}mBpp`Jds_+l1LWUc3cJ&jcT^4DU3%M3EKJJWyBRxpu;Jh6K`JJoa zrBQ9YhEn+cj@nTa1)((ZK*OWjwu=WhcvUuH3~tly`TeF`MsfHhca`q?@bKwdM@?+d zLyqWv8qH`8S!~p5G|??d9|{XvJ8%$nSX-E=>Emy6#K=I3wN-x1yeU=X2g!LnkJ8;m zeb>-SvX^32f2TH#_=%74t_+&5xqNhowp9IpeVcA*A7|+XL@+ksvFGMlFl^ zwb=>p&ap--`&8d<9kyp7Yhy6x1K;W=Wt)m?WQ?Oa^1thFE1a0EJvJ2$PI-_ok_`&c z!&~O)CSJR2@S4l-?cI$5jVy;V+lLxV4?klRM(WxZs;zZPE5zE z?nbtFI(1ceHA?Akh6oc;gpc)S5pKqqe+ndbOK;5OO$jP+v|58++6JdSAAE+EV4G^1 zcT`x)vIk@-kb>ORs%*QlqdyF6M=eE#W5fF(BBr!^az3A~t2K*z0in|16R41{L~WSh z-TOVqHMW7-!Ey$#5VZ^DBxP^khI5Voe3CEvX_heN9FLp_q4MZ2&N9~ayjvQt%KK+- zW^_~d!F7aWk0_(CCJo0%Qw;n03T2OzB~1b9CFaAvAP3IR{4RISP&ih5+wPp59xJcI z`@JUB!gXGoMT-~n_hE(eOTK}yPgf)cIWJ-5z|2Y*5J<5y08ZNsrq}nx;*LmPk2358i^AI*gcnx2Y`-h6fxAfAJrmK-6S=FUL1(F z=#4H2LQ6WTrDook93B2lkx|hjzCREF{i%#TbU`MEqY@K-mbaNqVFv~vRMzM6a}&2M zUNkJ9yw3h2q@2`{iP-B+z5TulUwpxes+jW!@XvD9nV<1RCO!*3;YgIqOCb?2bpDjv{?dal31^@ z@#j|%zGcYnmTA2FJUVdewZb6U+0IZO`_I{4d*kcq`Q`G*=AE)T3N*}C>)I2H$}C!M z@Ru2+hJNgy_KwE)J2v-G$x3xGid2v!b<$5k*}=g>I^)~cJO+Syd|W*k&70Bljnv}N zctS|d`j7dZZ|!E?k520e3qCp=txbBh9M7;Fzsdd(CTf0lK3M<5Nj0-zhE_k1#A0<> z-z~34QJ$6X#chE1R^Yr>0!LU7=DbJpyj9C4ieCj|3l)^y?KqciwH$XUds(&5NpG~J z6rB*2!zd>?paF|q|B>i65`83BhXIe`GFWZQ30E3^?%^2XAXb>;TOY`zepp8$7 zWX|&g>RY0hAjNk;XMV;C=Pj2eq?zbM>II0m&F)Yl1}L8UkUMAILfouuFK;$M{>T4& zGVOp`p000@bW*#_Y^WFgl!oa*IT*EQJh84$HIjR54dPK6PZns<^MkN}?WxTx(Y{TL zKS~%pNfJgR&0Ht-L?TyRE1$8N?$6>+tE);HBdX5~39WIu zqF#wS!_TWl6SXk9&wD>!z*M?s4@rv{lpMK2Y&u1?L`UPM*-;w4N(xFzGqWEzJ|&Z? zV_yn&K4l%-yBV8Y%Gl&J0e-NeLi9N|bm}2xGC8y$A#6B6<>AQ&9wpl#8!s)h#}j#} z7_7wZ+VgX%_@^pTlOSIeNqwJI>8JtZur%MSS`g3lH;|$EDs)RG7?^Fi? zeU_z_(c4Z{k5BuoSVSL6h;@*!SC9leaWG<03*U|~q1!78aQKr-O`nzhSqithewkO! z;{$KiPF3E3mj4PDTQ9}pBwx|EL_X&+FqcA3<4*;0c&C{cO(>hKvPH8%w5dkJJ^j?I zE|)8zR^57=Zjb|ClPj*OsJS)-oT8@xTA@pA;lO1qvR?JFsZ32qQNrJI%R%jCA*;#9h)BbKlK{dfu3OD^N|KkuYsTRw z9NU&Z{BPRizlbO;LI$U1pBpN8GRJK|>{To5qe|@(YMf4Vj-VzkO|to~=&C+^3ibaJ zxMygnq(6}8awhjMN2!den?d6a`sB4Vbm+VMSbQeiQ~2PQ=^=4b#85;HD2ME~tX}QM za;|MtGN$v~oT-WyMN!I)ji*NJMk0nzbwJUTwd$_)=pIi%>wjQo&Zip;vP-TuV$;kd zxk&d$Xs7ZTfe;2+l>L9Q@=$Z15}6#4fI?2FDDULQd^$>_k-|&aGBGPrDE}wMECwy6B0* zq~4zY<_u;z8qj%6CEITBYw-}Idt!uqR^k+}=^z&riODy4xa5biCK115CZP9zc z-CO;kZb^!xzcM9Ue-Fm~I6*|&Q`tNtj{cIDIY0O-qI~qLVdhflPe;4WoWp*8=GHGL zufb2VT=i`t-|+#nMs^JFMIo0uo z1}#*&pTU?`-Y0YLY9%G3m&tD4;c4jZVnU(8UEwV^!oNyQ1Z-7nG=2eZQU*3<5`{j4 zrPWHf^FU$sQ?iUSE&Yxke<6|2~R z$#x}C&H>DLzXxWXEoV$+REC;& z>%}y45h(Bzwyd7g&SB%;Zg_9e#z1k}pJ_5tDCDpql%he_3?x)1rIVYWH-gC0viC7B zq9D_P6@f)Gsw`e>hc6U5LtPx&Emz(@Ncfcv&qjXt@NnDmKREb$2x3coRq1|wdV<<3 zA&4!$(B>31TM+nDnY?uv9Ll-e!bt#mnJ8mf@(J}Ay}m3cM1d?&>RS)57x*%7)a?_k z`IO+#eskLnn9+}(_0eo?knATL62QB*hr|a-_{#@qMzIY*6kGj~KfVxLix59mrp$fh zO@gCWi427Fh~j`)!Kv~YT~#4hTqs$Xj9gSa*5U(7M;azXoV_duH$DDFf)J0G7F{eH zrM;v4<0OHeSBrwjHHYq9^B==Bx7EgB1XivP&JW92oX#a5M4$^u*lbk#H>fSVeSa_D za+7iA>wxnV+*t7!{8N`X(1ev)ruja~?fOs|c;-PVRb7(;T*%UiZg~_2TTqK-fzb5g zod~|(Hqatpti@PPqH3R!byCF7jSySA<<|B>KJ=B%&rQST6Gu}7U~`1SG>CcW zDz6ZzQyn~ti73gx44UYjRFwvKV7fhz!8y3} zYO=i*V-8G(qwW6wpAP$;Jfxg+C4Sl$)Z6d4B~TvpcC>~WB0vkXL({&GUb+yx=Gfc2 zQW>S=(bo@cMt|ByoOp0(09n(m?G(giv_>m4B2w5tuWLMu4Q~tDY-Tl^^W!yMG8hS* zfbI*X<8qZ@^ouY}DW8zR7qZc1Q|v}*)3w>munL|3KFkm7FG#M;VzJiUQ38jc$P|G$ zW8T=g#t`!;qUduYl>8hqLLTq6{IkT&<)7-XlIYz-;fXEUb!4>%pqL%kM zfVecVe*h6@SyN<*e&_E0kEyQ=h;ob8J}L$!EnUOVNJAQsUfptdeout_ z0?9NJJ;S%JO_BgWkRvDbmR$(+z{x=WjBw^VaGY!RkjX!}<-ji6L0oa1bWfLgcQRZX zS-I)W_nX4~8oJZG%glVZ6wYLBa;tNV5VG#aIwtaArzIF18D?uwF*Ip+Eilt^A=S^l zODlq`{)e^my~}(A@DlvXlURJ!8mklEqXSJTRW?+7jY48YDnF*m=4j97(%HE;efs&4 zorRX|{~LGkNm4g9jo-G?Dnr<9SHbvzU&2cHbPDwggBQ~0@x~L!0o72Xsk~tDn^X%p z%7xi#WWv0Rg`ttx$5K||ZnNuX0mpW_M;S)qPhS%~ovcJ;{i@ z;1^*%uah?QK=}b6&O>LyXz{fND{4QHUTL8Ai_! z%y-uAA$vWUHS=S$hHHR*)G09Yzt#5B=Ym{bA#nUgLUNIB3*AdlN2~$m8OV=Mwt|<{ zPdb!Sf1%^Sd~D@8?uf7|j;hqO7E2eSr_b!>IT$H##HM`#T3mxS)-7#hY-*eAT$6nMb7j zQbYl>`~HBzJ1A5ypx*Y-NrH?F1I|rj7Ls@RA>5g7_@?LeW6fO>Q49-}>yRlvFUbCd zZD}Ev(Y`O``@!fui@4as!r(haFV}J9JK|a~X~sT}ha~Sobj%4h9VQ>lu>V3*%JWPn zf+J^rsveh`;!CdU2P?)S-Y#fWhXS&EjFPpTU}T@c+Q-311uZK-Xc)W5o;hWh!fan; zIz_qkO>z^T0qha9R99%T_G;mQl7#nrcFS1tvyirQMv*blqQ){9`P7AwgUdPh!A?_W z9;tZ8CRYTo0n~gDRE8NT1NRM^abvXsdNvp#wNutCBgYWy~X=Pg) z+d>vltFH?XL7Cd%EfPOD-08A~FdR;XK2aXp6ph~+bzexmG@B5;W(Up~Nj6|;a&R^W zcQZXhsSC@4bdQP&TDjcHbCQvSvOhlP;Q&*GG$AV-mP~4gwp_UM`Pi$BKdCKKk95Q(}ei-_!dmI=JD&_3>08_XCT*Qs=X}XhTyG;cf zO;cMZIMYtok^q&<*eT?>n#s>97{rbE-PTk;!t(>22N(SUO?j-@0LoTMNx^J$|Ez2f zO&fLf2-f8TNK?l=*deInPyPkFd|PgJhD=>kpkV5;`bPsg6kNXS_})K4`3{u>rjb=Y zI>Al?)P%wYs&@WG29e zR7fQrA<6FR;Mq$ot|qpP0M~GepZHAvipV4zA*lPIk;fMh^D*nNpP}(UfHG6CC3>Y4 zY{v{QJ)rWV+g7%Wn9K+#=h(<;0XIQWJ1}daU@+rKtM-KA0x`0D1Y_=NIZ|;>b8hKS zQvq9aFL|W|3Fl`M{HMMZZ{P|ir7!QWob8hM?xg_Fye1`7S}@Y-4i4UnAwaRLB3JYj z3@5s`veTn~Jz+(p03&0$AGt{qL@Nua?<@(hu4VGFN`F7y z9s9-QJ7|heq|nqOk}=e8j8ZIvQNh5ZT*)=l!*)~1#4*NnX@>}F!MV9_6BYk zZ?S$M0Sg#emm*DCb@ZX1_Y({0aj&o@FatzG)Mn#DWIB1p1iM^CW_wn|OZoigvq-or zY=f^rl@xd;BmxI%gV{m(g98+P($`eY^H#GObJr}n1HD5wL1}j(b5^0gHw>MAC>o^G zqK+XGIR@W>QK3EaT*_bNtIkw4AubkEx;tb2L@5Gog?XHSTU4x%}AykTRhM}`~8_^kMK zTZM3+0f*n!F071=yt@$ypE5@x`(Z5b>t*1JO7$J%t$3ECi1NK3H0Qh9Y4#x6WM42Xt31MU0O z+^^Km(>wdeUxg&oJ;FJ7#gD=xeDkSF5Q1w1OKI z5i+o2lCm~kHYur`(iDbUSwkzk`=C3SDC4p0EEIR%KSsZUQ!*>y|>c%&* z+FT-!qpwAwG}l9LmB-k~`6kshtOu3n{Emg9zW0mYAD^$Zib_~Mo864{ylzkM47mQT z1BGzMIl*p2QnKiPXIt+1spr5zmez4~f!W>nVm*iyPW8hO)Y=ERoNpT9_H2Wf?g*7U zs{PVDTy3he;dr%-oG9JL0$|#VVn?xdQovUy39cv55D7Iui6)?5<+Vq59jQKc6yD zAht|d4U1J}KYb|`hRuBpW1qKI=qGLzs@Pf4n>YB`$FMnx@ICePjsT%z3uW0AS?0Bn zYp?{EzxxZI36!sZJ%?sq&4vl5TR~!lYJX?KNWqDF7VJ`YBZP*pUWh~2Aix3w&2(E2 z4$Q>a;iSbI84B6p?^^*!m8(%hdit2MICZ_jWuX15GUr$ECKi&tSHNnXF0um-F~$M+ z!8Cg9Pe92=ly4f~3dzT?rugJX&2Gbk=QhhMEsAVTfDeEo{eac0xoE_H2=?>aZ6mB! z9i=l>rS=q8ge{f*Q7w$>!1F<@!h&{VRZoHQ2{}6%oM)0kS)pkbwq|I8+45?E*uIS& zsJv;PM}VKa9+0o1aFNRbr!Mxb%STLbcf58|@>Hb;o`B-$?sW3Dd;LIBTeykmsbh2Y z+U}8kLf;A$Rhmbw9}SBi`C!|;i-L9;t#_Oh-W+(XU=Y`9benMZmsr_MOIAS9DC{|5 zVO86zvv=>aT8EJ=PW@54D90V(Kmp2Auowwe$}DP!`CPc@NBZ>UiTGH<-LZRGZd2z0 zgl&E{5{$_m7#a&7y)(?Q(#c-nq2n#{jQLZcU=X9Qy911+T`Dp#x7nlKgO%8fr>71p zLKHmu(Uw-{4LwQHV+B69CpN6!NHYDs!}sKRp>X-Hgh+?_*tdlTuy^ThYBW>7GqWdB z{)Aihe|yo7VtZpQ3U$pvTHZ2<;~?FJTcJxTYr0MIOIZoV*SP*Mw{59r<~+fhkAw3!u%WG8LrR#q*{v7ED*gq*+MoDmeCN zaqX?w^QqmRe656HFe$s`2h~34^=#A1{|H;MzF$K>l2G^$V*zq%kztygg~Tr?NV+7Y zRvzF!u;dbvB0M<;bcR2FFUCxX=KuVo(N)g2UMQLfFZRE=StcTnfP zwbh9Rsx^YMu&h?Y}Z;2k`wn^2QY1xsAZYd`58Z17m5JN1#fw*2AQWui7vVC)FAw^*~ ztNX#k_DZ3>^6IrIqJ`Ag9wQ`$eG+A^D>7Z=U38ZSmIAxmv1E|POO|g~?$f`ArPcQ& zXO#7MSgGEmE>~=DS}uCP7^a2XcWS^$Xb_@0;X*CTu=cuu<%Q&q+UE-?|D8?l zy|%ND9S4}Gw$frUQnK=`W{5znRXOpki-O|ABOhpJ+r_(;tIzGiJ?+HM6QKxmTYqrm zO>al`JwK)3eVCl}pv>=u;rYSar<)Y9z9l|+LX|g#)%-5HWJti5b3EG|=lRUX*h3sk z6TKfX#X^?P(@g&bL^7Gf9Kni3B+J4}!B`6QK13_7^f`p;a-}jO_BJGn6&U^k;MuuT z)DP+rnHwxG7mAZ*TwQVx5`o2;qpIK#X%U9N|+p%PvMu7sBgxwndK2@B1YA zl^pet0_uYvr6`zobZP#(1J0-WeP?=~`NyPx_-mGuqi{{0zkU6S100L%=d633aF*y4 zfcf8<5YpWDj^^sixhtI@BKeTxCL0{+x@R4>vtVX8!pJHdCL=nXOwy0(HV)=WjAqS)%Pw|__C4KOn`a-m5`zjUo~5tICJ8OB`6cd>Ob zTawP5Rt&4p;~Bab%9GRtUI=7ZSD1eKX^3(vGl^O8B5g@ zW^(N2?W|>mK9~u|glD@34=dS7Fa-AsZjEawoZP)5kQZM3ph}&X&QWlF=9^J{3>s7c zQ+SokZgeEuh%QhA82*%ycaK@$kPPGf>+J20B+VkxPJk5f5A_w1m9#opyk&pHzx#k% z)iV-|DD1RgST&9JkqTOS>SJATGZr#GVA4!Y?+yh}O%c=&dkd)@(ZXL3u)akGIFY__ zfFNUqY)5$SIUeJExCH9VIdIVrxT2VhUspr|Wc)FN{mh{Y^H~iFMI!o|iJ1FzKIp~L zdY)1C$Uy#54;u}oooz|-OHITm+|8dJHd`k2tTrj}0d+-A&mYjRWET2(OKMgT7kH^l zS^rn3dUVjnx|iu&rvU6w2Iw84pxJ_0-sAMWstGH(3xA})h$2jDVIu&lzIpW8EVFz= zO;tc>vRw(qf1}4t$ii|Ksx~!DM9(BhG#;U2>>rlJ=lAXh!*q?N@Fc%DL)o!>+iN3E z?L7ZAJ4VS@d4`K0&b(7L&ObRz3Wh_?%<4VA)-#?X*ua*wk4U950Tf9r!iUL@D?iM9LEP4y`y#Y=)M_DB(5nZSz@C)hb-jZ@)6skK z#uL7BC@w7l*RSD9(Te6I>Zzw^k*+_}eAH+r@oJde2Gcr0`4|Jr$AjYm7H*=tABFJB zpgzym!V{Or2ORy8XQWRQemuy`zuPtM-ETWqOX?&+(uZ(hb54f2($T2{lo}3sG5ZAW zc6uL|1w&PXND(~KIjFLphRq`ABfz>NsCJ*)EGDI%Pne}YzM=vsutW8;23x(J)aoD| zob4yT8tBx)p1p~g&u3zgh14p~5e8eegn(-C2VY74k_R|4yIe%#vkCT$dqVT6Fd*Yb zqkW<2Lx;weV@rc(Vzf!i;jOJDVR~d01i_p zF>n->k1=G;cX#mqS}HI~@2rM3L4$d;I)GwYl94TbF5Z5kdJ zdn*@g_vuQ?Sh{oIw7}R~I51x%#O%*S1ppn?OIb{0Pz};@734WZd=_p(q3K_IZepW&3bq*aQqPbmbH7a!bE%ZzBqu zhM`6i>mAm6BM-g0O)g0d3DyUh-}ZWD3tU%M9%LdW+BXHep6=Jv z$9k|Cf1nPlA@_Z8kQ?euC$!B$YFVyIJ_>O5s$0fv9VKRpXSz;ZKnt0ZE!H;(7V>sN zh;`tHe)80h##Fxw8Z;a@$Krnq5%oSQ8(3_pI}=w@)5P>QW>5UO^9teFv=W~8lb)7w z1kjC3muQh|%w|L35wyw)ZrM@4y?gib(@Hm8@je5vg1Qz_qzakQrn zaf>ztOc}%X^JDXlfso5BP;;TZ0yyC|5##i++H6h+(+|lb!g2p58Q}fIL!nsps8JgYa&17KIHOP3_CB5!u;2)fvh4R19|k&(sTEEVaO-&- zq7EJn?upx)7O(zw_$p6&Bb_=z^}8h!Qj=M?-;7$d<=jWWC~(!y9WrqB@?#&k4BqZ! z89!U*W3JZ*tPJ5A#iG-35#4r*ig9(p(ytDiFE=ksXP{}@d*i>DNdbk}+q98MAbW9) zp4SKaJq4sQP8|eGTSnm88G;37S9 z1KdT%L1B)#@fyZMNO&zq$(($#?~4h?jsJ*1=ckSt&;E1&(YcTrBp4;TFd6Y7`wxBg z7D5Un7pkslx33v+h5s(#TUzU9F%)lDqFH$f01a%lqJG>j0O;Vv4t8AY?O%zXjvH=Z zu!`p7n;R_;Ilxs5DdMvnqzBYsHry95Zwk}KI!&Mu+PwKh)Iph`>HP7=V%)Z8M zz*hkukQEU!G1aXwhy--tarDEZ8p0L#9zcg^PW}GKyraX_+|#dgoicZ}X*}L+JGIFl z6ldQjUpSRLl;Xdtp-1m*_lD53I=DIYBUhk_E#GF=^&RhC?Af2d)69LQ-r7k~-}_6@ zH6$`v#LM^7)P(0b1kDsLcegwJ2~YE*Kv@u*c2}mktVU_o&OLF!PH+X|PQAVl&vUCx zn{K?@u%uO%jN7RC{$2Ho5g;A74Z1`h(5xVR@;`t&_$_S9tAp;ltNDLUH-}fh&jr+8 zhW-hX<7iM9H6n~aVzMee0(J`U^bSZ&juCcfk;n2}q?a6EA)GNVmSdO(WPf|=xLAi+ zqJkOalmIpJ%lCInC)i0n@mkSZ_+sDrQ{^%2D#2DnX0n=lLi=P5C^QcN^Vm}qTXH4--d*_2|&dG@ChLxsjp(2nyg*QqyYCFNv< ztKV6!<{ATk^uQsz}-8#ljYz{D|jys+gv38=6co;SW4A~V@3^uJxxl`qS$eL~dY zm$(t_GJiDObI$p^q^Vg;8Guzl)Ybc~?6m|yz9ud$B%ov4XU_C3LU3Uv8+FS>gmSk` ziU-ZCvltA{wKYUPkeNPYTXtFcivp#O>g+R*Tolf0>}#&WIz*hJ!N`oAS{3IzUxmhZ zd04DwEEK@5dVhB>3>zCK#J4n{Sf9@NaU^+|D%8%yH~*Q)T7jwCdx?YqAj#rtxunsS zgeHDJ%qxncW!Pe`@;G{eV1AQJAAYN{}6E|L@%Af)uLo&d%*L z!GC3?zdPQGIb}gpJILgKMwN3?*HTXc*lrckqXC_!r)?da`kgMwz7DP;7S|>}Ml?1R zAZ&-4H-jkI(*WfR_!Bc0t!4)zy&cqQx01+*RvXN%7YFX}jLve3R{);EmxT6z58L>4 zqT)a&Jq(rbd(-(#!s?Eu#Z*N>(yYL578N%3Hv2cL*jj%OCF3a2b-31 zCspd_Z}tS>{<}^Z!(_wC_xu$ar)!t#&arw^>=Y5~sUjC$+d}@<75qZ}Tw}=}MX4{d z4XeN9LO174zI{CIHr9*osfdd}hb0g?~q zHq=bF#6sJj^NsK~%q&%!UB}_(0vsweC`5`Ng!UL$$;XdZf&o~aI&J} zIqK2?JhMoZ&yNA@c}S+-VEYviz^)D?zc+m(=|*^o1j;1V#7&xSF(kb*u%V&}m2FMR zl_MLscxzU4GJQkzSZbchZtYMHa%RDRIg0#p1LYR2_$Uvt5*7lU3Rw!FgB&t_A$E&R zge!mc4mzt;k0S+KkPkU_8uQJb{^p*xKgWqU6GLjn&!*@CSVN~fx>J|0_77v*HyB9A5)9NbQ zRZaA7UbIN})fVtY0Ti%uJ(++4S8unDt&13vg>IR%08Hp6d&yw zWAu@0p$NxYPAb^w<=0UW=)H{M@g`+%{{$@#? zeqw$A8kC=7w}q?j*SY3}Fk!&7qHIJ^3x0o&^B=Th+C4H8fl_8mhE;+YuJOa**lnQZ zx+M07xi_nU@)!e7T4W(R5UvsUQkKfkj_WY-gIK&O6ITedcKH95zQOA|Xu>DCH_n(a zRW zx9I9_aul{)7*;tuV1_fwFTYvaKC@e}UO8VF;p7uz%585`V*Lz6QosWJIUzy4EHKKT z+p571)Hkeh2)tJNxxCenUbIEM$L*HVmDEi4*2a6gBAIm8GWO;rn$>;RadusmKYVY5 zcj3jLIvIepfknwFK0pDF*TL-OK^;5*E+b9%K2^mX$G5Z^vA=0Zu~gAmB9$Hu9|SGq zc$)2mzKdM9RQi9a-8xD|4OKLU_ zco>Sz)Ku9FXV?PH{AH;MoqjY$asX%@9VaYAZF*h*M+vY6);k(`o8A{2LGxEskdf8N zY9Lubjz_O~RzMEpWx@Xoz0f&Xg&!go2tXN-X+?w-sE9O~t683anRBTf#SZTo`Kv3` z1M@E%Td5$%T-xObaAARnA`g*P2-Rh;DJx=cduJZ!xYv``7zq7~+&_u-FS%>>=nCB} z?KV_`X?@-Z$WwIvGn$nC&m$1{Q&OcP_I6)Ea2NTk6#$r#>mM&CGHcB^+NzHW{lvI}_`~JHZj0 zSidVjM*h9Hd$Z5!*I$Ga;8$S$Pp&_Sd%0*>@h)9CTgySzOH9 zbGgSDTbufw=5_|2y~YF^ZFxY~kfuaGd40YK54QznNuAfX4i*FjPZ6?ZcAS|x_zMs* zT=;ic08JBi)aXcW$Cu3P+=Om0(&Xa%_~~Y)-$=OGg%!hz3{ZnMG5UE#rw_o-9n_OgjEV8f+Ny2{@KW9Nnf!~uV zoSg5OcfBx86mV-PqNv;1v|47I;LRM%SpLQ-J$eB*%8vrY43u}1LqO=-O^2(3JR-z~ z6Q~9?n~!>HG06qU_`x}N{-Df{xl&2GoGwXqs8+lazM#~(xLoWb(jLG%KTQ$u;}|>3 zSarU5Q?|r`w%qhBe$<}vXNidFB`^}{rT^i zLT<@d%n$Z_-%K<>LWONmW^AsdiS8V;;X*wgrN!&ovFd_MeIF5hGK29u~u&%zfM<@CP)9P;i%k`yI})j#aEvwF;P*3uQ=k z5pdk}rQfcontqu1oN5uPZ+2HARV|iKox;Qa!?DeI#>bIk;>Et#M%&uZfLRBksf7|| z|8K(j*Rtx&>Zl9sc{oup9{v#c_eER0}-U7OU_!fBxC z2z*H^nzv(>(SYbpo~!03-BCivPFu4&#AuUEBo4cFsw&B-y7d4-on<6sJ}_a3boBmM zoPCrKTO?vKaFdvI`w`iO`w)3#IGvKbljWDSSigF&Hm(faVKN`0(+f`%IV9e1Nj zI}vw!e{u#B2dXmy17A@O>9H)I{J`02r3EtYj#3E${{PC14Y_j>Ot0r#dw^!M@X3k$fm8hSztxLdRH&m`YdkpfKs=nIiTk={6u`l;Cd;T)%*7+Q&Nx#c$2 zu8So^S*S6^ahhOo8}J%urKQ)$_l$`iv^}l38IHrd(UqEl9Q>=;YG-lve?LXo?a=Yt z#lIEd8lfoh+M4#f28_rJK<$0VeLl>0EC`@rienRWrWwN=Q>`dD@t*x&bpc}2#H;C2 z8iQ^(7P*_n;%70KS!jH?#;J2Mzr!{x9yU(!wPnK6aAIMDvDII{B&|~`+AkJafN*Zr z^-Sn=AM4gV0FNn2Jd#i?!CP!uOJmkG^j<_$&XQ+@YhdfW}72^t*L?(C`ng`idizxR6V8oXbzf2`{?Q2VbCJOSwArFVkf-o3J|Ss$T45Sx~pmvmxaul)_?k)O(fkDc5#P9P@-H?yQYV0 zsC#EWz35loUP+0LL^?LMc>%{S69bfP329Maax9@iwrFQW60RlQBz^c7c9oq;H|k=% z%K%5L(7s49@FBc2fD`j@xt}sMpG$>_{mkBK?lWSGEspbYx zHmf(1Ai=!Ef;ei(crkTy;_O$>H=*}9j@n0F1&8}PXsPIU$e}d+rTDjAhu>@_#lkmR z$^08$!yAo}3E0zN2Pgq|^STdWZmyhSc}tz_M+8v9ekXkE5Iv5NyewzPjVD5b{|T)9 zMy4+Oo1GjN3|C4r!?zqs1_Z#%(j{7mQgW)4R(07T*kYF*kT(=B^B$a5gAv+lQLB zhs&L|)P z2Q5??an%AEpS#ajrHp`{7Ns>rLr%a!e7-k?@Q~+CGiop;9_L`p?a+Q3@I~eL4bT<7 z#g}Bmz{+1_+Lt|v!0EzFnFPbX!tF^p$6u_eporC~Fm|oXPt#SFyR?h`gMQc- zZ`bpv2u)s>K{crUx$}UuHN4lek0jN&&sf*pKnagf?!dUXf8IS6TN$0ewE%>*v`9V3 zy)~6Q$n2@BGpxPiy)EV`Z5-6mf7iL|o3LQ$#EchAD;(kmTyGli5d{!Uyjr%S| zK>Vd21chvhm^WFq@(~R<85Wi5KKbDA9lva`wb>uhBz@$?{{3*yh$)N`?zqLzie@uINDV*u4_<<#>kM z36R;j78iZSl%)4wEenMl&Sjk=!K={A+niA1z48g9Xw~UicXijHU`Y(VROi5lV6a`% zH@I3~xlw{IdTKQrt=k{TZ*YIn20HnB6r=*No|4Kofq#ytNUcHppM$inN1Y@)p2+xfzgZ&xcJmR-aYeR986JqF-Mu5%BM?)m#w& zA~u_Vo!t~Vc;34Px(j^dVbR4c0t=}SFO!nIN1M`&B7g2L+Fpr<*4GD&3&TM~{rUTf zUT}@4C^-sS%Qov>v}bKxQJ=OLV2C8?iQ-&Nq!!xZ7UKVOI->o(!1$Tlk(K2w?v~OU zJ&!+`$=zFt8gz->|I8}8BKOwj!smyU{%uNzhQLS~V>WR}@g12m6kG2b!R(wuY?HAb z8PGrajn@CE<)J&bwI0Be7u?<6x2S))@a}I`B{klzK#CZGCegsZkEYH~$B6B#*Kxs{ z>qpC(x2FJF@gW&ywHFa+WB}qu?0LSrg5P05%!`G84f{Qnvm$n09ftOp#D*fWKu;pa z@s|k)AXGIyGi;05rs?^<4|@vSjks#yk#i5f9-1OSVp%SwnL%d|di-CU{)ma;w-O`c zmkHk*G#KVID}J)*>H+i*vO)+wnrNk^N~sK=A@!Y*W7NTC@QJa;#Z#dhJw8mCoH`); zj3U?Btq(4HA6I04Yj<5^W0=A`3P3;iYQ!Y}$d<=lw#@iD2X-!p_AO$-lijQ3+55G= zCAvKay`!t!#3I&oUb+1IfnI&B#O4(KFh6q}&bOT|Uy$v_uCK3`v9DFqwHe`+gafP@!7j1W_#srMA^gGjiOF%Z{yg2`lY^HH__yjP z+_hqNh_Uqp^v|o(DB2T7AXWUUAB-gmxZppBEcRY%O@ZQ0is-E}#QvL@ljWb|wz}BG z&8Q`y2yvr@c!#VUv7!sLy`lGoUSt*hc>Gs>5?CR%Zu+)fxesvj<0`4Gr?gAE;Sc+a zi)TU=Er^Lnw2LGd`UbfQ~_3OCiPf6(FbyoP**1r z_~oO34NX9pujY#Y2e`XT%6rAmnYQoP7b|9G-~4u_f9vkW11XVcO&ttBXBykD4M`g| zejxv4qsRTuJ< z7`*!a`gz$AsNqXCP{&6z`S*wL{j=U)L_0!-1Jvc(;*-V6_n zs1GonC1fRT>^AQqfsSWMH(8g~y*ST!O@>+|7cv>NpqCj-BAUUQTxq6}0bi|vD(+%yZaD;+hJzFUH#cH_|St5 z^~8MLmhX7dfk8X_KqRH=w!iFu-NM_={FoMff09C7p}qE9>72mes{$}?L()o?fu2d} zpkm`&j7`6myi?ozwMw+3{egCi@ad_G^ZPAO^GTu`L<1}&WqLXlB!Bu*8#=aoS^QZ5 zN2=LP;#Fmj{t~pdIDA^I^qY**>uZJ>2LUhsJx7^8I`egmABcpv_bPl|gY3K)p_DKE zm_Es9y4uE0=K;+b6X3nK;s3(6JU>Yq;QuGHe}5#gEw4!i#yHR~{y-!7`iIZ=9wbh= zYjzu-uLs`02n{;%+(7Yn8FhF3YeZOf1*pG&m-dRhg5egvmnE>tC#FN3EFU%5smNv{ zr;mdE`E|1^47gh4u62zCBf9ff!Fey(e#m!@g$U%Q%NEw&VVfsuziuJutr!xIl*=~a zRnF(1%@dAa(W_8b4eWq*$a7^rQB=+`NQM;0BLzJX4;s`ISh7Z{fZ zgc}#k1$|O2rH6y`i;|a(ZVlQ?_9>3?IUp6&syAzyH&4H>M}HE|zHvKy*X&aXv?AYI z&eKm|0c+o2!Pp;S|MeO&m$I&j*|!?1+he6$)+_xG_e34sBb)`w2O~vM=KD!9+~@A& zrk;G_PN>rJf>=qfP$(uY<+P^mF=3?p0ydG*N5mS^hmVzGLG#aB3bv z)acbPToz`2N+~YE1Re+u9tep)Wkjl+lKH)ul}_n8R?IuSj8ns1W+;Y*!J7P>mwJN&63p){48aI<$usEBZ6jk~4lReLuA zk6A5jo&_PM;kuo_0oQHPLBF5R@e+Vw_1!kOXFI+r6VM8UMMbAl$;RD1v*0aM?fE@1 z!+uu|t92^0h;`25kIh#9yf}g}A2GS`y)cpVZNM7b*xhV7mJT}xYie=fm>))u(UJK@ zelLwYjHJ#Vd_pbsYo91`%^QKo-sE|o2Z+c;tTn@%?h7h2Bg6)tbgB}<)y$ZszNeWG zUT7~}{4h6?Qk#9rK!Pvrv$t=PNTOUmI7k2<3BDjJ5=f$)vSm_Zt#wkmi49l&Wc3ex!8WNOUMi%uo~cg&+amX(3NK zM#MKs0XZu7lU1^kALFKta~PB-rF=-3ZsoVY{U?xYf=Q_=E{j+xBCp99bbv{e;U7i! zY(8dOQ!aOSR3$*BZ20__n5}t!(RniJH~ikt?)}se7mdY{%Dl(zzC5_tFh1@jTxt`= z|NHqPQnvR}8q}U7mk;Be&U@rC`rD71bwNN;87{r{Ghx2=wTOgTdCA5Bzq`+D3KGg^ zSs~sUO8Ay<>Hfcl8GW)*t-`)E=c%uf5KWKLJD?#yXg?m=`YI~&Nt;flAen#Hg(={f zwY#!Kn$2=PDjGtK3e(xu=~h&S_fSzYlL!R%PS>bD`@eUki3`D=wdfCtKoKS)knC*i zm^+Q|;M%N(Ec)4ii(ztSA)(?UNMZ(RZSWDA@*#^dSyH=v=7f|ODZGtZ857>{UX>sm zJuqmycf>LhSE!+Q^t(wQ5N>q?9VlwehHi-4f9{d~pyi{-n~!#`Q0^`+?7$QE3F3}0 zzbFk-yX{vu#{Q(+5XEa$q4KCSy)TWP5Z=CL&%X2({sYc*bA|nME){UXiDxJfg$XN-5+a3@m8v$jOyiisEgnp8t#oM1(apsF|NR zi_yn0yEx$Dl`4LMUmTc~p+*WZnm7zWVVLr)*-WDUv$iXbtqA35vW&*jbcsQik!V!E zfug|2XJx+kU2MBfI-6O=4}6^~V_q3~(I0AJB2PC#_uH&WvjiPapjX?Lj%dmQE1Q>l z@uaQc*T1*#&jccwUtd zI)fViTb3Pa)r2j4H8FdiKLzffIHthNt3S(qUCu2oIwRLDQmS!l_Iz&`nP=j3W%qDx zeCeocTfc>^d9T~+J)}xi==W(k1h_V}6jXd)ETYhHVV^B_AQtqo@B>m$8(;`eq)ryw zfbYgdDR*!Cb;sa*bB;mt;%T@OKDso22(ItZ=~t<#?qs;1m31h?bn2z)8=(zc?JqNG=F0;FgA4G+F*CzoRAzqNe(n8W{HEJ<_M$^OuJ0$=0JjQK8Tw zpCtSj%}*#5U0+*@P~?(MEeUj;&>v<&;Iz>jvybkdxj_T%k&R;1=B1`8Z+VA zFd1<#5!chb?$1WgHsrZwwbm zVg*b!4Pcq1AHQ-as+T)_ss{1L7%stu3c?oEA{VwHgm zJxCF{R!l0;P5J*XwQai%l}@?VQ)T@=YLF=`U!mls6!EejxW3&9t{K|Ns~9aI=9UoR zTzWH1-oDq_@2sEEuF|Dq$8T65rg-=y7A4EkdszQ5r+VIhzDcNhUgPk1`j6ANRkd(v zqFZ8sX+x1}0zoLRNRLd-*bD3}!S7BoY%PLv!yrQSK__fs8;fRU32-t^8I}4H-!T>o zRzud?RCaZ7Z0Is!8z?7v7*aQah}du4nl0r0iKKrXc6(gS=)kL-ybyZW?r9e=#4xI` zG_&#KrC9y5y3uD6RCq0dLPD2Gr58U#ju~+@2+uozNUqDJz2iHdV?$BIu*gJ0LoAd! z69e+GziN{Zh}^wg)|+?84k!XAC3GKZlf9nz!2LNgH|n`W$I5)&b**7$m_O{GKa^t% z1YzE#0kkElNWgPm?)MajbMCq-+Gw9_>(x}tv985IXaZxB*Pom!M(qxM5IPVd)`B2( z!~-zFtVWsr8_u+9T{yANU{}Zf7`h;Ekp3j_>0;7Nnzwo3d3qvXdI$Lb2XB-oUGnXM zh#dS&qjBB6qY=-a@9d__5scd$rle^1^9JP1Z1$MnMF5A5&!9%^$li#rkqX-H3A4hO zwU(tS>xDJgai*krKqoMho`R~Bfqe1x$(%gY>asi~sQ1R*aMEZsCzLU6ip3j;;e{go5N4#Zq$a|> z#J1PeuCfse6nS-vC!S%sP;lLC%RVWd+hlA#G${C29wu>o(Os&zPk=ZG@En$otM6Nj zvb4E{{_t5`1!#9z-U2FDS6`RZ6Ck&@;iS7MaSr4h5SDR|W0J3T@C#?kRBtgqxqZv5 z9eFM1M$xK)y4hH%IL}EAJFk8_+b!)r%$v9xl56f!K2PO(naB$m^Hgq``M;Q6O*?qH za|dJgK$Z3`L$XzgUCa$^f8vdi(V2_j0S``OkiI)L`EP-1ScV&MpHnh3-aHafz-5lO zD?^gsW6-6(?_u+~wut}N0tsblS)xof16lBf0RNqzzohfx+wwW6txstnnxVZnbP6Y+F8O;WOnmx9~~ zH%H_xF;Z5FjXWC{MXF#~wJ#dOIRBgP>!oYTvQJPM?cidvoTXSM4Exv(8BfKl&nD!& zb&V?Uig`gE-Z!Yyj791kRy4C_#i0Z5QXD%(pq0r>kt}&iX>p>DPSgl*4Zp+JHv7!V z%xg!VKv1ciDkban=B?S?fz}(f=->Zh(Vu4l|AU>~ zendPxKb8pDDF26@VLxTd18nPttDLnF79V`$U%=IK2ti{6{q3SMJ%rD!7X@-T4H=J0 zi+d~ywPNtUxpq$|u-etJRd^Tngm5RWh&~MbQ%z;6zM4q=Y#}1eWw~Tf`D<=Cx1lRs zN9hN*PiJD;t;T4omkGArXFH_S|QuewHL-#GQ618^^_V~Lar)Q= zZE~T%S3gz3MF|3vr4^UJBQkBXz^XZwW{J zwrzhl`{IeS#xDY0L4)`gEhEQeTaQzpq+Qx;TQ>q!Z~`GA4CdJmS%H;pOGfTI9=1`% zx+9U)#=C*4+#eSNTz)0<3yFv11qPTgIR%NZ#3?tVA+t%?JZ93grD$}y^wG}Qf^Yq% zSeg_Wl=QbNtj#+oQ6E5cN`qv zG?_u-8GB9Rj$RO!HLF5uTSf*SEpw7kJj?RRQn>fw=ta_X#hn+ftq)Ib20}hN7&~A1 zq�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

qHTB)cQqm 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

M4%Z?`!5Vh)$0DyvLz2onIP@mp19Q=;e~CZ{7{g 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'QEkAz~_~cBENY)Ku-R=^4F2g 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%0A&+$Wp3c4$j!F1KZ7!{~%Vu0rtH-%zgg*+S{|0 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�FVegdvs`tJmwx6EOYE+OK;AByaL`TISr{e+hkehsorcC+oWM7Ph z86{Hm!4&PU7hm$yb;jD=(YaHG6>31uu$AL3O=3c-U)lG^9wyENSWPA||Bos44&3?e z6Vl!cp#=kb3=P%hHeNca_6dS^RyH$6up6{>DcwIx^Ktn(94ThcK{Y{*g_(x8kLLSY z#g>6Zb%!r=s9~`EI@Ml6h)wUO%1ZJ?%c{K&=)2QaIrDHBmuU$<-51!%3m%$WZ-1_O z7(YxcN#gK5fHg3GVm*eqCERceH1_3?Mif0$eNpz~jvnn3Fs2oRD4#Fqtmg?u9;x8H zef3FB&H&Xq@j~Ly%zK8ca+4n7jfy!cfz#`D3$;DRMIZ?Ki4PbantdsOHrW9}ME#HC z{A9gwMU5*Wohhl>cF{Gd(}uen$)-}e_`9aM*YXcMxledH{( zzM-|#+`Ue?wNZMlzX_Lp1@p_YwGXvoU$~31gB=odCWoAPsqQPzl>3q;`cG<$hf!`( z&j3qU{y3FahE$ba1YG>x_o`rB1=uUWFgPlFnXNC#pTTDpa!!huxy(Gj?MYy!-lnDx zdA6Iw{R~X?z)K;`q%*=cqj(7}0rHLAlR&{NQ9WMs+Q6-wOmq9coK@U=&+XWBY)amY z=-w*nqIg0Nim88a?UQt-X7Zf}!kP&e0 zMQ{B0Oswpw)go4XgV8z3zQZKxEB9caI^N`&*@0R5W1eYZpohKBzot4%5n;?KH|$Am zW~+E(_?JDOjIm0nhnzQ|Cdi8SGjajruxmcw+ z>D#60@IUT5uMm&+d&5&|!cdqZ9(*hiQvTzCk3cL(-Sq2!l>9W%3*rN8oWUgmPW$pG z6y-4U>Oyru~Rys{2e>M{t=~rYN`#`i6<)#ZL}nSi3X0vm0yZP1@1nY!M*2 zuwEOc>^4 zJQ+UNzHp&RKT15Z3n2_w8sF@9kBH{@64ZtBIb5_SScuvxFtEjNjXZaVNyZ~~gymh0 z;541Ty=ibw-^-#QT%on4&09-uYa$(TOXo%Ti*`(sM{zb#O((h^t^|)GOOK09DqM$gd5OZKa98?ppSR+u%@A**pj*4 zn`FBkn!Y>J)+@o$eI{$*t?6$}Ke7t4OWG}b^?~rSGyb}39>jRCgXlc25@8a!phCfW z5I~i|1yvbX+hgd&uNZ5|71SWdm;=4-^x zlwe$4f&94nG}L2V$x|Ru+N=HOy2kew*i}n?*Dj={?c+8pI_*KAVQ=M5r{v>;8+~y$ zm+_;F*k2_xGE?(liXA-DGo-g!to7uaAKat|YzD8(XXz+Q^-pT9kaJV(@EBD<8EmS- zmCHUTF&NMjN*?tz&WR0vd8N6)(bUW6S3AjvS6QUPT7`Q)$zEaq_rBU=T2>o{nI%~w{y0mj|jfR#bXYPiGDk;R~smyamZeZqq-5Ijllq zH@BYTSWwfh_Ptva^AlJr=AWz7PBpxDv}NMD4sAco)_3B!PcQ{^(t#YZQE1K62;3Ru z2luk9Y-kR=W)n)LteQ|IpNt{dBQmBUiCPmC8D%9Az-s}-p8$ty5))%ZT4NhL`e-Yk zc2j7HnrWoS;sZJZqv1p1BO+?$5O_^d1{@R5k701*X%>7xUgqd0nMbfWTBG9oB@(n; z>3)d}wu`1{*l{8Ia4Pb)EW9oDIXVMqEEX^&08{jT|N00O<%#th*Qj{3!kqra-Ds2Q z=YtUztNd=NgM{E*x=u9zW(2I3nY_#Fs!Y1+f#E-Lw9y_Z2Suh3Y>_H?T{G---O@e$ zfUc<*qe`nkO|H9shp#a4^U2)ka)nSI>x+|V80}u6_JZ>~C;C-%z@N$IA8X(`R}~El zwKwIgRq?7n>Xwq8w4M5Jf+;zSF+}k*FI>ErkM47A{{xTy>B0=5Q|cia=xgjssP5|H zB)o(W)>}a#IuVlM2|0>yn{}B^5B}J>#6BA zD!u=R7BKM`PHmNi_N1?rhe-n%ZSawg1Q;1Vr;;GkF3#rDzPJnK(u^>?s(SmuOHq(0 zS|`FwJaoBEz|r_-IZ6jUD=GcZ$#7=o0hWL9eXC12tD25Jr4m8 zs`C+IA?~EuY4~hwcvoi?ilS|3f*bLTgMB8D2@=?r%kT744*)Sxh8-PQ2!sVj6lv}z z@^4MN2?h|O4o=R-kJ53|yxJ#>n3=O|=KB|Yd>(I8ln|#GvNZk6n1CgM&a3FdRpMFy zf8Z9M>@bb-m6bBW+J`nX7atkB`gRhSFl;|5vA60(sKAr@zvhxdQN{HhzJ~{f;B`z- z1lC>}7s z_CJb}zyL)sJ2_XG?RHrb{u7)rj?l z{5JP47ngBqkwBAi*}w{)KsLwP^s^3JvGL70k49)=S60B~Xxk@F<^NHzw|srSrLvyq z71aTk%R*I|q9-O3uhuZb$?ES}N$4#MpHD@ysh2({ zEu}bKoN=op_iRE9v>HsBWQ56k%ClV#Fm@ilz_Z+{KVDHJ30=_%ikB5=IS<9J7yMDH zFr6cNzlrA_MHNM8-gu|vC@ib-nQ#VB^}gm6x@W-Q;Okx->jU0EV>4dWn$AIRtAuQ! zd?U@#D`8^tM=u5e^U9<6TyNuN+lVq;PAIb&Z_{vU@pz+8T4eO2!~`qt7!K8>2intk>bCKly40W$?dDI} zI21e~PahjHMrx#aH5FOLtRZrwG9Y~IP!jM(mFr|_R>*Tm+AQs8`TwEkflLf!VV6Qi3^T`ekhA+hY1>Tpu|5m=C=BV@9s}FW_ zEqp-npOr%_n@4k6L;(8a<@m`1uGw0L*V|qKZ%W+3|CM*tuA?|+ty^#0Qyr9D#!w!= z!X9ulnp-y*OZN*Tyor+;NL&P*$0xlBNL|mViBt1dnp=XGt_8#s&0uoxMhC_L8uf)$ ztF`LI{6vEgi zAUuTu3?u$3>oe1$B^ z>YarwB!bm_wm!B0msjTsF6=I7|A|#zwtEdl?b9`?UfzHy@t23d(h&hSonvdqEZC2O zm~VHP;y(ireHkA(L!>C9_VWJU?lKZC=CEb$dtjiX6EEz9eo$;Ov=S=iWUKOcs$Arc^&viAUa+<;dj_hA& z*Kw&Xx03+>tv;@!{do^qF;#ZG%SJ@2Op_dC;7-b(k*}8CNA(?}AWvrDk z4oC$7{9M?VEeN08Q9vli%BIZmGsRl@c#2Au3fsMNykF>%9Zv@d!?NiSZ@kCavN-#ww)Tv7b+9x;KJ_CcMwySLE!EIg#>Es0<0@+DBvm* zCGUX2>G`QM3I8^}`*&Y=z|s!9t6x-#e6XAbD5R6>V8$I-Newr4?`ZneB~Jw%7GNB_ z+|PmK>-~+=M9Ca?*^gH3+KfjGTB#zjN`K^4`H6~R28ciHOs2}RBLAKRagV=pER?%_ zXxdD|8C_8ZVivjGt7uwkyqO6O6hlOw9 zdl@$WPAw1^WPD$}Wq&@fY|Tqc+%WA*EXbkK+zE9##?_pXq1X}rr~RIslR5U&uDXJQPq^MOudVB~{duN9wJ`fE7w$iBncDr@Z~TOh z#vIyNuvmm6f>OGcU*o^20Qo`5VNf;PM&fe(tIYL{6fO8&Krzy}mvrFPr5u5*jssUB zKNg_GE2qP5u=Rs;-=Wt7nUm$hEwHVl2wo=1(sTa4KMzba6y-KFMc=ji)ccM>s9w4$64yQi+N_=)P68yUFM*u6)&h0nA?>C)o z(=_|;n>-$@y3eSn8JA(ol4L6kY&93C?~_oQI!yEemTLS&l$&*Td=OZEE^HhYkgf^V z0w2-rY6Ynw4(iV52ab&-o4;nqUKN48$0EVj^YDzDC2O60K{6zRUe=+{3nM}(LSBGg{v*q3Mt55455GTjU!ZY?E^A%JcH%lV zHCRFKpT5hto#sw1KAAfv#Jin~QKk9!qy(Ax)$et=kMg2Uj`nSBINAg@)RK$8nuaQX zSkWyXqCxsOcK%Vg3sBg0Gq}|?Aq}V2cGAcP6PDcTYPBu?>3t+%u5P(zTTgoy#>xSe zKk@kS%RqEE>>sn`)o6M=>>VZdA9pqntLL+O#ZT<(V?Pdl)Zv0SMC)kF#zVOxCg&4= za&QtZ5UTz$-3w;lo`44MDaw91kl%D9qZr4hwdrGm;K)Hxb?_om$g1m3Me|g4ZlEgG<%xEqq&J&&r`t$eWXw&5E$*Ax`eI+8D`)XWU56}U;>Ik z?--4>r<`p8{TilNco16O^o3{+vEqhES4$GHSyadOc>%D;vIoE(r0i_%mK3O_f7c7r zkE56pyiqf6ti9I{J%^V&yMQ-N$akSWOYvdM;sm)0z1|^rRjJ^;f3M>mH#YmbmNDx| z9VjA_f=->9FO@u^rX{zcw&W`Mh70$Q1{ofDHxU?Zav#3SX1+D9kdb+q2h*U7h4QK| zva0X!oS9LhI&QD?xMO}BkHeyAp(MiKThtOdyteOy>O$zOLB_0{DWJJ@qLQc|Q*ZRa z>S}1-`{mfv5duyHl^+2-#+7l%=_cMR(h@I%1w24k0;ennNd4Y37*TnuNjco8hycUu z_AFLq1=>o@7t1%qoppvc8wyS3^AT5_QL=j@oGky?{*yrMaMV}x-oUMcB%}JnvcajW zUt5vKvo~ur93*-ZSVAZENc>6gQI94Y4Q9UjKPql$TOJ7#oGJPXZ{r5J1^QH_1eF(H{PfPi%_3L(7!TmgHjp zOpR9`SML9adds+|zVH285OF|y0BMPl?rve|8oHaI1q1{nBpo`2P66rebVNlurCUUr zA*5UJK778v|LcCt%y7=xXYakP_qx{FPa99$N!ZWs-aRk5E6e@QxKEO&WoD$vN-Y7H zxFY9RD)HAysRg6SJfvWU#r}xC9zXaG@L zc2zMdcBS(~!5%%Mz5#;#J_Z(B*2~O&v>lT;;Q6{Q$(bV(6r<#ya1Ih1kO$wTY1efa z_0;n(DI@S*N9T{=>!J%!}zL(AVoIWqxA z_W-&TBLVH(1pw#>Ak$tqNp04r_U~^eQ&60c7Q@TZjpLW%N373GY)Uiz>s?|DahpSx z{6uSc02`S2Dd-~({8q~EY-LHs=I**`FQV*uUFA{)x|2!bsAjFCaK_KY-_W^{!D`Ik zkgKmicyn{pG(D<%8*yrOXmH#*rb$^E$MkOV@`DeES@R6rQb*+^l`yi2&9Y(uThxaa zTkUDp>-u8Qj4O4-)5u=q^9zu=BH-7Qp!ZxcG?Y^MX{o!%vsz4OPUpuAhF%2xoE3%s=Q! z7_r?Q^1>#eIz9HtsFHjD#F+GG^pilRVBv4X%9${kLf3zo%UAVSORWA2Q1AP1YVZX({6 z+=vp8a2i<&&f_FgVcIy5XIlDwGZ^sEgDU52hVd0hD)&ygNNp}lk#%e?AS}8mw6CsA zJe~%2LX<|NL=9(J;?5_b-t2P%5;2^2po)txxt6iM_XZjMnZx&q$sE|U(JX@~d5O8T4u~@6^ zl-#YZ1psxtOCqR}w>beX*82=KV}J8UB!0DS6Mx#yx92o|hwhnqisDSERLWE5J>q#O z5`j3MSM(l^&}qwD5cr#rKyNc`15NgxuV0SA!|8kawr4@iW@t*o(pX5hcq+dlR8BmN zup=bZVO>&KsLJkV{gQ{jGM#yR0%a=jor|B_cu0|xo$vdQB-u?IiA*0u#dJw1G+%%< zr+(x^k!jxh^@Y@$X;(Syg`)v?zmKIk-it?%KK?kJoe?(zwmyK=sN7tQXUy(b-V*`e zLL7-0pS}Z6pg>|?)%?E#i7_>6Q@f=v-ltztLTdk+=>^#>loJCKbXkEQd$#9oOzAD^ zV+-(qYNx#)-ou~{J(O_^ex1<3yomgNRaX-?>(9OvUvN+!tz#Y0R%w^b8UNiLp- zdtIwVX!SuLz=G!X=OktjzE|FhUs2%&a5sjEKg#6^VCoxSQIEW4TdFUAzE&IYWV;D% z&UWDQHJ4-1`dh)6)%qV&6Y$F3;I5uGi@<#`3xdUEoJmf>{0h);@2*C5JP&81`bfHj zgWm|<3xLv8Kme$Q+^~Gd%en)~so0!TTksMaLKjjZIqv8Payrw7Tt&^P!G0+7l<#Pg zFp}pW+fES&$;;m^qL*i9r=NTLBD#T8x=wMDw2Rx%RhJWk*v{35Bd11_n`k_i;^#fO z=k!xW|AKxIzvydcm5jI+1zcqi62KSE@CXo

Nb|PI$|?GVDiV=XFB1nw10UM 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

%pNuw3H&>t^Gfq|BBy>i@Rh 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 + ├── tcga + │ ├── COHORT + │ │ ├── Counts_raw.parquet + │ │ └── recount3_metadata.tsv.gz + │ ├── centers.csv + │ ├── tumor_purity_metadata.csv + │ └── cleaned_clinical_metadata.csv + └── + ``` + + The processed data path will be built/filled/ checked with the following structure. + The cohort is the tcga cohort, which we collect from the dataset name. + The true dataset name is generated from the dataset name, the design factors, + the continuous factors, the small samples, the small genes and the only two centers + parameters. + + ``` + + ├── tcga + │ └── COHORT + │ ├── counts.parquet + │ └── clinical_data.csv + ├── centers_data + │ └── tcga + │ └── + │ └── center_0 + │ ├── counts_data.csv + │ └── metadata.csv + ├── pooled_data + │ └── tcga + │ └── + │ ├── counts_data.csv + │ └── metadata.csv + └── + ``` + + Parameters + ---------- + raw_data_path : str or Path + Path to raw data. + processed_data_path : str or Path + Path to processed data. + dataset_name: TCGADatasetNames = "TCGA-LUAD", + The dataset to preprocess, by default "TCGA-LUAD". + small_samples : bool + If True, only preprocess a small subset of the data, by default False. + This small subset is composed of 10 samples per center (or the number + of samples in the center if this number is inferior). + small_genes : bool + If True, only preprocess a small subset of the data features (genes) + , by default False. This small subset is composed of 100 genes. + only_two_centers : bool + If True, split the data in two centers only, by default False. + design_factors : str or list + The design factors. + continuous_factors : list[str] or None + The continuous design factors. Factors not in this list will be considered + as categorical. + heterogeneity_method : str or None + The method to use to generate heterogeneity in the dataset. If None, no + heterogeneity is generated. Default is None. + heterogeneity_method_param : float or None + The parameter of the heterogeneity method. Default is None. + force : bool + If True, force the setup of the dataset even if the metadata already exists. + Default is False. + **pydeseq2_kwargs + Additional arguments to pass to the pydeseq2 and fedpydeseq2 classes and + strategies. + """ + raw_data_path = Path(raw_data_path).resolve() + processed_data_path = Path(processed_data_path).resolve() + + common_preprocessing_tcga( + dataset_name=dataset_name, + raw_data_path=raw_data_path, + processed_data_path=processed_data_path, + force=force, + ) + + if isinstance(design_factors, str): + design_factors = [design_factors] + + experiment_id = get_experiment_id( + dataset_name, + small_samples, + small_genes, + only_two_centers, + design_factors, + continuous_factors, + heterogeneity_method=heterogeneity_method, + heterogeneity_method_param=heterogeneity_method_param, + **pydeseq2_kwargs, + ) + + logger.info(f"Setting up TCGA dataset: {experiment_id}") + + center_data_path = processed_data_path / "centers_data" / "tcga" / experiment_id + first_center_metadata_path = center_data_path / "center_0" / "metadata.csv" + + if not first_center_metadata_path.exists() or force: + logger.info( + "First center metadata does not exist or force=True. Setting up the " + "dataset." + ) + return _setup_tcga_dataset( + processed_data_path, + dataset_name, + small_samples, + small_genes, + only_two_centers, + design_factors, + continuous_factors, + heterogeneity_method, + heterogeneity_method_param, + **pydeseq2_kwargs, + ) + # Check if the metadata contains all the design factors + logger.info( + f"First center metadata exists at {first_center_metadata_path}. " + f"Checking if all design factors are present." + ) + metadata = pd.read_csv(first_center_metadata_path, index_col=0) + for design_factor in design_factors: + if design_factor not in metadata.columns: + logger.info( + f"Design factor {design_factor} not present in the metadata." + f" Setting up the dataset." + ) + return _setup_tcga_dataset( + processed_data_path, + dataset_name, + small_samples, + small_genes, + only_two_centers, + design_factors, + continuous_factors, + heterogeneity_method, + heterogeneity_method_param, + **pydeseq2_kwargs, + ) + + +def _setup_tcga_dataset( + processed_data_path: str | Path, + dataset_name: TCGADatasetNames = "TCGA-LUAD", + small_samples=False, + small_genes=False, + only_two_centers=False, + design_factors: str | list[str] = "stage", + continuous_factors: list[str] | None = None, + heterogeneity_method: str | None = None, + heterogeneity_method_param: float | None = None, + **pydeseq2_kwargs, +): + """Load, clean and split a TCGA dataset into clients. + + This is the main function to perform these operations. + + This function is given the path to the raw data. + Afterward, the natural split (centers) of the dataset is used + to separate the data into different dataframes, one for each center. + Finally the function saves those dataframe on the disk as a csv + file for each center. + Those datasets would correspond to center's dataset in substrafl. + + For the file structure description, see the `setup_tcga_dataset` function. + + Parameters + ---------- + processed_data_path : str or Path + This path will contain a folder 'centers_data' and 'pooled_data' + to store the preprocessed data. + dataset_name: TCGADatasetNames = "TCGA-LUAD", + The dataset to preprocess, by default "TCGA-LUAD". + small_samples : bool + If True, only preprocess a small subset of the data, by default False. + This small subset is composed of 10 samples per center. + small_genes : bool + If True, only preprocess a small subset of the data features (genes) + , by default False. This small subset is composed of 100 genes. + only_two_centers : bool + If True, split the data in two centers only, by default False. + design_factors : str or list + The design factors. + continuous_factors : list[str] or None + The continuous design factors. Factors not in this list will be considered + as categorical. + heterogeneity_method : str or None + The method to use to generate heterogeneity in the dataset. If None, no + heterogeneity is generated. Default is None. + heterogeneity_method_param : float or None + The parameter of the heterogeneity method. Default is None. + **pydeseq2_kwargs + Additional arguments to pass to the pydeseq2 and fedpydeseq2 classes and + strategies. + + """ + # Check that the design factors and continuous factors are allowed + if isinstance(design_factors, str): + design_factors = [design_factors] + if continuous_factors is None: + continuous_factors = [] + assert set(design_factors).issubset( + ALLOWED_DESIGN_FACTORS_TCGA + ), f"Design factors should be in {ALLOWED_DESIGN_FACTORS_TCGA}" + assert set(continuous_factors).issubset( + ALLOWED_CONTINUOUS_FACTORS_TCGA + ), f"Continuous factors should be in {ALLOWED_CONTINUOUS_FACTORS_TCGA}" + + processed_data_path = Path(processed_data_path).resolve() + sampling_random_generator = np.random.default_rng(42) + + if small_genes: + n_genes = 100 + if small_samples: + n_samples = 10 + + experiment_id = get_experiment_id( + dataset_name, + small_samples, + small_genes, + only_two_centers, + design_factors, + continuous_factors, + heterogeneity_method, + heterogeneity_method_param, + **pydeseq2_kwargs, + ) + + center_data_path = processed_data_path / "centers_data" / "tcga" / experiment_id + + # -- Process the data + logger.info(f"Processing the data for the TCGA dataset: {experiment_id}") + counts_data, metadata = preprocess_tcga( + processed_data_path=processed_data_path, + dataset_name=dataset_name, + only_two_centers=only_two_centers, + design_factors=design_factors, + heterogeneity_method=heterogeneity_method, + heterogeneity_method_param=heterogeneity_method_param, + ) + + if small_genes: + counts_data = counts_data.sample( + n_genes, axis=1, random_state=sampling_random_generator + ) + + if small_samples: + new_counts_data_list: list[pd.DataFrame] = [] + new_metadata_list: list[pd.DataFrame] = [] + + # -- Split the data + logger.info(f"Saving the data for each center {center_data_path}") + for center_id in metadata.center_id.unique(): + counts_dataframe = counts_data.loc[metadata.center_id == center_id] + metadata_dataframe = metadata.loc[metadata.center_id == center_id] + if small_samples: + categorical_factors = list(set(design_factors) - set(continuous_factors)) + n_levels = len(metadata_dataframe[categorical_factors].drop_duplicates()) + n_samples_per_level = max(n_samples // n_levels, 1) + + def _sampling_function(df_, n_samples_, sampling_rng_): + return df_.sample( + min(len(df_), n_samples_), + random_state=sampling_rng_, + replace=False, + ) + + _partialized_sampling_function = partial( + _sampling_function, + n_samples_=n_samples_per_level, + sampling_rng_=sampling_random_generator, + ) + + metadata_dataframe = ( + metadata_dataframe.groupby(categorical_factors, dropna=False) + .apply( + _partialized_sampling_function, + include_groups=False, + ) + .reset_index(categorical_factors) + ) + + counts_dataframe = counts_dataframe.loc[metadata_dataframe.index] + new_counts_data_list.append(counts_dataframe) + new_metadata_list.append(metadata_dataframe) + path = center_data_path / f"center_{center_id}" + + # delete the folder if it exists + # This avoids having old files in the folder when registering the data + # in substra + if path.exists(): + for file in path.iterdir(): + if file.is_dir(): + if file.name == ".ipynb_checkpoints": + logger.info(f"Removing {file}") + shutil.rmtree(file) + else: + raise ValueError( + f"Unexpected directory in the center folder: {file}" + ) + else: + file.unlink() + path.rmdir() + path.mkdir(parents=True) + + counts_dataframe.to_csv(path / "counts_data.csv") + metadata_dataframe.to_csv(path / "metadata.csv") + + if small_samples: + counts_data = pd.concat(new_counts_data_list) + metadata = pd.concat(new_metadata_list) + # Now save to the pooled data folder + pooled_data_path = processed_data_path / "pooled_data" / "tcga" / experiment_id + logger.info(f"Saving the pooled data at {pooled_data_path}") + pooled_data_path.mkdir(parents=True, exist_ok=True) + counts_data.to_csv(pooled_data_path / "counts_data.csv") + metadata.to_csv(pooled_data_path / "metadata.csv") + + +def preprocess_tcga( + processed_data_path: Path, + dataset_name: TCGADatasetNames = "TCGA-LUAD", + only_two_centers=False, + design_factors: str | list[str] = "stage", + heterogeneity_method: str | None = None, + heterogeneity_method_param: float | None = None, +) -> tuple[pd.DataFrame, pd.DataFrame]: + """Preprocess the TCGA dataset. + + If the `stage` design factor is used, the function will binarize the `stage` design + into two categories: `Advanced` and `Non-advanced`. + `Advanced` corresponds to stage `IV`, + and `Non-advanced` corresponds to stages `I`, `II` and `III`. + For the TCGA-PRAD cohort, we do not have the stage information, but we infer the + stage from the `T`, `N` and `M` columns. If the `N` or `M` columns are > 0, + the stage is IV according to: + https://www.cancer.org/cancer/types/prostate-cancer\ + /detection-diagnosis-staging/staging.html + and hence the `Advanced` stage. Otherwise, it is `Non-advanced`. + + + Parameters + ---------- + processed_data_path : Path + Where to find the folder tcga with raw data. + dataset_name: TCGADatasetNames = "TCGA-LUAD", + The dataset to preprocess, by default "TCGA-LUAD". + only_two_centers : bool + If True, split the data in two centers only, by default False. + design_factors : str or list + The design factors. + heterogeneity_method : str or None + The method to use to generate heterogeneity in the dataset. If None, no + heterogeneity is generated. Default is None. + heterogeneity_method_param : float or None + The parameter of the heterogeneity method. Default is None. + + Returns + ------- + counts_data: pd.DataFrame + Processed pooled counts dataset. + metadata: pd.DataFrame + Processed pooled metadata dataset. + + """ + _, cohort = dataset_name.split("-")[:2] + if cohort in ["NSCLC", "CRC"]: + if cohort == "NSCLC": + dataset_1, dataset_2 = cast(TCGADatasetNames, "TCGA-LUAD"), cast( + TCGADatasetNames, "TCGA-LUSC" + ) + elif cohort == "CRC": + dataset_1, dataset_2 = cast(TCGADatasetNames, "TCGA-COAD"), cast( + TCGADatasetNames, "TCGA-READ" + ) + counts_data_1, metadata_1 = preprocess_tcga( + processed_data_path=processed_data_path, + dataset_name=dataset_1, + only_two_centers=only_two_centers, + design_factors=design_factors, + ) + metadata_1["center_id"] = 0 + counts_data_2, metadata_2 = preprocess_tcga( + processed_data_path=processed_data_path, + dataset_name=dataset_2, + only_two_centers=only_two_centers, + design_factors=design_factors, + ) + metadata_2["center_id"] = 1 + counts_data = pd.concat([counts_data_1, counts_data_2]) + metadata = pd.concat([metadata_1, metadata_2]) + + metadata = mix_centers( + metadata, heterogeneity_method, heterogeneity_method_param + ) + return counts_data, metadata + + data_path = processed_data_path / "tcga" / cohort + path_to_counts = data_path / "counts.parquet" + path_to_metadata = data_path / "clinical_data.csv" + # -- Load the data + counts_data = pd.read_parquet(path_to_counts) + + metadata = pd.read_csv(path_to_metadata, index_col=0) + + # -- Process the metadata + + # If the cohort is PRAD, we need to add the stage information + if dataset_name == "TCGA-PRAD": + + def binarize_stage_prad(metadata_row): + if ( + pd.isna(metadata_row["M"]) + and pd.isna(metadata_row["N"]) + and pd.isna(metadata_row["T"]) + ): + return pd.NA + if (not pd.isna(metadata_row["N"])) and (metadata_row["N"] > 0): + return "Advanced" + elif (not pd.isna(metadata_row["M"])) and (metadata_row["M"] > 0): + return "Advanced" + else: + return "Non-advanced" + + metadata["stage"] = metadata.apply(binarize_stage_prad, axis=1) + + else: + # Binarize the stage + def binarize_stage(stage): + if pd.isna(stage): + return pd.NA + elif stage == 4: + return "Advanced" + else: + return "Non-advanced" + + metadata["stage"] = metadata["stage"].apply(binarize_stage) + + # -- Process the data + cols_to_keep = ( + design_factors.copy() if isinstance(design_factors, list) else [design_factors] + ) + cols_to_keep.append("center_id") + metadata = metadata[cols_to_keep] + + # remove samples with NaN design factor + metadata.dropna(subset=design_factors, inplace=True) + + if only_two_centers: + metadata = _merge_centers(metadata) + + counts_data = counts_data.loc[metadata.index] + + return counts_data, metadata + + +def _merge_centers(metadata: pd.DataFrame) -> pd.DataFrame: + """ + Merge the centers into two centers. + + Parameters + ---------- + metadata : pd.DataFrame + Metadata + + Returns + ------- + metadata : pd.DataFrame + Metadata + """ + list_center_ids = np.sort(metadata.center_id.unique()) + assert len(list_center_ids) > 2, "The dataset has less than 2 centers" + dict_mapping = {list_center_ids[k]: 0 for k in range(len(list_center_ids) // 2)} + dict_mapping.update( + { + list_center_ids[k]: 1 + for k in range(len(list_center_ids) // 2, len(list_center_ids)) + } + ) + logger.info(f"Merging centers using the mapping: {dict_mapping}") + metadata["center_id"] = metadata["center_id"].map(dict_mapping) + + return metadata diff --git a/fedpydeseq2_datasets/utils.py b/fedpydeseq2_datasets/utils.py new file mode 100644 index 0000000..381e0dc --- /dev/null +++ b/fedpydeseq2_datasets/utils.py @@ -0,0 +1,435 @@ +import copy +import pickle +import re +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +from loguru import logger + +from fedpydeseq2_datasets.constants import TCGADatasetNames + +IDENTIFYING_PARAMETERS = [ + "contrast", + "refit_cooks", + "alt_hypothesis", + "lfc_null", +] + + +def tnm_to_series(tnm_string: str | None) -> pd.Series: + """Convert a TNM string into a pandas Series with T, N, and M categories. + + If there are multiple categories for the same letter, the maximum number is used. + A typical TNM string looks like 'T1bN2M0'. + + Parameters + ---------- + tnm_string : str or None + The TNM string to convert. + + Returns + ------- + pd.Series + A pandas Series with the T, N, and M categories. + """ + if pd.isna(tnm_string): + return pd.Series({"T": pd.NA, "N": pd.NA, "M": pd.NA}) + + assert isinstance(tnm_string, str), "The TNM string must be a string." + # Split the string into separate TNM categories + tnm_categories = re.findall(r"[TNM]\d+[a-z]*", tnm_string) + + # Initialize the maximum numbers for T, N, and M as None + max_t = max_n = max_m = None + + # Iterate over each category + for category in tnm_categories: + # Extract the category letter and number + letter = category[0] + number = int(re.search(r"\d+", category).group()) # type: ignore + + # Update the maximum number for the corresponding category + if letter == "T": + max_t = max(max_t, number) if max_t is not None else number # type: ignore + elif letter == "N": + max_n = max(max_n, number) if max_n is not None else number # type: ignore + elif letter == "M": + max_m = max(max_m, number) if max_m is not None else number # type: ignore + + # Convert the maximum numbers into a pandas Series + series = pd.Series( + { + "T": max_t if max_t is not None else pd.NA, + "N": max_n if max_n is not None else pd.NA, + "M": max_m if max_m is not None else pd.NA, + } + ) + + return series + + +def get_experiment_id( + dataset_name: TCGADatasetNames | list[TCGADatasetNames], + small_samples: bool, + small_genes: bool, + only_two_centers: bool, + design_factors: str | list[str] = "stage", + continuous_factors: list[str] | None = None, + heterogeneity_method: str | None = None, + heterogeneity_method_param: float | None = None, + **pydeseq2_kwargs: Any, +): + """ + Generate the experiment id. + + Parameters + ---------- + dataset_name : TCGADatasetNames or list[TCGADatasetNames] + Dataset name + small_samples : bool + If True, only preprocess a small subset of the data, by default False. + This small subset is composed of 10 samples per center. + small_genes : bool + If True, only preprocess a small subset of the data features (genes) + only_two_centers : bool + If True, split the data in two centers only. + design_factors : str or list + The design factors. + continuous_factors : list or None + The continuous design factors. Factors not in this list will be considered + as categorical. + heterogeneity_method : str or None + The method used to generate heterogeneity in the data. + heterogeneity_method_param : float or None + The parameter for the heterogeneity method. + **pydeseq2_kwargs : Any + Additional arguments to pass to pydeseq2. + + Returns + ------- + experiment_id : str + The true dataset name + """ + if isinstance(dataset_name, list): + # Create a string with all the dataset names + # Get the tcga cohorts + all_cohorts = "-".join( + sorted([dataset_name.split("-")[1] for dataset_name in dataset_name]) + ) + full_dataset_name = f"TCGA-{all_cohorts}" + else: + full_dataset_name = dataset_name + if isinstance(design_factors, str): + design_factors = [design_factors] + if continuous_factors is None: + continuous_factors = [] + design_factor_str = "_".join(design_factors) + continuous_factor_str = "_".join(continuous_factors) + small_genes_postfix = "-small-genes" if small_genes else "" + small_samples_postfix = "-small-samples" if small_samples else "" + two_centers_postfix = "-two-centers" if only_two_centers else "" + + pydeseq2_kwargs = copy.deepcopy(pydeseq2_kwargs) + if len(design_factors) > 1: + # Add the contrast to the pydeseq2_kwargs + pydeseq2_kwargs["contrast"] = pydeseq2_kwargs.get("contrast", None) + + # Sort the kwargs alphabetically + parameter_names = sorted(pydeseq2_kwargs.keys()) + parameter_str = "" + for parameter_name in parameter_names: + if parameter_name not in IDENTIFYING_PARAMETERS: + continue + parameter_value = pydeseq2_kwargs[parameter_name] + if parameter_value is None: + parameter_str += f"-default_{parameter_name}" + elif isinstance(parameter_value, list): + parameter_str += f"-{parameter_name}-{'_'.join(parameter_value)}" + else: + parameter_str += f"-{parameter_name}-{parameter_value}" + + heterogeneity_postfix = ( + f"heterogeneity-{heterogeneity_method}" + if heterogeneity_method is not None + else "" + ) + heterogeneity_method_param_postfix = ( + f"-{heterogeneity_method_param}" + if heterogeneity_method_param is not None + else "" + ) + + experiment_id = ( + f"{full_dataset_name}-{design_factor_str}-{continuous_factor_str}" + f"{small_genes_postfix}{small_samples_postfix}{two_centers_postfix}" + f"{heterogeneity_postfix}{heterogeneity_method_param_postfix}{parameter_str}" + ) + experiment_id = experiment_id.strip("-_") # Remove trailing '-' and '_' + + return experiment_id + + +def get_ground_truth_dds_name( + reference_dds_ref_level: tuple[str, ...] | None = ("stage", "Advanced"), + refit_cooks: bool = False, + pooled: bool = True, +) -> str: + """ + Generate the ground truth dds name. + + Parameters + ---------- + reference_dds_ref_level : tuple or None + The reference level for the design factor. + refit_cooks : bool + If True, refit the genes with cooks outliers. + TODO this is now obsolete, we should remove it at the end + TODO (but for compatibility reasons we keep it for now). + pooled : bool + If True, we compute the pooled dds, and then restrict it to the + center to get the local dds. If False, we only compute the local dds + from the center data only. + If not pooled, we add the suffix '-center' to the name. + + Returns + ------- + ground_truth_dds_name : str + The ground truth dds name + """ + ref_level_str = ( + "_".join(reference_dds_ref_level) + if reference_dds_ref_level is not None + else "None" + ) + ground_truth_dds_name = f"ground_truth_dds-{ref_level_str}" + if refit_cooks: + ground_truth_dds_name += "-refit_cooks" + if not pooled: + ground_truth_dds_name += "-center" + return ground_truth_dds_name + + +def get_n_centers( + processed_data_path: str | Path, + dataset_name: TCGADatasetNames, + small_samples: bool = False, + small_genes: bool = False, + only_two_centers: bool = False, + design_factors: str | list[str] = "stage", + continuous_factors: list[str] | None = None, + heterogeneity_method: str | None = None, + heterogeneity_method_param: float | None = None, + **pydeseq2_kwargs: Any, +) -> int: + """ + Get the number of centers in the dataset. + + To do so, we open the file containing the metadata and count the number + of unique center ids and count them. + + Parameters + ---------- + processed_data_path : str or Path + The path to the processed data. + + dataset_name : TCGADatasetNames + The name of the dataset to use. + + small_samples : bool + Whether to use a small number of samples. Default is False. + + small_genes : bool + Whether to use a small number of genes. Default is False. + + only_two_centers : bool + Whether to use only two centers. Default is False. + + design_factors : str or list[str] + The design factors to use. Default is "stage". + + continuous_factors : list[str] or None + The continuous factors to use. Default is None. + + heterogeneity_method : str or None + The method to used to define the heterogeneity + of the center's attribution. + + heterogeneity_method_param : float or None + The parameter of the heterogeneity method. + + **pydeseq2_kwargs : Any + Additional arguments to pass to pydeseq2 and fedpydeseq2. + For example, the contrast. + + Returns + ------- + n_centers : int + The number of centers in the dataset + + """ + # Get the number of centers + processed_data_path = Path(processed_data_path) + experiment_id = get_experiment_id( + dataset_name=dataset_name, + small_samples=small_samples, + small_genes=small_genes, + only_two_centers=only_two_centers, + design_factors=design_factors, + continuous_factors=continuous_factors, + heterogeneity_method=heterogeneity_method, + heterogeneity_method_param=heterogeneity_method_param, + **pydeseq2_kwargs, + ) + n_centers = len( + np.unique( + pd.read_csv( + processed_data_path + / "pooled_data" + / "tcga" + / experiment_id + / "metadata.csv" + )["center_id"] + ) + ) + return n_centers + + +def get_n_centers_from_subfolders(centers_path: str | Path) -> int: + """ + Get the number of centers from a folder. + + Parameters + ---------- + centers_path : str or Path + The path to the folder which must contain + center_{i} subfolders + + Returns + ------- + int + The number of centers + """ + centers_path = Path(centers_path) + n_centers = len([x for x in centers_path.iterdir() if x.name.startswith("center_")]) + # check that the names are correct + assert all((centers_path / f"center_{i}").exists() for i in range(n_centers)) + return n_centers + + +def get_valid_centers_from_subfolders_file( + centers_path: str | Path, filename: str, pkl: bool = False +) -> tuple[int, list[int]]: + """ + Get the number of centers from a folder. + + Parameters + ---------- + centers_path : str or Path + The path to the folder which must contain + center_{i} subfolders + + filename : str + The name of the file to check for in the center_{i} subfolders. + If the file is not found in a center_{i} subfolder, the center is + not considered valid (in practice, this will mean that a DeSEQ2 analysis + will not have been run on the center for lack of samples of all + design factors). If pkl is True, the file is assumed to be a pickle file, + and the file is loaded with pickle.load() to check if it is None. + If it is None, the center is not considered valid. + + pkl : bool + If True, the file is assumed to be a pickle file, and the file is loaded + with pickle.load() to check if it is None. If it is None, the center is + not considered valid. + + Returns + ------- + int + The number of centers + """ + centers_path = Path(centers_path) + n_centers = get_n_centers_from_subfolders(centers_path) + valid_centers = [] + for i in range(n_centers): + if (centers_path / f"center_{i}" / filename).exists(): + if pkl: + with open(centers_path / f"center_{i}" / filename, "rb") as f: + data = pickle.load(f) + if data is not None: + valid_centers.append(i) + else: + valid_centers.append(i) + return n_centers, valid_centers + + +def mix_centers( + metadata: pd.DataFrame, + heterogeneity_method: str | None = None, + heterogeneity_method_param: float | None = None, +): + """ + Mix the centers in the metadata. + + It uses the heterogeneity method and the heterogeneity + method parameter. + + Parameters + ---------- + metadata : pd.DataFrame + The metadata to mix the centers + heterogeneity_method : Optional[str] + The method used to generate heterogeneity in the data. The only option + supported is 'binomial'. + heterogeneity_method_param : Optional[float] + The parameter for the heterogeneity method. Should be between 0 and 1. If + the value is 0, the centers are not mixed. If the value is 1, the centers + are completely mixed. + + Returns + ------- + metadata : pd.DataFrame + The metadata with the centers mixed + + """ + if heterogeneity_method is None: + logger.info("No heterogeneity method specified. Keeping the centers as is.") + return metadata + assert ( + heterogeneity_method_param is not None + ), "The heterogeneity method parameter must be specified." + assert ( + 0 <= heterogeneity_method_param <= 1 + ), "The heterogeneity method parameter must be between 0 and 1." + np.random.seed(42) + assert set(metadata.center_id.unique()) == { + 0, + 1, + }, "The metadata must contain only two centers." + if heterogeneity_method == "binomial": + assert heterogeneity_method_param is not None + mask_center_0 = metadata.center_id == 0 + mask_center_1 = metadata.center_id == 1 + random_binomial_0 = ( + np.random.binomial(1, heterogeneity_method_param / 2.0, mask_center_0.sum()) + ).astype(int) + random_binomial_1 = ( + np.random.binomial( + 1, 1.0 - heterogeneity_method_param / 2.0, mask_center_1.sum() + ) + ).astype(int) + metadata["new_center_id"] = np.zeros(len(metadata), dtype=int) + metadata.loc[mask_center_0, "new_center_id"] = random_binomial_0 + metadata.loc[mask_center_1, "new_center_id"] = random_binomial_1 + cross_table = pd.crosstab(metadata["center_id"], metadata["new_center_id"]) + logger.info("Mixing centers results") + logger.info(cross_table) + metadata.drop(columns=["center_id"], inplace=True) + metadata.rename(columns={"new_center_id": "center_id"}, inplace=True) + + else: + raise ValueError( + f"Unknown heterogeneity method parameter: {heterogeneity_method_param}" + ) + return metadata diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..9a9f28b --- /dev/null +++ b/poetry.lock @@ -0,0 +1,1493 @@ +# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. + +[[package]] +name = "anndata" +version = "0.10.8" +description = "Annotated data." +optional = false +python-versions = ">=3.9" +files = [ + {file = "anndata-0.10.8-py3-none-any.whl", hash = "sha256:1b24934dc2674eaf3072cb7010e187aa2b2f4f0e4cf0a32ffeab5ffebe3b1415"}, + {file = "anndata-0.10.8.tar.gz", hash = "sha256:b728a33225eeaaefddf6bed546d935c0f06881c9166621b24de3b492b2f406bb"}, +] + +[package.dependencies] +array-api-compat = ">1.4,<1.5 || >1.5" +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +h5py = ">=3.1" +natsort = "*" +numpy = ">=1.23" +packaging = ">=20.0" +pandas = ">=1.4,<2.1.0rc0 || >2.1.0rc0,<2.1.2 || >2.1.2" +scipy = ">1.8" + +[package.extras] +dev = ["pytest-xdist", "setuptools-scm"] +doc = ["awkward (>=2.0.7)", "ipython", "myst-parser", "nbsphinx", "readthedocs-sphinx-search", "scanpydoc[theme,typehints] (>=0.13.4)", "sphinx (>=4.4)", "sphinx-autodoc-typehints (>=1.11.0)", "sphinx-book-theme (>=1.1.0)", "sphinx-copybutton", "sphinx-design (>=0.5.0)", "sphinx-issues", "sphinxext-opengraph", "zarr"] +gpu = ["cupy"] +test = ["awkward (>=2.3)", "boltons", "dask[array,distributed] (>=2022.09.2)", "httpx", "joblib", "loompy (>=3.0.5)", "matplotlib", "openpyxl", "pyarrow", "pytest (>=8.2)", "pytest-cov (>=2.10)", "pytest-memray", "pytest-mock", "scanpy", "scikit-learn", "zarr (<3.0.0a0)"] + +[[package]] +name = "array-api-compat" +version = "1.9.1" +description = "A wrapper around NumPy and other array libraries to make them compatible with the Array API standard" +optional = false +python-versions = ">=3.9" +files = [ + {file = "array_api_compat-1.9.1-py3-none-any.whl", hash = "sha256:41a2703a662832d21619359ddddc5c0449876871f6c01e108c335f2a9432df94"}, + {file = "array_api_compat-1.9.1.tar.gz", hash = "sha256:17bab828c93c79a5bb8b867145b71fcb889686607c5672b060aef437e0359ea8"}, +] + +[package.extras] +cupy = ["cupy"] +dask = ["dask"] +jax = ["jax"] +numpy = ["numpy"] +pytorch = ["pytorch"] +sparse = ["sparse (>=0.15.1)"] + +[[package]] +name = "black" +version = "24.10.0" +description = "The uncompromising code formatter." +optional = false +python-versions = ">=3.9" +files = [ + {file = "black-24.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6668650ea4b685440857138e5fe40cde4d652633b1bdffc62933d0db4ed9812"}, + {file = "black-24.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1c536fcf674217e87b8cc3657b81809d3c085d7bf3ef262ead700da345bfa6ea"}, + {file = "black-24.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:649fff99a20bd06c6f727d2a27f401331dc0cc861fb69cde910fe95b01b5928f"}, + {file = "black-24.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:fe4d6476887de70546212c99ac9bd803d90b42fc4767f058a0baa895013fbb3e"}, + {file = "black-24.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5a2221696a8224e335c28816a9d331a6c2ae15a2ee34ec857dcf3e45dbfa99ad"}, + {file = "black-24.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f9da3333530dbcecc1be13e69c250ed8dfa67f43c4005fb537bb426e19200d50"}, + {file = "black-24.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4007b1393d902b48b36958a216c20c4482f601569d19ed1df294a496eb366392"}, + {file = "black-24.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:394d4ddc64782e51153eadcaaca95144ac4c35e27ef9b0a42e121ae7e57a9175"}, + {file = "black-24.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5e39e0fae001df40f95bd8cc36b9165c5e2ea88900167bddf258bacef9bbdc3"}, + {file = "black-24.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d37d422772111794b26757c5b55a3eade028aa3fde43121ab7b673d050949d65"}, + {file = "black-24.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14b3502784f09ce2443830e3133dacf2c0110d45191ed470ecb04d0f5f6fcb0f"}, + {file = "black-24.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:30d2c30dc5139211dda799758559d1b049f7f14c580c409d6ad925b74a4208a8"}, + {file = "black-24.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cbacacb19e922a1d75ef2b6ccaefcd6e93a2c05ede32f06a21386a04cedb981"}, + {file = "black-24.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1f93102e0c5bb3907451063e08b9876dbeac810e7da5a8bfb7aeb5a9ef89066b"}, + {file = "black-24.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ddacb691cdcdf77b96f549cf9591701d8db36b2f19519373d60d31746068dbf2"}, + {file = "black-24.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:680359d932801c76d2e9c9068d05c6b107f2584b2a5b88831c83962eb9984c1b"}, + {file = "black-24.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:17374989640fbca88b6a448129cd1745c5eb8d9547b464f281b251dd00155ccd"}, + {file = "black-24.10.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:63f626344343083322233f175aaf372d326de8436f5928c042639a4afbbf1d3f"}, + {file = "black-24.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfa1d0cb6200857f1923b602f978386a3a2758a65b52e0950299ea014be6800"}, + {file = "black-24.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:2cd9c95431d94adc56600710f8813ee27eea544dd118d45896bb734e9d7a0dc7"}, + {file = "black-24.10.0-py3-none-any.whl", hash = "sha256:3bb2b7a1f7b685f85b11fed1ef10f8a9148bceb49853e47a294a3dd963c1dd7d"}, + {file = "black-24.10.0.tar.gz", hash = "sha256:846ea64c97afe3bc677b761787993be4991810ecc7a4a937816dd6bddedc4875"}, +] + +[package.dependencies] +click = ">=8.0.0" +mypy-extensions = ">=0.4.3" +packaging = ">=22.0" +pathspec = ">=0.9.0" +platformdirs = ">=2" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""} + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.10)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + +[[package]] +name = "cfgv" +version = "3.4.0" +description = "Validate configuration and produce human readable error messages." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "contourpy" +version = "1.3.1" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.10" +files = [ + {file = "contourpy-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a045f341a77b77e1c5de31e74e966537bba9f3c4099b35bf4c2e3939dd54cdab"}, + {file = "contourpy-1.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:500360b77259914f7805af7462e41f9cb7ca92ad38e9f94d6c8641b089338124"}, + {file = "contourpy-1.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2f926efda994cdf3c8d3fdb40b9962f86edbc4457e739277b961eced3d0b4c1"}, + {file = "contourpy-1.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adce39d67c0edf383647a3a007de0a45fd1b08dedaa5318404f1a73059c2512b"}, + {file = "contourpy-1.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abbb49fb7dac584e5abc6636b7b2a7227111c4f771005853e7d25176daaf8453"}, + {file = "contourpy-1.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0cffcbede75c059f535725c1680dfb17b6ba8753f0c74b14e6a9c68c29d7ea3"}, + {file = "contourpy-1.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab29962927945d89d9b293eabd0d59aea28d887d4f3be6c22deaefbb938a7277"}, + {file = "contourpy-1.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974d8145f8ca354498005b5b981165b74a195abfae9a8129df3e56771961d595"}, + {file = "contourpy-1.3.1-cp310-cp310-win32.whl", hash = "sha256:ac4578ac281983f63b400f7fe6c101bedc10651650eef012be1ccffcbacf3697"}, + {file = "contourpy-1.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:174e758c66bbc1c8576992cec9599ce8b6672b741b5d336b5c74e35ac382b18e"}, + {file = "contourpy-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8b974d8db2c5610fb4e76307e265de0edb655ae8169e8b21f41807ccbeec4b"}, + {file = "contourpy-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:20914c8c973f41456337652a6eeca26d2148aa96dd7ac323b74516988bea89fc"}, + {file = "contourpy-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d40d37c1c3a4961b4619dd9d77b12124a453cc3d02bb31a07d58ef684d3d86"}, + {file = "contourpy-1.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:113231fe3825ebf6f15eaa8bc1f5b0ddc19d42b733345eae0934cb291beb88b6"}, + {file = "contourpy-1.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dbbc03a40f916a8420e420d63e96a1258d3d1b58cbdfd8d1f07b49fcbd38e85"}, + {file = "contourpy-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a04ecd68acbd77fa2d39723ceca4c3197cb2969633836ced1bea14e219d077c"}, + {file = "contourpy-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c414fc1ed8ee1dbd5da626cf3710c6013d3d27456651d156711fa24f24bd1291"}, + {file = "contourpy-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:31c1b55c1f34f80557d3830d3dd93ba722ce7e33a0b472cba0ec3b6535684d8f"}, + {file = "contourpy-1.3.1-cp311-cp311-win32.whl", hash = "sha256:f611e628ef06670df83fce17805c344710ca5cde01edfdc72751311da8585375"}, + {file = "contourpy-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b2bdca22a27e35f16794cf585832e542123296b4687f9fd96822db6bae17bfc9"}, + {file = "contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509"}, + {file = "contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc"}, + {file = "contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454"}, + {file = "contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80"}, + {file = "contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec"}, + {file = "contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9"}, + {file = "contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b"}, + {file = "contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d"}, + {file = "contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e"}, + {file = "contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d"}, + {file = "contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2"}, + {file = "contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5"}, + {file = "contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81"}, + {file = "contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2"}, + {file = "contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7"}, + {file = "contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c"}, + {file = "contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3"}, + {file = "contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1"}, + {file = "contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82"}, + {file = "contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd"}, + {file = "contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30"}, + {file = "contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751"}, + {file = "contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342"}, + {file = "contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c"}, + {file = "contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f"}, + {file = "contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda"}, + {file = "contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242"}, + {file = "contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1"}, + {file = "contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1"}, + {file = "contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546"}, + {file = "contourpy-1.3.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b457d6430833cee8e4b8e9b6f07aa1c161e5e0d52e118dc102c8f9bd7dd060d6"}, + {file = "contourpy-1.3.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb76c1a154b83991a3cbbf0dfeb26ec2833ad56f95540b442c73950af2013750"}, + {file = "contourpy-1.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:44a29502ca9c7b5ba389e620d44f2fbe792b1fb5734e8b931ad307071ec58c53"}, + {file = "contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699"}, +] + +[package.dependencies] +numpy = ">=1.23" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.11.1)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "pytest-rerunfailures", "pytest-xdist", "wurlitzer"] + +[[package]] +name = "cycler" +version = "0.12.1" +description = "Composable style cycles" +optional = false +python-versions = ">=3.8" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[package.extras] +docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] +tests = ["pytest", "pytest-cov", "pytest-xdist"] + +[[package]] +name = "distlib" +version = "0.3.9" +description = "Distribution utilities" +optional = false +python-versions = "*" +files = [ + {file = "distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87"}, + {file = "distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "filelock" +version = "3.16.1" +description = "A platform independent file lock." +optional = false +python-versions = ">=3.8" +files = [ + {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"}, + {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"}, +] + +[package.extras] +docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"] +typing = ["typing-extensions (>=4.12.2)"] + +[[package]] +name = "fonttools" +version = "4.55.1" +description = "Tools to manipulate font files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fonttools-4.55.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c17a6f9814f83772cd6d9c9009928e1afa4ab66210a31ced721556651075a9a0"}, + {file = "fonttools-4.55.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c4d14eecc814826a01db87a40af3407c892ba49996bc6e49961e386cd78b537c"}, + {file = "fonttools-4.55.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8589f9a15dc005592b94ecdc45b4dfae9bbe9e73542e89af5a5e776e745db83b"}, + {file = "fonttools-4.55.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bfee95bd9395bcd9e6c78955387554335109b6a613db71ef006020b42f761c58"}, + {file = "fonttools-4.55.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:34fa2ecc0bf1923d1a51bf2216a006de2c3c0db02c6aa1470ea50b62b8619bd5"}, + {file = "fonttools-4.55.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9c1c48483148bfb1b9ad951133ceea957faa004f6cb475b67e7bc75d482b48f8"}, + {file = "fonttools-4.55.1-cp310-cp310-win32.whl", hash = "sha256:3e2fc388ca7d023b3c45badd71016fd4185f93e51a22cfe4bd65378af7fba759"}, + {file = "fonttools-4.55.1-cp310-cp310-win_amd64.whl", hash = "sha256:c4c36c71f69d2b3ee30394b0986e5f8b2c461e7eff48dde49b08a90ded9fcdbd"}, + {file = "fonttools-4.55.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5daab3a55d460577f45bb8f5a8eca01fa6cde43ef2ab943b527991f54b735c41"}, + {file = "fonttools-4.55.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:acf1e80cf96c2fbc79e46f669d8713a9a79faaebcc68e31a9fbe600cf8027992"}, + {file = "fonttools-4.55.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e88a0329f7f88a210f09f79c088fb64f8032fc3ab65e2390a40b7d3a11773026"}, + {file = "fonttools-4.55.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03105b42259a8a94b2f0cbf1bee45f7a8a34e7b26c946a8fb89b4967e44091a8"}, + {file = "fonttools-4.55.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9af3577e821649879ab5774ad0e060af34816af556c77c6d3820345d12bf415e"}, + {file = "fonttools-4.55.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34bd5de3d0ad085359b79a96575cd6bd1bc2976320ef24a2aa152ead36dbf656"}, + {file = "fonttools-4.55.1-cp311-cp311-win32.whl", hash = "sha256:5da92c4b637f0155a41f345fa81143c8e17425260fcb21521cb2ad4d2cea2a95"}, + {file = "fonttools-4.55.1-cp311-cp311-win_amd64.whl", hash = "sha256:f70234253d15f844e6da1178f019a931f03181463ce0c7b19648b8c370527b07"}, + {file = "fonttools-4.55.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9c372e527d58ba64b695f15f8014e97bc8826cf64d3380fc89b4196edd3c0fa8"}, + {file = "fonttools-4.55.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:845a967d3bef3245ba81fb5582dc731f6c2c8417fa211f1068c56893504bc000"}, + {file = "fonttools-4.55.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f03be82bcd4ba4418adf10e6165743f824bb09d6594c2743d7f93ea50968805b"}, + {file = "fonttools-4.55.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c42e935cf146f826f556d977660dac88f2fa3fb2efa27d5636c0b89a60c16edf"}, + {file = "fonttools-4.55.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96328bf91e05621d8e40d9f854af7a262cb0e8313e9b38e7f3a7f3c4c0caaa8b"}, + {file = "fonttools-4.55.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:291acec4d774e8cd2d8472d88c04643a77a3324a15247951bd6cfc969799b69e"}, + {file = "fonttools-4.55.1-cp312-cp312-win32.whl", hash = "sha256:6d768d6632809aec1c3fa8f195b173386d85602334701a6894a601a4d3c80368"}, + {file = "fonttools-4.55.1-cp312-cp312-win_amd64.whl", hash = "sha256:2a3850afdb0be1f79a1e95340a2059226511675c5b68098d4e49bfbeb48a8aab"}, + {file = "fonttools-4.55.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0c88d427eaf8bd8497b9051f56e0f5f9fb96a311aa7c72cda35e03e18d59cd16"}, + {file = "fonttools-4.55.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f062c95a725a79fd908fe8407b6ad63e230e1c7d6dece2d5d6ecaf843d6927f6"}, + {file = "fonttools-4.55.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f298c5324c45cad073475146bf560f4110ce2dc2488ff12231a343ec489f77bc"}, + {file = "fonttools-4.55.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f06dbb71344ffd85a6cb7e27970a178952f0bdd8d319ed938e64ba4bcc41700"}, + {file = "fonttools-4.55.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4c46b3525166976f5855b1f039b02433dc51eb635fb54d6a111e0c5d6e6cdc4c"}, + {file = "fonttools-4.55.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:af46f52a21e086a2f89b87bd941c9f0f91e5f769e1a5eb3b37c912228814d3e5"}, + {file = "fonttools-4.55.1-cp313-cp313-win32.whl", hash = "sha256:cd7f36335c5725a3fd724cc667c10c3f5254e779bdc5bffefebb33cf5a75ecb1"}, + {file = "fonttools-4.55.1-cp313-cp313-win_amd64.whl", hash = "sha256:5d6394897710ccac7f74df48492d7f02b9586ff0588c66a2c218844e90534b22"}, + {file = "fonttools-4.55.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:52c4f4b383c56e1a4fe8dab1b63c2269ba9eab0695d2d8e033fa037e61e6f1ef"}, + {file = "fonttools-4.55.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d83892dafdbd62b56545c77b6bd4fa49eef6ec1d6b95e042ee2c930503d1831e"}, + {file = "fonttools-4.55.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:604d5bf16f811fcaaaec2dde139f7ce958462487565edcd54b6fadacb2942083"}, + {file = "fonttools-4.55.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3324b92feb5fd084923a8e89a8248afd5b9f9d81ab9517d7b07cc84403bd448"}, + {file = "fonttools-4.55.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:30f8b1ca9b919c04850678d026fc330c19acaa9e3b282fcacc09a5eb3c8d20c3"}, + {file = "fonttools-4.55.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:1835c98df2cf28c86a66d234895c87df7b9325fd079a8019c5053a389ff55d23"}, + {file = "fonttools-4.55.1-cp38-cp38-win32.whl", hash = "sha256:9f202703720a7cc0049f2ed1a2047925e264384eb5cc4d34f80200d7b17f1b6a"}, + {file = "fonttools-4.55.1-cp38-cp38-win_amd64.whl", hash = "sha256:2efff20aed0338d37c2ff58766bd67f4b9607ded61cf3d6baf1b3e25ea74e119"}, + {file = "fonttools-4.55.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3032d9bf010c395e6eca2851666cafb1f4ecde85d420188555e928ad0144326e"}, + {file = "fonttools-4.55.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0794055588c30ffe25426048e8a7c0a5271942727cd61fc939391e37f4d580d5"}, + {file = "fonttools-4.55.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13ba980e3ffd3206b8c63a365f90dc10eeec27da946d5ee5373c3a325a46d77c"}, + {file = "fonttools-4.55.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d7063babd7434a17a5e355e87de9b2306c85a5c19c7da0794be15c58aab0c39"}, + {file = "fonttools-4.55.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:ed84c15144015a58ef550dd6312884c9fb31a2dbc31a6467bcdafd63be7db476"}, + {file = "fonttools-4.55.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e89419d88b0bbfdb55209e03a17afa2d20db3c2fa0d785543c9d0875668195d5"}, + {file = "fonttools-4.55.1-cp39-cp39-win32.whl", hash = "sha256:6eb781e401b93cda99356bc043ababead2a5096550984d8a4ecf3d5c9f859dc2"}, + {file = "fonttools-4.55.1-cp39-cp39-win_amd64.whl", hash = "sha256:db1031acf04523c5a51c3e1ae19c21a1c32bc5f820a477dd4659a02f9cb82002"}, + {file = "fonttools-4.55.1-py3-none-any.whl", hash = "sha256:4bcfb11f90f48b48c366dd638d773a52fca0d1b9e056dc01df766bf5835baa08"}, + {file = "fonttools-4.55.1.tar.gz", hash = "sha256:85bb2e985718b0df96afc659abfe194c171726054314b019dbbfed31581673c7"}, +] + +[package.extras] +all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["munkres", "pycairo", "scipy"] +lxml = ["lxml (>=4.0)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=15.1.0)"] +woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] + +[[package]] +name = "gitdb" +version = "4.0.11" +description = "Git Object Database" +optional = false +python-versions = ">=3.7" +files = [ + {file = "gitdb-4.0.11-py3-none-any.whl", hash = "sha256:81a3407ddd2ee8df444cbacea00e2d038e40150acfa3001696fe0dcf1d3adfa4"}, + {file = "gitdb-4.0.11.tar.gz", hash = "sha256:bf5421126136d6d0af55bc1e7c1af1c397a34f5b7bd79e776cd3e89785c2b04b"}, +] + +[package.dependencies] +smmap = ">=3.0.1,<6" + +[[package]] +name = "gitpython" +version = "3.1.43" +description = "GitPython is a Python library used to interact with Git repositories" +optional = false +python-versions = ">=3.7" +files = [ + {file = "GitPython-3.1.43-py3-none-any.whl", hash = "sha256:eec7ec56b92aad751f9912a73404bc02ba212a23adb2c7098ee668417051a1ff"}, + {file = "GitPython-3.1.43.tar.gz", hash = "sha256:35f314a9f878467f5453cc1fee295c3e18e52f1b99f10f6cf5b1682e968a9e7c"}, +] + +[package.dependencies] +gitdb = ">=4.0.1,<5" + +[package.extras] +doc = ["sphinx (==4.3.2)", "sphinx-autodoc-typehints", "sphinx-rtd-theme", "sphinxcontrib-applehelp (>=1.0.2,<=1.0.4)", "sphinxcontrib-devhelp (==1.0.2)", "sphinxcontrib-htmlhelp (>=2.0.0,<=2.0.1)", "sphinxcontrib-qthelp (==1.0.3)", "sphinxcontrib-serializinghtml (==1.1.5)"] +test = ["coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "typing-extensions"] + +[[package]] +name = "h5py" +version = "3.12.1" +description = "Read and write HDF5 files from Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "h5py-3.12.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f0f1a382cbf494679c07b4371f90c70391dedb027d517ac94fa2c05299dacda"}, + {file = "h5py-3.12.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cb65f619dfbdd15e662423e8d257780f9a66677eae5b4b3fc9dca70b5fd2d2a3"}, + {file = "h5py-3.12.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b15d8dbd912c97541312c0e07438864d27dbca857c5ad634de68110c6beb1c2"}, + {file = "h5py-3.12.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59685fe40d8c1fbbee088c88cd4da415a2f8bee5c270337dc5a1c4aa634e3307"}, + {file = "h5py-3.12.1-cp310-cp310-win_amd64.whl", hash = "sha256:577d618d6b6dea3da07d13cc903ef9634cde5596b13e832476dd861aaf651f3e"}, + {file = "h5py-3.12.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ccd9006d92232727d23f784795191bfd02294a4f2ba68708825cb1da39511a93"}, + {file = "h5py-3.12.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ad8a76557880aed5234cfe7279805f4ab5ce16b17954606cca90d578d3e713ef"}, + {file = "h5py-3.12.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1473348139b885393125126258ae2d70753ef7e9cec8e7848434f385ae72069e"}, + {file = "h5py-3.12.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:018a4597f35092ae3fb28ee851fdc756d2b88c96336b8480e124ce1ac6fb9166"}, + {file = "h5py-3.12.1-cp311-cp311-win_amd64.whl", hash = "sha256:3fdf95092d60e8130ba6ae0ef7a9bd4ade8edbe3569c13ebbaf39baefffc5ba4"}, + {file = "h5py-3.12.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:06a903a4e4e9e3ebbc8b548959c3c2552ca2d70dac14fcfa650d9261c66939ed"}, + {file = "h5py-3.12.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7b3b8f3b48717e46c6a790e3128d39c61ab595ae0a7237f06dfad6a3b51d5351"}, + {file = "h5py-3.12.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:050a4f2c9126054515169c49cb900949814987f0c7ae74c341b0c9f9b5056834"}, + {file = "h5py-3.12.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c4b41d1019322a5afc5082864dfd6359f8935ecd37c11ac0029be78c5d112c9"}, + {file = "h5py-3.12.1-cp312-cp312-win_amd64.whl", hash = "sha256:e4d51919110a030913201422fb07987db4338eba5ec8c5a15d6fab8e03d443fc"}, + {file = "h5py-3.12.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:513171e90ed92236fc2ca363ce7a2fc6f2827375efcbb0cc7fbdd7fe11fecafc"}, + {file = "h5py-3.12.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:59400f88343b79655a242068a9c900001a34b63e3afb040bd7cdf717e440f653"}, + {file = "h5py-3.12.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3e465aee0ec353949f0f46bf6c6f9790a2006af896cee7c178a8c3e5090aa32"}, + {file = "h5py-3.12.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba51c0c5e029bb5420a343586ff79d56e7455d496d18a30309616fdbeed1068f"}, + {file = "h5py-3.12.1-cp313-cp313-win_amd64.whl", hash = "sha256:52ab036c6c97055b85b2a242cb540ff9590bacfda0c03dd0cf0661b311f522f8"}, + {file = "h5py-3.12.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d2b8dd64f127d8b324f5d2cd1c0fd6f68af69084e9e47d27efeb9e28e685af3e"}, + {file = "h5py-3.12.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4532c7e97fbef3d029735db8b6f5bf01222d9ece41e309b20d63cfaae2fb5c4d"}, + {file = "h5py-3.12.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fdf6d7936fa824acfa27305fe2d9f39968e539d831c5bae0e0d83ed521ad1ac"}, + {file = "h5py-3.12.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84342bffd1f82d4f036433e7039e241a243531a1d3acd7341b35ae58cdab05bf"}, + {file = "h5py-3.12.1-cp39-cp39-win_amd64.whl", hash = "sha256:62be1fc0ef195891949b2c627ec06bc8e837ff62d5b911b6e42e38e0f20a897d"}, + {file = "h5py-3.12.1.tar.gz", hash = "sha256:326d70b53d31baa61f00b8aa5f95c2fcb9621a3ee8365d770c551a13dbbcbfdf"}, +] + +[package.dependencies] +numpy = ">=1.19.3" + +[[package]] +name = "identify" +version = "2.6.3" +description = "File identification library for Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "identify-2.6.3-py2.py3-none-any.whl", hash = "sha256:9edba65473324c2ea9684b1f944fe3191db3345e50b6d04571d10ed164f8d7bd"}, + {file = "identify-2.6.3.tar.gz", hash = "sha256:62f5dae9b5fef52c84cc188514e9ea4f3f636b1d8799ab5ebc475471f9e47a02"}, +] + +[package.extras] +license = ["ukkonen"] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "joblib" +version = "1.4.2" +description = "Lightweight pipelining with Python functions" +optional = false +python-versions = ">=3.8" +files = [ + {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"}, + {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.7" +description = "A fast implementation of the Cassowary constraint solver" +optional = false +python-versions = ">=3.8" +files = [ + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6"}, + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17"}, + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3"}, + {file = "kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc"}, + {file = "kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c"}, + {file = "kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523"}, + {file = "kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d"}, + {file = "kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b"}, + {file = "kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520"}, + {file = "kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b"}, + {file = "kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb"}, + {file = "kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a"}, + {file = "kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e"}, + {file = "kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6"}, + {file = "kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee"}, + {file = "kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07"}, + {file = "kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76"}, + {file = "kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650"}, + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5d5abf8f8ec1f4e22882273c423e16cae834c36856cac348cfbfa68e01c40f3a"}, + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:aeb3531b196ef6f11776c21674dba836aeea9d5bd1cf630f869e3d90b16cfade"}, + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7d755065e4e866a8086c9bdada157133ff466476a2ad7861828e17b6026e22c"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08471d4d86cbaec61f86b217dd938a83d85e03785f51121e791a6e6689a3be95"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bbfcb7165ce3d54a3dfbe731e470f65739c4c1f85bb1018ee912bae139e263b"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d34eb8494bea691a1a450141ebb5385e4b69d38bb8403b5146ad279f4b30fa3"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9242795d174daa40105c1d86aba618e8eab7bf96ba8c3ee614da8302a9f95503"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0f64a48bb81af7450e641e3fe0b0394d7381e342805479178b3d335d60ca7cf"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:8e045731a5416357638d1700927529e2b8ab304811671f665b225f8bf8d8f933"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4322872d5772cae7369f8351da1edf255a604ea7087fe295411397d0cfd9655e"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:e1631290ee9271dffe3062d2634c3ecac02c83890ada077d225e081aca8aab89"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:edcfc407e4eb17e037bca59be0e85a2031a2ac87e4fed26d3e9df88b4165f92d"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:4d05d81ecb47d11e7f8932bd8b61b720bf0b41199358f3f5e36d38e28f0532c5"}, + {file = "kiwisolver-1.4.7-cp38-cp38-win32.whl", hash = "sha256:b38ac83d5f04b15e515fd86f312479d950d05ce2368d5413d46c088dda7de90a"}, + {file = "kiwisolver-1.4.7-cp38-cp38-win_amd64.whl", hash = "sha256:d83db7cde68459fc803052a55ace60bea2bae361fc3b7a6d5da07e11954e4b09"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327"}, + {file = "kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644"}, + {file = "kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4"}, + {file = "kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bfa1acfa0c54932d5607e19a2c24646fb4c1ae2694437789129cf099789a3b00"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:eee3ea935c3d227d49b4eb85660ff631556841f6e567f0f7bda972df6c2c9935"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f3160309af4396e0ed04db259c3ccbfdc3621b5559b5453075e5de555e1f3a1b"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a17f6a29cf8935e587cc8a4dbfc8368c55edc645283db0ce9801016f83526c2d"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10849fb2c1ecbfae45a693c070e0320a91b35dd4bcf58172c023b994283a124d"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ac542bf38a8a4be2dc6b15248d36315ccc65f0743f7b1a76688ffb6b5129a5c2"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, +] + +[[package]] +name = "loguru" +version = "0.7.2" +description = "Python logging made (stupidly) simple" +optional = false +python-versions = ">=3.5" +files = [ + {file = "loguru-0.7.2-py3-none-any.whl", hash = "sha256:003d71e3d3ed35f0f8984898359d65b79e5b21943f78af86aa5491210429b8eb"}, + {file = "loguru-0.7.2.tar.gz", hash = "sha256:e671a53522515f34fd406340ee968cb9ecafbc4b36c679da03c18fd8d0bd51ac"}, +] + +[package.dependencies] +colorama = {version = ">=0.3.4", markers = "sys_platform == \"win32\""} +win32-setctime = {version = ">=1.0.0", markers = "sys_platform == \"win32\""} + +[package.extras] +dev = ["Sphinx (==7.2.5)", "colorama (==0.4.5)", "colorama (==0.4.6)", "exceptiongroup (==1.1.3)", "freezegun (==1.1.0)", "freezegun (==1.2.2)", "mypy (==v0.910)", "mypy (==v0.971)", "mypy (==v1.4.1)", "mypy (==v1.5.1)", "pre-commit (==3.4.0)", "pytest (==6.1.2)", "pytest (==7.4.0)", "pytest-cov (==2.12.1)", "pytest-cov (==4.1.0)", "pytest-mypy-plugins (==1.9.3)", "pytest-mypy-plugins (==3.0.0)", "sphinx-autobuild (==2021.3.14)", "sphinx-rtd-theme (==1.3.0)", "tox (==3.27.1)", "tox (==4.11.0)"] + +[[package]] +name = "matplotlib" +version = "3.9.3" +description = "Python plotting package" +optional = false +python-versions = ">=3.9" +files = [ + {file = "matplotlib-3.9.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:41b016e3be4e740b66c79a031a0a6e145728dbc248142e751e8dab4f3188ca1d"}, + {file = "matplotlib-3.9.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e0143975fc2a6d7136c97e19c637321288371e8f09cff2564ecd73e865ea0b9"}, + {file = "matplotlib-3.9.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f459c8ee2c086455744723628264e43c884be0c7d7b45d84b8cd981310b4815"}, + {file = "matplotlib-3.9.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:687df7ceff57b8f070d02b4db66f75566370e7ae182a0782b6d3d21b0d6917dc"}, + {file = "matplotlib-3.9.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:edd14cf733fdc4f6e6fe3f705af97676a7e52859bf0044aa2c84e55be739241c"}, + {file = "matplotlib-3.9.3-cp310-cp310-win_amd64.whl", hash = "sha256:1c40c244221a1adbb1256692b1133c6fb89418df27bf759a31a333e7912a4010"}, + {file = "matplotlib-3.9.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:cf2a60daf6cecff6828bc608df00dbc794380e7234d2411c0ec612811f01969d"}, + {file = "matplotlib-3.9.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:213d6dc25ce686516208d8a3e91120c6a4fdae4a3e06b8505ced5b716b50cc04"}, + {file = "matplotlib-3.9.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c52f48eb75fcc119a4fdb68ba83eb5f71656999420375df7c94cc68e0e14686e"}, + {file = "matplotlib-3.9.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3c93796b44fa111049b88a24105e947f03c01966b5c0cc782e2ee3887b790a3"}, + {file = "matplotlib-3.9.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cd1077b9a09b16d8c3c7075a8add5ffbfe6a69156a57e290c800ed4d435bef1d"}, + {file = "matplotlib-3.9.3-cp311-cp311-win_amd64.whl", hash = "sha256:c96eeeb8c68b662c7747f91a385688d4b449687d29b691eff7068a4602fe6dc4"}, + {file = "matplotlib-3.9.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0a361bd5583bf0bcc08841df3c10269617ee2a36b99ac39d455a767da908bbbc"}, + {file = "matplotlib-3.9.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e14485bb1b83eeb3d55b6878f9560240981e7bbc7a8d4e1e8c38b9bd6ec8d2de"}, + {file = "matplotlib-3.9.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a8d279f78844aad213c4935c18f8292a9432d51af2d88bca99072c903948045"}, + {file = "matplotlib-3.9.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6c12514329ac0d03128cf1dcceb335f4fbf7c11da98bca68dca8dcb983153a9"}, + {file = "matplotlib-3.9.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6e9de2b390d253a508dd497e9b5579f3a851f208763ed67fdca5dc0c3ea6849c"}, + {file = "matplotlib-3.9.3-cp312-cp312-win_amd64.whl", hash = "sha256:d796272408f8567ff7eaa00eb2856b3a00524490e47ad505b0b4ca6bb8a7411f"}, + {file = "matplotlib-3.9.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:203d18df84f5288973b2d56de63d4678cc748250026ca9e1ad8f8a0fd8a75d83"}, + {file = "matplotlib-3.9.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b651b0d3642991259109dc0351fc33ad44c624801367bb8307be9bfc35e427ad"}, + {file = "matplotlib-3.9.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:66d7b171fecf96940ce069923a08ba3df33ef542de82c2ff4fe8caa8346fa95a"}, + {file = "matplotlib-3.9.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6be0ba61f6ff2e6b68e4270fb63b6813c9e7dec3d15fc3a93f47480444fd72f0"}, + {file = "matplotlib-3.9.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d6b2e8856dec3a6db1ae51aec85c82223e834b228c1d3228aede87eee2b34f9"}, + {file = "matplotlib-3.9.3-cp313-cp313-win_amd64.whl", hash = "sha256:90a85a004fefed9e583597478420bf904bb1a065b0b0ee5b9d8d31b04b0f3f70"}, + {file = "matplotlib-3.9.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3119b2f16de7f7b9212ba76d8fe6a0e9f90b27a1e04683cd89833a991682f639"}, + {file = "matplotlib-3.9.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:87ad73763d93add1b6c1f9fcd33af662fd62ed70e620c52fcb79f3ac427cf3a6"}, + {file = "matplotlib-3.9.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:026bdf3137ab6022c866efa4813b6bbeddc2ed4c9e7e02f0e323a7bca380dfa0"}, + {file = "matplotlib-3.9.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:760a5e89ebbb172989e8273024a1024b0f084510b9105261b3b00c15e9c9f006"}, + {file = "matplotlib-3.9.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a42b9dc42de2cfe357efa27d9c50c7833fc5ab9b2eb7252ccd5d5f836a84e1e4"}, + {file = "matplotlib-3.9.3-cp313-cp313t-win_amd64.whl", hash = "sha256:e0fcb7da73fbf67b5f4bdaa57d85bb585a4e913d4a10f3e15b32baea56a67f0a"}, + {file = "matplotlib-3.9.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:031b7f5b8e595cc07def77ec5b58464e9bb67dc5760be5d6f26d9da24892481d"}, + {file = "matplotlib-3.9.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9fa6e193c14d6944e0685cdb527cb6b38b0e4a518043e7212f214113af7391da"}, + {file = "matplotlib-3.9.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e6eefae6effa0c35bbbc18c25ee6e0b1da44d2359c3cd526eb0c9e703cf055d"}, + {file = "matplotlib-3.9.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10d3e5c7a99bd28afb957e1ae661323b0800d75b419f24d041ed1cc5d844a764"}, + {file = "matplotlib-3.9.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:816a966d5d376bf24c92af8f379e78e67278833e4c7cbc9fa41872eec629a060"}, + {file = "matplotlib-3.9.3-cp39-cp39-win_amd64.whl", hash = "sha256:3fb0b37c896172899a4a93d9442ffdc6f870165f59e05ce2e07c6fded1c15749"}, + {file = "matplotlib-3.9.3-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f2a4ea08e6876206d511365b0bc234edc813d90b930be72c3011bbd7898796f"}, + {file = "matplotlib-3.9.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:9b081dac96ab19c54fd8558fac17c9d2c9cb5cc4656e7ed3261ddc927ba3e2c5"}, + {file = "matplotlib-3.9.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a0a63cb8404d1d1f94968ef35738900038137dab8af836b6c21bb6f03d75465"}, + {file = "matplotlib-3.9.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:896774766fd6be4571a43bc2fcbcb1dcca0807e53cab4a5bf88c4aa861a08e12"}, + {file = "matplotlib-3.9.3.tar.gz", hash = "sha256:cd5dbbc8e25cad5f706845c4d100e2c8b34691b412b93717ce38d8ae803bcfa5"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +kiwisolver = ">=1.3.1" +numpy = ">=1.23" +packaging = ">=20.0" +pillow = ">=8" +pyparsing = ">=2.3.1" +python-dateutil = ">=2.7" + +[package.extras] +dev = ["meson-python (>=0.13.1)", "numpy (>=1.25)", "pybind11 (>=2.6,!=2.13.3)", "setuptools (>=64)", "setuptools_scm (>=7)"] + +[[package]] +name = "mypy" +version = "1.13.0" +description = "Optional static typing for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a"}, + {file = "mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80"}, + {file = "mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7"}, + {file = "mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f"}, + {file = "mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372"}, + {file = "mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d"}, + {file = "mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d"}, + {file = "mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b"}, + {file = "mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73"}, + {file = "mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca"}, + {file = "mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5"}, + {file = "mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e"}, + {file = "mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2"}, + {file = "mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0"}, + {file = "mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2"}, + {file = "mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7"}, + {file = "mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62"}, + {file = "mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8"}, + {file = "mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7"}, + {file = "mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc"}, + {file = "mypy-1.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:100fac22ce82925f676a734af0db922ecfea991e1d7ec0ceb1e115ebe501301a"}, + {file = "mypy-1.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7bcb0bb7f42a978bb323a7c88f1081d1b5dee77ca86f4100735a6f541299d8fb"}, + {file = "mypy-1.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bde31fc887c213e223bbfc34328070996061b0833b0a4cfec53745ed61f3519b"}, + {file = "mypy-1.13.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:07de989f89786f62b937851295ed62e51774722e5444a27cecca993fc3f9cd74"}, + {file = "mypy-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:4bde84334fbe19bad704b3f5b78c4abd35ff1026f8ba72b29de70dda0916beb6"}, + {file = "mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc"}, + {file = "mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732"}, + {file = "mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc"}, + {file = "mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d"}, + {file = "mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24"}, + {file = "mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a"}, + {file = "mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e"}, +] + +[package.dependencies] +mypy-extensions = ">=1.0.0" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = ">=4.6.0" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +faster-cache = ["orjson"] +install-types = ["pip"] +mypyc = ["setuptools (>=50)"] +reports = ["lxml"] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + +[[package]] +name = "natsort" +version = "8.4.0" +description = "Simple yet flexible natural sorting in Python." +optional = false +python-versions = ">=3.7" +files = [ + {file = "natsort-8.4.0-py3-none-any.whl", hash = "sha256:4732914fb471f56b5cce04d7bae6f164a592c7712e1c85f9ef585e197299521c"}, + {file = "natsort-8.4.0.tar.gz", hash = "sha256:45312c4a0e5507593da193dedd04abb1469253b601ecaf63445ad80f0a1ea581"}, +] + +[package.extras] +fast = ["fastnumbers (>=2.0.0)"] +icu = ["PyICU (>=1.0.0)"] + +[[package]] +name = "nodeenv" +version = "1.9.1" +description = "Node.js virtual environment builder" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"}, + {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, +] + +[[package]] +name = "numpy" +version = "1.26.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2"}, + {file = "numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07"}, + {file = "numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a"}, + {file = "numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20"}, + {file = "numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0"}, + {file = "numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110"}, + {file = "numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c"}, + {file = "numpy-1.26.4-cp39-cp39-win32.whl", hash = "sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6"}, + {file = "numpy-1.26.4-cp39-cp39-win_amd64.whl", hash = "sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0"}, + {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, +] + +[[package]] +name = "packaging" +version = "24.2" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.2.2" +description = "Powerful data structures for data analysis, time series, and statistics" +optional = false +python-versions = ">=3.9" +files = [ + {file = "pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce"}, + {file = "pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238"}, + {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4abfe0be0d7221be4f12552995e58723c7422c80a659da13ca382697de830c08"}, + {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8635c16bf3d99040fdf3ca3db669a7250ddf49c55dc4aa8fe0ae0fa8d6dcc1f0"}, + {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:40ae1dffb3967a52203105a077415a86044a2bea011b5f321c6aa64b379a3f51"}, + {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8e5a0b00e1e56a842f922e7fae8ae4077aee4af0acb5ae3622bd4b4c30aedf99"}, + {file = "pandas-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:ddf818e4e6c7c6f4f7c8a12709696d193976b591cc7dc50588d3d1a6b5dc8772"}, + {file = "pandas-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:696039430f7a562b74fa45f540aca068ea85fa34c244d0deee539cb6d70aa288"}, + {file = "pandas-2.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8e90497254aacacbc4ea6ae5e7a8cd75629d6ad2b30025a4a8b09aa4faf55151"}, + {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58b84b91b0b9f4bafac2a0ac55002280c094dfc6402402332c0913a59654ab2b"}, + {file = "pandas-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d2123dc9ad6a814bcdea0f099885276b31b24f7edf40f6cdbc0912672e22eee"}, + {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2925720037f06e89af896c70bca73459d7e6a4be96f9de79e2d440bd499fe0db"}, + {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0cace394b6ea70c01ca1595f839cf193df35d1575986e484ad35c4aeae7266c1"}, + {file = "pandas-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:873d13d177501a28b2756375d59816c365e42ed8417b41665f346289adc68d24"}, + {file = "pandas-2.2.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9dfde2a0ddef507a631dc9dc4af6a9489d5e2e740e226ad426a05cabfbd7c8ef"}, + {file = "pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b79011ff7a0f4b1d6da6a61aa1aa604fb312d6647de5bad20013682d1429ce"}, + {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cb51fe389360f3b5a4d57dbd2848a5f033350336ca3b340d1c53a1fad33bcad"}, + {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eee3a87076c0756de40b05c5e9a6069c035ba43e8dd71c379e68cab2c20f16ad"}, + {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3e374f59e440d4ab45ca2fffde54b81ac3834cf5ae2cdfa69c90bc03bde04d76"}, + {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:43498c0bdb43d55cb162cdc8c06fac328ccb5d2eabe3cadeb3529ae6f0517c32"}, + {file = "pandas-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:d187d355ecec3629624fccb01d104da7d7f391db0311145817525281e2804d23"}, + {file = "pandas-2.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0ca6377b8fca51815f382bd0b697a0814c8bda55115678cbc94c30aacbb6eff2"}, + {file = "pandas-2.2.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9057e6aa78a584bc93a13f0a9bf7e753a5e9770a30b4d758b8d5f2a62a9433cd"}, + {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:001910ad31abc7bf06f49dcc903755d2f7f3a9186c0c040b827e522e9cef0863"}, + {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66b479b0bd07204e37583c191535505410daa8df638fd8e75ae1b383851fe921"}, + {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a77e9d1c386196879aa5eb712e77461aaee433e54c68cf253053a73b7e49c33a"}, + {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:92fd6b027924a7e178ac202cfbe25e53368db90d56872d20ffae94b96c7acc57"}, + {file = "pandas-2.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:640cef9aa381b60e296db324337a554aeeb883ead99dc8f6c18e81a93942f5f4"}, + {file = "pandas-2.2.2.tar.gz", hash = "sha256:9e79019aba43cb4fda9e4d983f8e88ca0373adbb697ae9c6c43093218de28b54"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.22.4", markers = "python_version < \"3.11\""}, + {version = ">=1.23.2", markers = "python_version == \"3.11\""}, + {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, +] +python-dateutil = ">=2.8.2" +pytz = ">=2020.1" +tzdata = ">=2022.7" + +[package.extras] +all = ["PyQt5 (>=5.15.9)", "SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)", "beautifulsoup4 (>=4.11.2)", "bottleneck (>=1.3.6)", "dataframe-api-compat (>=0.1.7)", "fastparquet (>=2022.12.0)", "fsspec (>=2022.11.0)", "gcsfs (>=2022.11.0)", "html5lib (>=1.1)", "hypothesis (>=6.46.1)", "jinja2 (>=3.1.2)", "lxml (>=4.9.2)", "matplotlib (>=3.6.3)", "numba (>=0.56.4)", "numexpr (>=2.8.4)", "odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "pandas-gbq (>=0.19.0)", "psycopg2 (>=2.9.6)", "pyarrow (>=10.0.1)", "pymysql (>=1.0.2)", "pyreadstat (>=1.2.0)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "qtpy (>=2.3.0)", "s3fs (>=2022.11.0)", "scipy (>=1.10.0)", "tables (>=3.8.0)", "tabulate (>=0.9.0)", "xarray (>=2022.12.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)", "zstandard (>=0.19.0)"] +aws = ["s3fs (>=2022.11.0)"] +clipboard = ["PyQt5 (>=5.15.9)", "qtpy (>=2.3.0)"] +compression = ["zstandard (>=0.19.0)"] +computation = ["scipy (>=1.10.0)", "xarray (>=2022.12.0)"] +consortium-standard = ["dataframe-api-compat (>=0.1.7)"] +excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)"] +feather = ["pyarrow (>=10.0.1)"] +fss = ["fsspec (>=2022.11.0)"] +gcp = ["gcsfs (>=2022.11.0)", "pandas-gbq (>=0.19.0)"] +hdf5 = ["tables (>=3.8.0)"] +html = ["beautifulsoup4 (>=4.11.2)", "html5lib (>=1.1)", "lxml (>=4.9.2)"] +mysql = ["SQLAlchemy (>=2.0.0)", "pymysql (>=1.0.2)"] +output-formatting = ["jinja2 (>=3.1.2)", "tabulate (>=0.9.0)"] +parquet = ["pyarrow (>=10.0.1)"] +performance = ["bottleneck (>=1.3.6)", "numba (>=0.56.4)", "numexpr (>=2.8.4)"] +plot = ["matplotlib (>=3.6.3)"] +postgresql = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "psycopg2 (>=2.9.6)"] +pyarrow = ["pyarrow (>=10.0.1)"] +spss = ["pyreadstat (>=1.2.0)"] +sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)"] +test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"] +xml = ["lxml (>=4.9.2)"] + +[[package]] +name = "pandas-stubs" +version = "2.2.3.241126" +description = "Type annotations for pandas" +optional = false +python-versions = ">=3.10" +files = [ + {file = "pandas_stubs-2.2.3.241126-py3-none-any.whl", hash = "sha256:74aa79c167af374fe97068acc90776c0ebec5266a6e5c69fe11e9c2cf51f2267"}, + {file = "pandas_stubs-2.2.3.241126.tar.gz", hash = "sha256:cf819383c6d9ae7d4dabf34cd47e1e45525bb2f312e6ad2939c2c204cb708acd"}, +] + +[package.dependencies] +numpy = ">=1.23.5" +types-pytz = ">=2022.1.1" + +[[package]] +name = "pathspec" +version = "0.12.1" +description = "Utility library for gitignore style pattern matching of file paths." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"}, + {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"}, +] + +[[package]] +name = "pillow" +version = "11.0.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.9" +files = [ + {file = "pillow-11.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6619654954dc4936fcff82db8eb6401d3159ec6be81e33c6000dfd76ae189947"}, + {file = "pillow-11.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b3c5ac4bed7519088103d9450a1107f76308ecf91d6dabc8a33a2fcfb18d0fba"}, + {file = "pillow-11.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a65149d8ada1055029fcb665452b2814fe7d7082fcb0c5bed6db851cb69b2086"}, + {file = "pillow-11.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88a58d8ac0cc0e7f3a014509f0455248a76629ca9b604eca7dc5927cc593c5e9"}, + {file = "pillow-11.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:c26845094b1af3c91852745ae78e3ea47abf3dbcd1cf962f16b9a5fbe3ee8488"}, + {file = "pillow-11.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:1a61b54f87ab5786b8479f81c4b11f4d61702830354520837f8cc791ebba0f5f"}, + {file = "pillow-11.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:674629ff60030d144b7bca2b8330225a9b11c482ed408813924619c6f302fdbb"}, + {file = "pillow-11.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:598b4e238f13276e0008299bd2482003f48158e2b11826862b1eb2ad7c768b97"}, + {file = "pillow-11.0.0-cp310-cp310-win32.whl", hash = "sha256:9a0f748eaa434a41fccf8e1ee7a3eed68af1b690e75328fd7a60af123c193b50"}, + {file = "pillow-11.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:a5629742881bcbc1f42e840af185fd4d83a5edeb96475a575f4da50d6ede337c"}, + {file = "pillow-11.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:ee217c198f2e41f184f3869f3e485557296d505b5195c513b2bfe0062dc537f1"}, + {file = "pillow-11.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1c1d72714f429a521d8d2d018badc42414c3077eb187a59579f28e4270b4b0fc"}, + {file = "pillow-11.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:499c3a1b0d6fc8213519e193796eb1a86a1be4b1877d678b30f83fd979811d1a"}, + {file = "pillow-11.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8b2351c85d855293a299038e1f89db92a2f35e8d2f783489c6f0b2b5f3fe8a3"}, + {file = "pillow-11.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f4dba50cfa56f910241eb7f883c20f1e7b1d8f7d91c750cd0b318bad443f4d5"}, + {file = "pillow-11.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5ddbfd761ee00c12ee1be86c9c0683ecf5bb14c9772ddbd782085779a63dd55b"}, + {file = "pillow-11.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:45c566eb10b8967d71bf1ab8e4a525e5a93519e29ea071459ce517f6b903d7fa"}, + {file = "pillow-11.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b4fd7bd29610a83a8c9b564d457cf5bd92b4e11e79a4ee4716a63c959699b306"}, + {file = "pillow-11.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cb929ca942d0ec4fac404cbf520ee6cac37bf35be479b970c4ffadf2b6a1cad9"}, + {file = "pillow-11.0.0-cp311-cp311-win32.whl", hash = "sha256:006bcdd307cc47ba43e924099a038cbf9591062e6c50e570819743f5607404f5"}, + {file = "pillow-11.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:52a2d8323a465f84faaba5236567d212c3668f2ab53e1c74c15583cf507a0291"}, + {file = "pillow-11.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:16095692a253047fe3ec028e951fa4221a1f3ed3d80c397e83541a3037ff67c9"}, + {file = "pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923"}, + {file = "pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903"}, + {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4"}, + {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f"}, + {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9"}, + {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7"}, + {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6"}, + {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc"}, + {file = "pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6"}, + {file = "pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47"}, + {file = "pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25"}, + {file = "pillow-11.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bcd1fb5bb7b07f64c15618c89efcc2cfa3e95f0e3bcdbaf4642509de1942a699"}, + {file = "pillow-11.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e038b0745997c7dcaae350d35859c9715c71e92ffb7e0f4a8e8a16732150f38"}, + {file = "pillow-11.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ae08bd8ffc41aebf578c2af2f9d8749d91f448b3bfd41d7d9ff573d74f2a6b2"}, + {file = "pillow-11.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d69bfd8ec3219ae71bcde1f942b728903cad25fafe3100ba2258b973bd2bc1b2"}, + {file = "pillow-11.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:61b887f9ddba63ddf62fd02a3ba7add935d053b6dd7d58998c630e6dbade8527"}, + {file = "pillow-11.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c6a660307ca9d4867caa8d9ca2c2658ab685de83792d1876274991adec7b93fa"}, + {file = "pillow-11.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:73e3a0200cdda995c7e43dd47436c1548f87a30bb27fb871f352a22ab8dcf45f"}, + {file = "pillow-11.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fba162b8872d30fea8c52b258a542c5dfd7b235fb5cb352240c8d63b414013eb"}, + {file = "pillow-11.0.0-cp313-cp313-win32.whl", hash = "sha256:f1b82c27e89fffc6da125d5eb0ca6e68017faf5efc078128cfaa42cf5cb38798"}, + {file = "pillow-11.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ba470552b48e5835f1d23ecb936bb7f71d206f9dfeee64245f30c3270b994de"}, + {file = "pillow-11.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:846e193e103b41e984ac921b335df59195356ce3f71dcfd155aa79c603873b84"}, + {file = "pillow-11.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4ad70c4214f67d7466bea6a08061eba35c01b1b89eaa098040a35272a8efb22b"}, + {file = "pillow-11.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6ec0d5af64f2e3d64a165f490d96368bb5dea8b8f9ad04487f9ab60dc4bb6003"}, + {file = "pillow-11.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c809a70e43c7977c4a42aefd62f0131823ebf7dd73556fa5d5950f5b354087e2"}, + {file = "pillow-11.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4b60c9520f7207aaf2e1d94de026682fc227806c6e1f55bba7606d1c94dd623a"}, + {file = "pillow-11.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1e2688958a840c822279fda0086fec1fdab2f95bf2b717b66871c4ad9859d7e8"}, + {file = "pillow-11.0.0-cp313-cp313t-win32.whl", hash = "sha256:607bbe123c74e272e381a8d1957083a9463401f7bd01287f50521ecb05a313f8"}, + {file = "pillow-11.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c39ed17edea3bc69c743a8dd3e9853b7509625c2462532e62baa0732163a904"}, + {file = "pillow-11.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:75acbbeb05b86bc53cbe7b7e6fe00fbcf82ad7c684b3ad82e3d711da9ba287d3"}, + {file = "pillow-11.0.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2e46773dc9f35a1dd28bd6981332fd7f27bec001a918a72a79b4133cf5291dba"}, + {file = "pillow-11.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2679d2258b7f1192b378e2893a8a0a0ca472234d4c2c0e6bdd3380e8dfa21b6a"}, + {file = "pillow-11.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eda2616eb2313cbb3eebbe51f19362eb434b18e3bb599466a1ffa76a033fb916"}, + {file = "pillow-11.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ec184af98a121fb2da42642dea8a29ec80fc3efbaefb86d8fdd2606619045d"}, + {file = "pillow-11.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:8594f42df584e5b4bb9281799698403f7af489fba84c34d53d1c4bfb71b7c4e7"}, + {file = "pillow-11.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:c12b5ae868897c7338519c03049a806af85b9b8c237b7d675b8c5e089e4a618e"}, + {file = "pillow-11.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:70fbbdacd1d271b77b7721fe3cdd2d537bbbd75d29e6300c672ec6bb38d9672f"}, + {file = "pillow-11.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5178952973e588b3f1360868847334e9e3bf49d19e169bbbdfaf8398002419ae"}, + {file = "pillow-11.0.0-cp39-cp39-win32.whl", hash = "sha256:8c676b587da5673d3c75bd67dd2a8cdfeb282ca38a30f37950511766b26858c4"}, + {file = "pillow-11.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:94f3e1780abb45062287b4614a5bc0874519c86a777d4a7ad34978e86428b8dd"}, + {file = "pillow-11.0.0-cp39-cp39-win_arm64.whl", hash = "sha256:290f2cc809f9da7d6d622550bbf4c1e57518212da51b6a30fe8e0a270a5b78bd"}, + {file = "pillow-11.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1187739620f2b365de756ce086fdb3604573337cc28a0d3ac4a01ab6b2d2a6d2"}, + {file = "pillow-11.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbbcb7b57dc9c794843e3d1258c0fbf0f48656d46ffe9e09b63bbd6e8cd5d0a2"}, + {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d203af30149ae339ad1b4f710d9844ed8796e97fda23ffbc4cc472968a47d0b"}, + {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21a0d3b115009ebb8ac3d2ebec5c2982cc693da935f4ab7bb5c8ebe2f47d36f2"}, + {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:73853108f56df97baf2bb8b522f3578221e56f646ba345a372c78326710d3830"}, + {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e58876c91f97b0952eb766123bfef372792ab3f4e3e1f1a2267834c2ab131734"}, + {file = "pillow-11.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:224aaa38177597bb179f3ec87eeefcce8e4f85e608025e9cfac60de237ba6316"}, + {file = "pillow-11.0.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5bd2d3bdb846d757055910f0a59792d33b555800813c3b39ada1829c372ccb06"}, + {file = "pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:375b8dd15a1f5d2feafff536d47e22f69625c1aa92f12b339ec0b2ca40263273"}, + {file = "pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:daffdf51ee5db69a82dd127eabecce20729e21f7a3680cf7cbb23f0829189790"}, + {file = "pillow-11.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7326a1787e3c7b0429659e0a944725e1b03eeaa10edd945a86dead1913383944"}, + {file = "pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=8.1)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"] +fpx = ["olefile"] +mic = ["olefile"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] +typing = ["typing-extensions"] +xmp = ["defusedxml"] + +[[package]] +name = "platformdirs" +version = "4.3.6" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +optional = false +python-versions = ">=3.8" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[package.extras] +docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"] +type = ["mypy (>=1.11.2)"] + +[[package]] +name = "pluggy" +version = "1.5.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "pre-commit" +version = "3.8.0" +description = "A framework for managing and maintaining multi-language pre-commit hooks." +optional = false +python-versions = ">=3.9" +files = [ + {file = "pre_commit-3.8.0-py2.py3-none-any.whl", hash = "sha256:9a90a53bf82fdd8778d58085faf8d83df56e40dfe18f45b19446e26bf1b3a63f"}, + {file = "pre_commit-3.8.0.tar.gz", hash = "sha256:8bb6494d4a20423842e198980c9ecf9f96607a07ea29549e180eef9ae80fe7af"}, +] + +[package.dependencies] +cfgv = ">=2.0.0" +identify = ">=1.0.0" +nodeenv = ">=0.11.1" +pyyaml = ">=5.1" +virtualenv = ">=20.10.0" + +[[package]] +name = "pyarrow" +version = "15.0.2" +description = "Python library for Apache Arrow" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pyarrow-15.0.2-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:88b340f0a1d05b5ccc3d2d986279045655b1fe8e41aba6ca44ea28da0d1455d8"}, + {file = "pyarrow-15.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eaa8f96cecf32da508e6c7f69bb8401f03745c050c1dd42ec2596f2e98deecac"}, + {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23c6753ed4f6adb8461e7c383e418391b8d8453c5d67e17f416c3a5d5709afbd"}, + {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f639c059035011db8c0497e541a8a45d98a58dbe34dc8fadd0ef128f2cee46e5"}, + {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:290e36a59a0993e9a5224ed2fb3e53375770f07379a0ea03ee2fce2e6d30b423"}, + {file = "pyarrow-15.0.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:06c2bb2a98bc792f040bef31ad3e9be6a63d0cb39189227c08a7d955db96816e"}, + {file = "pyarrow-15.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:f7a197f3670606a960ddc12adbe8075cea5f707ad7bf0dffa09637fdbb89f76c"}, + {file = "pyarrow-15.0.2-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:5f8bc839ea36b1f99984c78e06e7a06054693dc2af8920f6fb416b5bca9944e4"}, + {file = "pyarrow-15.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f5e81dfb4e519baa6b4c80410421528c214427e77ca0ea9461eb4097c328fa33"}, + {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3a4f240852b302a7af4646c8bfe9950c4691a419847001178662a98915fd7ee7"}, + {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e7d9cfb5a1e648e172428c7a42b744610956f3b70f524aa3a6c02a448ba853e"}, + {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:2d4f905209de70c0eb5b2de6763104d5a9a37430f137678edfb9a675bac9cd98"}, + {file = "pyarrow-15.0.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:90adb99e8ce5f36fbecbbc422e7dcbcbed07d985eed6062e459e23f9e71fd197"}, + {file = "pyarrow-15.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:b116e7fd7889294cbd24eb90cd9bdd3850be3738d61297855a71ac3b8124ee38"}, + {file = "pyarrow-15.0.2-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:25335e6f1f07fdaa026a61c758ee7d19ce824a866b27bba744348fa73bb5a440"}, + {file = "pyarrow-15.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90f19e976d9c3d8e73c80be84ddbe2f830b6304e4c576349d9360e335cd627fc"}, + {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a22366249bf5fd40ddacc4f03cd3160f2d7c247692945afb1899bab8a140ddfb"}, + {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c2a335198f886b07e4b5ea16d08ee06557e07db54a8400cc0d03c7f6a22f785f"}, + {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3e6d459c0c22f0b9c810a3917a1de3ee704b021a5fb8b3bacf968eece6df098f"}, + {file = "pyarrow-15.0.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:033b7cad32198754d93465dcfb71d0ba7cb7cd5c9afd7052cab7214676eec38b"}, + {file = "pyarrow-15.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:29850d050379d6e8b5a693098f4de7fd6a2bea4365bfd073d7c57c57b95041ee"}, + {file = "pyarrow-15.0.2-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:7167107d7fb6dcadb375b4b691b7e316f4368f39f6f45405a05535d7ad5e5058"}, + {file = "pyarrow-15.0.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e85241b44cc3d365ef950432a1b3bd44ac54626f37b2e3a0cc89c20e45dfd8bf"}, + {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:248723e4ed3255fcd73edcecc209744d58a9ca852e4cf3d2577811b6d4b59818"}, + {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ff3bdfe6f1b81ca5b73b70a8d482d37a766433823e0c21e22d1d7dde76ca33f"}, + {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:f3d77463dee7e9f284ef42d341689b459a63ff2e75cee2b9302058d0d98fe142"}, + {file = "pyarrow-15.0.2-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:8c1faf2482fb89766e79745670cbca04e7018497d85be9242d5350cba21357e1"}, + {file = "pyarrow-15.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:28f3016958a8e45a1069303a4a4f6a7d4910643fc08adb1e2e4a7ff056272ad3"}, + {file = "pyarrow-15.0.2-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:89722cb64286ab3d4daf168386f6968c126057b8c7ec3ef96302e81d8cdb8ae4"}, + {file = "pyarrow-15.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cd0ba387705044b3ac77b1b317165c0498299b08261d8122c96051024f953cd5"}, + {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad2459bf1f22b6a5cdcc27ebfd99307d5526b62d217b984b9f5c974651398832"}, + {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58922e4bfece8b02abf7159f1f53a8f4d9f8e08f2d988109126c17c3bb261f22"}, + {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:adccc81d3dc0478ea0b498807b39a8d41628fa9210729b2f718b78cb997c7c91"}, + {file = "pyarrow-15.0.2-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:8bd2baa5fe531571847983f36a30ddbf65261ef23e496862ece83bdceb70420d"}, + {file = "pyarrow-15.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6669799a1d4ca9da9c7e06ef48368320f5856f36f9a4dd31a11839dda3f6cc8c"}, + {file = "pyarrow-15.0.2.tar.gz", hash = "sha256:9c9bc803cb3b7bfacc1e96ffbfd923601065d9d3f911179d81e72d99fd74a3d9"}, +] + +[package.dependencies] +numpy = ">=1.16.6,<2" + +[[package]] +name = "pydeseq2" +version = "0.4.9" +description = "A python implementation of DESeq2." +optional = false +python-versions = ">=3.9.0" +files = [ + {file = "pydeseq2-0.4.9-py3-none-any.whl", hash = "sha256:7f112fe1dfd3cef1c19e1ead67379d348f2517ad0594fac0fcbae847d0d62020"}, + {file = "pydeseq2-0.4.9.tar.gz", hash = "sha256:0375207775953f43f84ed4279fcb9f11a430d79d038e158bbe74acbc58326d31"}, +] + +[package.dependencies] +anndata = ">=0.8.0" +matplotlib = ">=3.6.2" +numpy = ">=1.23.0" +pandas = ">=1.4.0" +scikit-learn = ">=1.1.0" +scipy = ">=1.11.0" + +[package.extras] +dev = ["coverage", "mypy", "numpydoc", "pandas-stubs", "pre-commit (>=2.13.0)", "pytest (>=6.2.4)"] + +[[package]] +name = "pyparsing" +version = "3.2.0" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +optional = false +python-versions = ">=3.9" +files = [ + {file = "pyparsing-3.2.0-py3-none-any.whl", hash = "sha256:93d9577b88da0bbea8cc8334ee8b918ed014968fd2ec383e868fb8afb1ccef84"}, + {file = "pyparsing-3.2.0.tar.gz", hash = "sha256:cbf74e27246d595d9a74b186b810f6fbb86726dbf3b9532efb343f6d7294fe9c"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] + +[[package]] +name = "pytest" +version = "8.3.4" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6"}, + {file = "pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=1.5,<2" +tomli = {version = ">=1", markers = "python_version < \"3.11\""} + +[package.extras] +dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "pytz" +version = "2024.2" +description = "World timezone definitions, modern and historical" +optional = false +python-versions = "*" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +description = "YAML parser and emitter for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"}, + {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"}, + {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237"}, + {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b"}, + {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"}, + {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180"}, + {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68"}, + {file = "PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99"}, + {file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"}, + {file = "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774"}, + {file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"}, + {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c"}, + {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317"}, + {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"}, + {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"}, + {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e"}, + {file = "PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5"}, + {file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"}, + {file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"}, + {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"}, + {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"}, + {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"}, + {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"}, + {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"}, + {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"}, + {file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"}, + {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"}, + {file = "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba"}, + {file = "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1"}, + {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133"}, + {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484"}, + {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5"}, + {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc"}, + {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652"}, + {file = "PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183"}, + {file = "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"}, + {file = "PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a"}, + {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5"}, + {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d"}, + {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"}, + {file = "PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706"}, + {file = "PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a"}, + {file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"}, + {file = "PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d"}, + {file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"}, + {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290"}, + {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12"}, + {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"}, + {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e"}, + {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725"}, + {file = "PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631"}, + {file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"}, + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, +] + +[[package]] +name = "ruff" +version = "0.2.2" +description = "An extremely fast Python linter and code formatter, written in Rust." +optional = false +python-versions = ">=3.7" +files = [ + {file = "ruff-0.2.2-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0a9efb032855ffb3c21f6405751d5e147b0c6b631e3ca3f6b20f917572b97eb6"}, + {file = "ruff-0.2.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d450b7fbff85913f866a5384d8912710936e2b96da74541c82c1b458472ddb39"}, + {file = "ruff-0.2.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ecd46e3106850a5c26aee114e562c329f9a1fbe9e4821b008c4404f64ff9ce73"}, + {file = "ruff-0.2.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e22676a5b875bd72acd3d11d5fa9075d3a5f53b877fe7b4793e4673499318ba"}, + {file = "ruff-0.2.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1695700d1e25a99d28f7a1636d85bafcc5030bba9d0578c0781ba1790dbcf51c"}, + {file = "ruff-0.2.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:b0c232af3d0bd8f521806223723456ffebf8e323bd1e4e82b0befb20ba18388e"}, + {file = "ruff-0.2.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f63d96494eeec2fc70d909393bcd76c69f35334cdbd9e20d089fb3f0640216ca"}, + {file = "ruff-0.2.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a61ea0ff048e06de273b2e45bd72629f470f5da8f71daf09fe481278b175001"}, + {file = "ruff-0.2.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e1439c8f407e4f356470e54cdecdca1bd5439a0673792dbe34a2b0a551a2fe3"}, + {file = "ruff-0.2.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:940de32dc8853eba0f67f7198b3e79bc6ba95c2edbfdfac2144c8235114d6726"}, + {file = "ruff-0.2.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:0c126da55c38dd917621552ab430213bdb3273bb10ddb67bc4b761989210eb6e"}, + {file = "ruff-0.2.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:3b65494f7e4bed2e74110dac1f0d17dc8e1f42faaa784e7c58a98e335ec83d7e"}, + {file = "ruff-0.2.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1ec49be4fe6ddac0503833f3ed8930528e26d1e60ad35c2446da372d16651ce9"}, + {file = "ruff-0.2.2-py3-none-win32.whl", hash = "sha256:d920499b576f6c68295bc04e7b17b6544d9d05f196bb3aac4358792ef6f34325"}, + {file = "ruff-0.2.2-py3-none-win_amd64.whl", hash = "sha256:cc9a91ae137d687f43a44c900e5d95e9617cb37d4c989e462980ba27039d239d"}, + {file = "ruff-0.2.2-py3-none-win_arm64.whl", hash = "sha256:c9d15fc41e6054bfc7200478720570078f0b41c9ae4f010bcc16bd6f4d1aacdd"}, + {file = "ruff-0.2.2.tar.gz", hash = "sha256:e62ed7f36b3068a30ba39193a14274cd706bc486fad521276458022f7bccb31d"}, +] + +[[package]] +name = "scikit-learn" +version = "1.5.2" +description = "A set of python modules for machine learning and data mining" +optional = false +python-versions = ">=3.9" +files = [ + {file = "scikit_learn-1.5.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:299406827fb9a4f862626d0fe6c122f5f87f8910b86fe5daa4c32dcd742139b6"}, + {file = "scikit_learn-1.5.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:2d4cad1119c77930b235579ad0dc25e65c917e756fe80cab96aa3b9428bd3fb0"}, + {file = "scikit_learn-1.5.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c412ccc2ad9bf3755915e3908e677b367ebc8d010acbb3f182814524f2e5540"}, + {file = "scikit_learn-1.5.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a686885a4b3818d9e62904d91b57fa757fc2bed3e465c8b177be652f4dd37c8"}, + {file = "scikit_learn-1.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:c15b1ca23d7c5f33cc2cb0a0d6aaacf893792271cddff0edbd6a40e8319bc113"}, + {file = "scikit_learn-1.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:03b6158efa3faaf1feea3faa884c840ebd61b6484167c711548fce208ea09445"}, + {file = "scikit_learn-1.5.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1ff45e26928d3b4eb767a8f14a9a6efbf1cbff7c05d1fb0f95f211a89fd4f5de"}, + {file = "scikit_learn-1.5.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f763897fe92d0e903aa4847b0aec0e68cadfff77e8a0687cabd946c89d17e675"}, + {file = "scikit_learn-1.5.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8b0ccd4a902836493e026c03256e8b206656f91fbcc4fde28c57a5b752561f1"}, + {file = "scikit_learn-1.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:6c16d84a0d45e4894832b3c4d0bf73050939e21b99b01b6fd59cbb0cf39163b6"}, + {file = "scikit_learn-1.5.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f932a02c3f4956dfb981391ab24bda1dbd90fe3d628e4b42caef3e041c67707a"}, + {file = "scikit_learn-1.5.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:3b923d119d65b7bd555c73be5423bf06c0105678ce7e1f558cb4b40b0a5502b1"}, + {file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f60021ec1574e56632be2a36b946f8143bf4e5e6af4a06d85281adc22938e0dd"}, + {file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:394397841449853c2290a32050382edaec3da89e35b3e03d6cc966aebc6a8ae6"}, + {file = "scikit_learn-1.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:57cc1786cfd6bd118220a92ede80270132aa353647684efa385a74244a41e3b1"}, + {file = "scikit_learn-1.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9a702e2de732bbb20d3bad29ebd77fc05a6b427dc49964300340e4c9328b3f5"}, + {file = "scikit_learn-1.5.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:b0768ad641981f5d3a198430a1d31c3e044ed2e8a6f22166b4d546a5116d7908"}, + {file = "scikit_learn-1.5.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:178ddd0a5cb0044464fc1bfc4cca5b1833bfc7bb022d70b05db8530da4bb3dd3"}, + {file = "scikit_learn-1.5.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7284ade780084d94505632241bf78c44ab3b6f1e8ccab3d2af58e0e950f9c12"}, + {file = "scikit_learn-1.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:b7b0f9a0b1040830d38c39b91b3a44e1b643f4b36e36567b80b7c6bd2202a27f"}, + {file = "scikit_learn-1.5.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:757c7d514ddb00ae249832fe87100d9c73c6ea91423802872d9e74970a0e40b9"}, + {file = "scikit_learn-1.5.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:52788f48b5d8bca5c0736c175fa6bdaab2ef00a8f536cda698db61bd89c551c1"}, + {file = "scikit_learn-1.5.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:643964678f4b5fbdc95cbf8aec638acc7aa70f5f79ee2cdad1eec3df4ba6ead8"}, + {file = "scikit_learn-1.5.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca64b3089a6d9b9363cd3546f8978229dcbb737aceb2c12144ee3f70f95684b7"}, + {file = "scikit_learn-1.5.2-cp39-cp39-win_amd64.whl", hash = "sha256:3bed4909ba187aca80580fe2ef370d9180dcf18e621a27c4cf2ef10d279a7efe"}, + {file = "scikit_learn-1.5.2.tar.gz", hash = "sha256:b4237ed7b3fdd0a4882792e68ef2545d5baa50aca3bb45aa7df468138ad8f94d"}, +] + +[package.dependencies] +joblib = ">=1.2.0" +numpy = ">=1.19.5" +scipy = ">=1.6.0" +threadpoolctl = ">=3.1.0" + +[package.extras] +benchmark = ["matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "pandas (>=1.1.5)"] +build = ["cython (>=3.0.10)", "meson-python (>=0.16.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pydata-sphinx-theme (>=0.15.3)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=7.3.7)", "sphinx-copybutton (>=0.5.2)", "sphinx-design (>=0.5.0)", "sphinx-design (>=0.6.0)", "sphinx-gallery (>=0.16.0)", "sphinx-prompt (>=1.4.0)", "sphinx-remove-toctrees (>=1.0.0.post1)", "sphinxcontrib-sass (>=0.3.4)", "sphinxext-opengraph (>=0.9.1)"] +examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"] +install = ["joblib (>=1.2.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)", "threadpoolctl (>=3.1.0)"] +maintenance = ["conda-lock (==2.5.6)"] +tests = ["black (>=24.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.9)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.2.1)", "scikit-image (>=0.17.2)"] + +[[package]] +name = "scipy" +version = "1.14.1" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = ">=3.10" +files = [ + {file = "scipy-1.14.1-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:b28d2ca4add7ac16ae8bb6632a3c86e4b9e4d52d3e34267f6e1b0c1f8d87e389"}, + {file = "scipy-1.14.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d0d2821003174de06b69e58cef2316a6622b60ee613121199cb2852a873f8cf3"}, + {file = "scipy-1.14.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8bddf15838ba768bb5f5083c1ea012d64c9a444e16192762bd858f1e126196d0"}, + {file = "scipy-1.14.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:97c5dddd5932bd2a1a31c927ba5e1463a53b87ca96b5c9bdf5dfd6096e27efc3"}, + {file = "scipy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ff0a7e01e422c15739ecd64432743cf7aae2b03f3084288f399affcefe5222d"}, + {file = "scipy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e32dced201274bf96899e6491d9ba3e9a5f6b336708656466ad0522d8528f69"}, + {file = "scipy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8426251ad1e4ad903a4514712d2fa8fdd5382c978010d1c6f5f37ef286a713ad"}, + {file = "scipy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:a49f6ed96f83966f576b33a44257d869756df6cf1ef4934f59dd58b25e0327e5"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:2da0469a4ef0ecd3693761acbdc20f2fdeafb69e6819cc081308cc978153c675"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:c0ee987efa6737242745f347835da2cc5bb9f1b42996a4d97d5c7ff7928cb6f2"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3a1b111fac6baec1c1d92f27e76511c9e7218f1695d61b59e05e0fe04dc59617"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8475230e55549ab3f207bff11ebfc91c805dc3463ef62eda3ccf593254524ce8"}, + {file = "scipy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:278266012eb69f4a720827bdd2dc54b2271c97d84255b2faaa8f161a158c3b37"}, + {file = "scipy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fef8c87f8abfb884dac04e97824b61299880c43f4ce675dd2cbeadd3c9b466d2"}, + {file = "scipy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b05d43735bb2f07d689f56f7b474788a13ed8adc484a85aa65c0fd931cf9ccd2"}, + {file = "scipy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:716e389b694c4bb564b4fc0c51bc84d381735e0d39d3f26ec1af2556ec6aad94"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:631f07b3734d34aced009aaf6fedfd0eb3498a97e581c3b1e5f14a04164a456d"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:af29a935803cc707ab2ed7791c44288a682f9c8107bc00f0eccc4f92c08d6e07"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2843f2d527d9eebec9a43e6b406fb7266f3af25a751aa91d62ff416f54170bc5"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:eb58ca0abd96911932f688528977858681a59d61a7ce908ffd355957f7025cfc"}, + {file = "scipy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30ac8812c1d2aab7131a79ba62933a2a76f582d5dbbc695192453dae67ad6310"}, + {file = "scipy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f9ea80f2e65bdaa0b7627fb00cbeb2daf163caa015e59b7516395fe3bd1e066"}, + {file = "scipy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:edaf02b82cd7639db00dbff629995ef185c8df4c3ffa71a5562a595765a06ce1"}, + {file = "scipy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2ff38e22128e6c03ff73b6bb0f85f897d2362f8c052e3b8ad00532198fbdae3f"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1729560c906963fc8389f6aac023739ff3983e727b1a4d87696b7bf108316a79"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:4079b90df244709e675cdc8b93bfd8a395d59af40b72e339c2287c91860deb8e"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e0cf28db0f24a38b2a0ca33a85a54852586e43cf6fd876365c86e0657cfe7d73"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0c2f95de3b04e26f5f3ad5bb05e74ba7f68b837133a4492414b3afd79dfe540e"}, + {file = "scipy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b99722ea48b7ea25e8e015e8341ae74624f72e5f21fc2abd45f3a93266de4c5d"}, + {file = "scipy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5149e3fd2d686e42144a093b206aef01932a0059c2a33ddfa67f5f035bdfe13e"}, + {file = "scipy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4f5a7c49323533f9103d4dacf4e4f07078f360743dec7f7596949149efeec06"}, + {file = "scipy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:baff393942b550823bfce952bb62270ee17504d02a1801d7fd0719534dfb9c84"}, + {file = "scipy-1.14.1.tar.gz", hash = "sha256:5a275584e726026a5699459aa72f828a610821006228e841b94275c4a7c08417"}, +] + +[package.dependencies] +numpy = ">=1.23.5,<2.3" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.13.1)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0,<=7.3.7)", "sphinx-design (>=0.4.0)"] +test = ["Cython", "array-api-strict (>=2.0)", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "smmap" +version = "5.0.1" +description = "A pure Python implementation of a sliding window memory map manager" +optional = false +python-versions = ">=3.7" +files = [ + {file = "smmap-5.0.1-py3-none-any.whl", hash = "sha256:e6d8668fa5f93e706934a62d7b4db19c8d9eb8cf2adbb75ef1b675aa332b69da"}, + {file = "smmap-5.0.1.tar.gz", hash = "sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62"}, +] + +[[package]] +name = "threadpoolctl" +version = "3.5.0" +description = "threadpoolctl" +optional = false +python-versions = ">=3.8" +files = [ + {file = "threadpoolctl-3.5.0-py3-none-any.whl", hash = "sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467"}, + {file = "threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107"}, +] + +[[package]] +name = "tomli" +version = "2.2.1" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"}, + {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"}, + {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"}, + {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"}, + {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"}, + {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"}, + {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"}, + {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"}, + {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"}, + {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"}, + {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"}, + {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"}, + {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"}, + {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"}, + {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"}, + {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"}, + {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"}, + {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"}, + {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"}, + {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"}, + {file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"}, + {file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"}, + {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"}, + {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"}, + {file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"}, + {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"}, + {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"}, + {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"}, + {file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"}, + {file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"}, + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, +] + +[[package]] +name = "types-pytz" +version = "2024.2.0.20241003" +description = "Typing stubs for pytz" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-pytz-2024.2.0.20241003.tar.gz", hash = "sha256:575dc38f385a922a212bac00a7d6d2e16e141132a3c955078f4a4fd13ed6cb44"}, + {file = "types_pytz-2024.2.0.20241003-py3-none-any.whl", hash = "sha256:3e22df1336c0c6ad1d29163c8fda82736909eb977281cb823c57f8bae07118b7"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.2" +description = "Provider of IANA time zone data" +optional = false +python-versions = ">=2" +files = [ + {file = "tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd"}, + {file = "tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc"}, +] + +[[package]] +name = "virtualenv" +version = "20.28.0" +description = "Virtual Python Environment builder" +optional = false +python-versions = ">=3.8" +files = [ + {file = "virtualenv-20.28.0-py3-none-any.whl", hash = "sha256:23eae1b4516ecd610481eda647f3a7c09aea295055337331bb4e6892ecce47b0"}, + {file = "virtualenv-20.28.0.tar.gz", hash = "sha256:2c9c3262bb8e7b87ea801d715fae4495e6032450c71d2309be9550e7364049aa"}, +] + +[package.dependencies] +distlib = ">=0.3.7,<1" +filelock = ">=3.12.2,<4" +platformdirs = ">=3.9.1,<5" + +[package.extras] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"] + +[[package]] +name = "win32-setctime" +version = "1.1.0" +description = "A small Python utility to set file creation time on Windows" +optional = false +python-versions = ">=3.5" +files = [ + {file = "win32_setctime-1.1.0-py3-none-any.whl", hash = "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad"}, + {file = "win32_setctime-1.1.0.tar.gz", hash = "sha256:15cf5750465118d6929ae4de4eb46e8edae9a5634350c01ba582df868e932cb2"}, +] + +[package.extras] +dev = ["black (>=19.3b0)", "pytest (>=4.6.2)"] + +[metadata] +lock-version = "2.0" +python-versions = ">=3.10,<3.13" +content-hash = "62b2c6456e33a45ebdc15be990837e5cb7243b3938876557de16c16d3bba74dc" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..651bebb --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,92 @@ +[tool.poetry] +name = "fedpydeseq2_datasets" +version = "0.1.0" +description = "This package contains utilities to process TCGA data for fedpydeseq2." +authors = ["Boris MUZELLEC ", "Ulysse MARTEAU ", "Tanguy MARCHAND "] +readme = "README.md" +packages = [{include = "fedpydeseq2_datasets", from = "./"}] +include = ["fedpydeseq2_datasets/assets", "fedpydeseq2_datasets/download_data"] + + +[build-system] +requires = ["poetry-core>=1.0.0", "setuptools>=65.6.3"] +build-backend = "poetry.core.masonry.api" + +[tool.poetry.dependencies] +python = ">=3.10,<3.13" +numpy = "1.26.4" +pandas = "2.2.2" +pyarrow = "15.0.2" +gitpython = "3.1.43" +anndata = "0.10.8" +pydeseq2 = "0.4.9" +loguru = "0.7.2" +pyyaml = ">=5.1" + + + +[tool.poetry.group.linting] +optional = true + +[tool.poetry.group.linting.dependencies] +ruff = "^0.2.2" +pre-commit = "^3.6.2" +mypy = "^1.8.0" +black = "^24.2.0" +pandas-stubs = "^2.2.0.240218" + +[tool.poetry.group.testing] +optional = true + +[tool.poetry.group.testing.dependencies] +pytest = "^8.0.1" + +[tool.poetry.scripts] +fedpydeseq2-download-data = "fedpydeseq2_datasets.download_data.download_data:main" + +[tool.black] +line-length = 88 + +[tool.ruff] +target-version = "py311" +line-length = 88 +lint.select = [ + "F", # Errors detected by Pyflakes + "E", # Error detected by Pycodestyle + "W", # Warning detected by Pycodestyle + "I", # isort + "D", # pydocstyle + "B", # flake8-bugbear + "TID", # flake8-tidy-imports + "C4", # flake8-comprehensions + "BLE", # flake8-blind-except + "UP", # pyupstage + "RUF100", # Report unused noqa directives + "D401", # Start docstrgins with an imperative verb + "D415", # End docstrings with a period + "D417", # Missing argument descriptions in the docstring +] + +lint.ignore = [ + # Missing docstring in public package + "D104", + # Missing docstring in public module + "D100", + # Missing docstring in __init__ + "D107", + # We don’t want a blank line before a class docstring + "D203", + # We want docstrings to start immediately after the opening triple quote + "D213", +] + +[tool.ruff.lint.isort] +force-single-line = true + +[tool.ruff.lint.pydocstyle] +convention = "numpy" + +[tool.ruff.lint.per-file-ignores] +"tests/*" = ["D"] +# Ignore unused imports in __init__.py files +"*/__init__.py" = ["F401", "I"] diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..ab59313 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,28 @@ +import json +from pathlib import Path + +import pytest + + +@pytest.fixture(scope="session") +def raw_data_path(): + """Fixture to get the path to the raw data.""" + default_paths = Path(__file__).parent / "paths_default.json" + specified_paths = Path(__file__).parent / "paths.json" + if specified_paths.exists(): + with open(specified_paths) as f: + raw_data_path = json.load(f)["raw_data"] + else: + with open(default_paths) as f: + raw_data_path = json.load(f)["raw_data"] + if raw_data_path.startswith("/"): + raw_data_path = Path(raw_data_path) + else: + raw_data_path = Path(__file__).parent / raw_data_path + print("Test raw data path") + return raw_data_path + + +@pytest.fixture(scope="session") +def tmp_processed_data_path(tmpdir_factory): + return Path(tmpdir_factory.mktemp("processed")) diff --git a/tests/paths_default.json b/tests/paths_default.json new file mode 100644 index 0000000..17db178 --- /dev/null +++ b/tests/paths_default.json @@ -0,0 +1 @@ +{"raw_data": "../../fedpydeseq2-datasets/data/raw"} diff --git a/tests/test_create_reference_dds.py b/tests/test_create_reference_dds.py new file mode 100644 index 0000000..8a0d9d6 --- /dev/null +++ b/tests/test_create_reference_dds.py @@ -0,0 +1,89 @@ +import pytest + +from fedpydeseq2_datasets.create_reference_dds import setup_tcga_ground_truth_dds +from fedpydeseq2_datasets.process_and_split_data import setup_tcga_dataset + + +@pytest.mark.parametrize( + "dataset_name", + [ + "TCGA-LUAD", + ], +) +@pytest.mark.usefixtures("raw_data_path", "tmp_processed_data_path") +def test_tcga_preprocessing_and_pooled_pydeseq2_all_indications_small( + raw_data_path, tmp_processed_data_path, dataset_name +): + """Build all necessary quantities for all tests. + + Builds ground truths. + """ + + setup_tcga_dataset( + raw_data_path, + tmp_processed_data_path, + dataset_name=dataset_name, + small_samples=True, + small_genes=True, + only_two_centers=False, + design_factors="stage", + continuous_factors=None, + refit_cooks=True, + force=True, + ) + print("Setting up TCGA ground truth DESeq2 datasets...") + setup_tcga_ground_truth_dds( + tmp_processed_data_path, + dataset_name=dataset_name, + small_samples=True, + small_genes=True, + only_two_centers=False, + design_factors="stage", + continuous_factors=None, + reference_dds_ref_level=("stage", "Advanced"), + refit_cooks=True, + force=True, + ) + + +@pytest.mark.parametrize( + "dataset_name", + [ + "TCGA-LUAD", + ], +) +@pytest.mark.usefixtures("raw_data_path", "tmp_processed_data_path") +def test_tcga_preprocessing_and_per_center_pydeseq2_all_indications_small( + raw_data_path, tmp_processed_data_path, dataset_name +): + """Build all necessary quantities for all tests. + + Builds ground truths. + """ + + setup_tcga_dataset( + raw_data_path, + tmp_processed_data_path, + dataset_name=dataset_name, + small_samples=True, + small_genes=True, + only_two_centers=False, + design_factors="stage", + continuous_factors=None, + refit_cooks=True, + force=True, + ) + print("Setting up TCGA ground truth DESeq2 datasets...") + setup_tcga_ground_truth_dds( + tmp_processed_data_path, + dataset_name=dataset_name, + small_samples=True, + small_genes=True, + only_two_centers=False, + design_factors="stage", + continuous_factors=None, + reference_dds_ref_level=("stage", "Advanced"), + refit_cooks=True, + force=True, + pooled=False, + ) diff --git a/tests/test_process_and_split_data.py b/tests/test_process_and_split_data.py new file mode 100644 index 0000000..c7fa13d --- /dev/null +++ b/tests/test_process_and_split_data.py @@ -0,0 +1,31 @@ +import pytest + +from fedpydeseq2_datasets.process_and_split_data import setup_tcga_dataset + + +@pytest.mark.parametrize( + "dataset_name", + [ + "TCGA-LUAD", + ], +) +@pytest.mark.usefixtures("raw_data_path", "tmp_processed_data_path") +def test_tcga_preprocessing_all_indications_small( + raw_data_path, tmp_processed_data_path, dataset_name +): + """Build all necessary quantities for all tests. + + Builds ground truths. + """ + + setup_tcga_dataset( + raw_data_path, + tmp_processed_data_path, + dataset_name=dataset_name, + small_samples=True, + small_genes=True, + only_two_centers=False, + design_factors="stage", + continuous_factors=None, + force=True, + ) diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..05bc89a --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,48 @@ +import numpy as np +import pandas as pd +import pytest + +from fedpydeseq2_datasets.utils import mix_centers + + +@pytest.mark.parametrize( + "heterogeneity_method, heterogeneity_method_param", + [ + ("binomial", 0.0), + ("binomial", 0.2), + ("binomial", 0.5), + ("binomial", 0.8), + ("binomial", 1), + ], +) +def test_mix_centers(heterogeneity_method, heterogeneity_method_param): + # Create a sample metadata DataFrame + np.random.seed(0) + metadata = pd.DataFrame( + { + "SampleID": [f"sample_{i}" for i in range(1000)], + "center_id": np.random.choice([0, 1], size=1000), + } + ) + old_metadata = metadata.copy() + # Call the mix_centers function + mix_centers(metadata, heterogeneity_method, heterogeneity_method_param) + + cross_table = pd.crosstab(metadata["center_id"], old_metadata["center_id"]) + + # Expected proportions + expected_cross_table = np.zeros((2, 2)) + center_0_count = sum(old_metadata["center_id"] == 0) + center_1_count = sum(old_metadata["center_id"] == 1) + + # Calculate the expected values based on the binomial distribution + expected_cross_table[0, 0] = center_0_count * (1 - heterogeneity_method_param / 2.0) + expected_cross_table[0, 1] = center_1_count * (heterogeneity_method_param / 2.0) + expected_cross_table[1, 0] = center_0_count * (heterogeneity_method_param / 2.0) + expected_cross_table[1, 1] = center_1_count * (1 - heterogeneity_method_param / 2.0) + + # Allow some tolerance due to randomness + tolerance = 0.1 * (center_0_count + center_1_count) + + # Check that the observed values are close to the expected values + assert np.allclose(cross_table.values, expected_cross_table, atol=tolerance)