From 7445296e6a4e9a92d64c14ca141bac845584785b Mon Sep 17 00:00:00 2001 From: Nikos Livathinos Date: Mon, 15 Jul 2024 10:52:19 +0200 Subject: [PATCH] Initial commit Signed-off-by: Nikos Livathinos --- .gitignore | 60 + .pre-commit-config.yaml | 43 + CODE_OF_CONDUCT.md | 129 + CONTRIBUTING.md | 163 + LICENSE | 21 + MAINTAINERS.md | 10 + README.md | 127 + demo/demo_layout_predictor.py | 126 + devtools/check_code.sh | 96 + .../layoutmodel/layout_predictor.py | 171 + docling_ibm_models/tableformer/__init__.py | 0 docling_ibm_models/tableformer/common.py | 200 ++ .../tableformer/data_management/__init__.py | 0 .../data_management/data_transformer.py | 504 +++ .../tableformer/data_management/functional.py | 574 ++++ .../matching_post_processor.py | 1325 ++++++++ .../data_management/tf_cell_matcher.py | 596 ++++ .../tableformer/data_management/tf_dataset.py | 1233 ++++++++ .../data_management/tf_predictor.py | 1020 ++++++ .../tableformer/data_management/transforms.py | 396 +++ .../tableformer/models/__init__.py | 0 .../tableformer/models/common/__init__.py | 0 .../tableformer/models/common/base_model.py | 279 ++ .../tableformer/models/table04_rs/__init__.py | 0 .../models/table04_rs/bbox_decoder_rs.py | 163 + .../models/table04_rs/encoder04_rs.py | 72 + .../models/table04_rs/tablemodel04_rs.py | 324 ++ .../models/table04_rs/transformer_rs.py | 203 ++ docling_ibm_models/tableformer/otsl.py | 541 ++++ docling_ibm_models/tableformer/settings.py | 90 + .../tableformer/test_dataset_cache.py | 37 + .../tableformer/test_prepare_image.py | 99 + .../tableformer/utils/__init__.py | 0 .../tableformer/utils/app_profiler.py | 243 ++ .../tableformer/utils/torch_utils.py | 216 ++ docling_ibm_models/tableformer/utils/utils.py | 376 +++ .../tableformer/utils/variance.py | 175 ++ docs/tablemodel_overview_color.png | Bin 0 -> 242920 bytes docs/tbm04.png | Bin 0 -> 205214 bytes poetry.lock | 2787 +++++++++++++++++ pyproject.toml | 66 + tests/__init__.py | 0 tests/test_common.py | 72 + .../model_artifacts/put_model_check_here.txt | 1 + tests/test_data/samples/ADS.2007.page_123.png | Bin 0 -> 397878 bytes ...S.2007.page_123.png_iocr.parse_format.json | 1 + tests/test_data/samples/PHM.2013.page_30.png | Bin 0 -> 174098 bytes ...HM.2013.page_30.png_iocr.parse_format.json | 1 + tests/test_layout_predictor.py | 88 + tests/test_tf_predictor.py | 627 ++++ 50 files changed, 13255 insertions(+) create mode 100644 .gitignore create mode 100644 .pre-commit-config.yaml create mode 100644 CODE_OF_CONDUCT.md create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE create mode 100644 MAINTAINERS.md create mode 100644 README.md create mode 100644 demo/demo_layout_predictor.py create mode 100755 devtools/check_code.sh create mode 100644 docling_ibm_models/layoutmodel/layout_predictor.py create mode 100644 docling_ibm_models/tableformer/__init__.py create mode 100644 docling_ibm_models/tableformer/common.py create mode 100644 docling_ibm_models/tableformer/data_management/__init__.py create mode 100644 docling_ibm_models/tableformer/data_management/data_transformer.py create mode 100644 docling_ibm_models/tableformer/data_management/functional.py create mode 100644 docling_ibm_models/tableformer/data_management/matching_post_processor.py create mode 100644 docling_ibm_models/tableformer/data_management/tf_cell_matcher.py create mode 100644 docling_ibm_models/tableformer/data_management/tf_dataset.py create mode 100644 docling_ibm_models/tableformer/data_management/tf_predictor.py create mode 100644 docling_ibm_models/tableformer/data_management/transforms.py create mode 100644 docling_ibm_models/tableformer/models/__init__.py create mode 100644 docling_ibm_models/tableformer/models/common/__init__.py create mode 100644 docling_ibm_models/tableformer/models/common/base_model.py create mode 100644 docling_ibm_models/tableformer/models/table04_rs/__init__.py create mode 100644 docling_ibm_models/tableformer/models/table04_rs/bbox_decoder_rs.py create mode 100644 docling_ibm_models/tableformer/models/table04_rs/encoder04_rs.py create mode 100644 docling_ibm_models/tableformer/models/table04_rs/tablemodel04_rs.py create mode 100644 docling_ibm_models/tableformer/models/table04_rs/transformer_rs.py create mode 100644 docling_ibm_models/tableformer/otsl.py create mode 100644 docling_ibm_models/tableformer/settings.py create mode 100644 docling_ibm_models/tableformer/test_dataset_cache.py create mode 100644 docling_ibm_models/tableformer/test_prepare_image.py create mode 100644 docling_ibm_models/tableformer/utils/__init__.py create mode 100644 docling_ibm_models/tableformer/utils/app_profiler.py create mode 100644 docling_ibm_models/tableformer/utils/torch_utils.py create mode 100644 docling_ibm_models/tableformer/utils/utils.py create mode 100644 docling_ibm_models/tableformer/utils/variance.py create mode 100644 docs/tablemodel_overview_color.png create mode 100644 docs/tbm04.png create mode 100644 poetry.lock create mode 100644 pyproject.toml create mode 100644 tests/__init__.py create mode 100644 tests/test_common.py create mode 100644 tests/test_data/model_artifacts/put_model_check_here.txt create mode 100644 tests/test_data/samples/ADS.2007.page_123.png create mode 100644 tests/test_data/samples/ADS.2007.page_123.png_iocr.parse_format.json create mode 100644 tests/test_data/samples/PHM.2013.page_30.png create mode 100644 tests/test_data/samples/PHM.2013.page_30.png_iocr.parse_format.json create mode 100644 tests/test_layout_predictor.py create mode 100644 tests/test_tf_predictor.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..34c70f7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,60 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# Tmp files and directories +stderr.* +stdout.* +*.tar +test.sh +OutputDecoder +jobs.txt +_std*.* +tests/tmp/* +runs/* +*.onnx +.DS_Store +viz/ + +# VIM +*.swp +*.swo +*.bak + +# Environments +.env +.venv +_venv/ +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ +venv + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# checkpoint file for testing +tests/test_data/model_artifacts/*.check +tests/test_data/model_artifacts/*.json +tests/test_data/model_artifacts/*.pt + +# test results +tests/test_data/viz/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..fa5c0b8 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,43 @@ +fail_fast: true +repos: + - repo: local + hooks: + - id: system + name: Black + entry: poetry run black docling_ibm_models + pass_filenames: false + language: system + files: '\.py$' + - repo: local + hooks: + - id: system + name: isort + entry: poetry run isort docling_ibm_models + pass_filenames: false + language: system + files: '\.py$' + - repo: local + hooks: + - id: system + name: Poetry check + entry: poetry lock --check + pass_filenames: false + language: system + +# Ready to be enabled soon +# - repo: local +# hooks: +# - id: system +# name: flake8 +# entry: poetry run flake8 docling_ibm_models +# pass_filenames: false +# language: system +# files: '\.py$' +# - repo: local +# hooks: +# - id: system +# name: MyPy +# entry: poetry run mypy docling_ibm_models +# pass_filenames: false +# language: system +# files: '\.py$' \ No newline at end of file diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..c7d5ea1 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,129 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, religion, or sexual identity +and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the + overall community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or + advances of any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email + address, without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement using +[deepsearch-core@zurich.ibm.com](mailto:deepsearch-core@zurich.ibm.com). + +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series +of actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or +permanent ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within +the community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.0, available at +[https://www.contributor-covenant.org/version/2/0/code_of_conduct.html](https://www.contributor-covenant.org/version/2/0/code_of_conduct.html). + +Community Impact Guidelines were inspired by [Mozilla's code of conduct +enforcement ladder](https://github.com/mozilla/diversity). + +Homepage: [https://www.contributor-covenant.org](https://www.contributor-covenant.org) + +For answers to common questions about this code of conduct, see the FAQ at +[https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq). Translations are available at +[https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations). \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..9e385ac --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,163 @@ +## Contributing In General +Our project welcomes external contributions. If you have an itch, please feel +free to scratch it. + +To contribute code or documentation, please submit a [pull request](https://github.com/DS4SD/docling/pulls). + +A good way to familiarize yourself with the codebase and contribution process is +to look for and tackle low-hanging fruit in the [issue tracker](https://github.com/DS4SD/docling/issues). +Before embarking on a more ambitious contribution, please quickly [get in touch](#communication) with us. + +For general questions or support requests, please refer to the [discussion section](https://github.com/DS4SD/docling/discussions). + +**Note: We appreciate your effort, and want to avoid a situation where a contribution +requires extensive rework (by you or by us), sits in backlog for a long time, or +cannot be accepted at all!** + +### Proposing new features + +If you would like to implement a new feature, please [raise an issue](https://github.com/DS4SD/docling/issues) +before sending a pull request so the feature can be discussed. This is to avoid +you wasting your valuable time working on a feature that the project developers +are not interested in accepting into the code base. + +### Fixing bugs + +If you would like to fix a bug, please [raise an issue](https://github.com/DS4SD/docling/issues) before sending a +pull request so it can be tracked. + +### Merge approval + +The project maintainers use LGTM (Looks Good To Me) in comments on the code +review to indicate acceptance. A change requires LGTMs from two of the +maintainers of each component affected. + +For a list of the maintainers, see the [MAINTAINERS.md](MAINTAINERS.md) page. + + +## Legal + +Each source file must include a license header for the MIT +Software. Using the SPDX format is the simplest approach. +e.g. + +``` +/* +Copyright IBM Inc. All rights reserved. + +SPDX-License-Identifier: MIT +*/ +``` + +We have tried to make it as easy as possible to make contributions. This +applies to how we handle the legal aspects of contribution. We use the +same approach - the [Developer's Certificate of Origin 1.1 (DCO)](https://github.com/hyperledger/fabric/blob/master/docs/source/DCO1.1.txt) - that the Linux® Kernel [community](https://elinux.org/Developer_Certificate_Of_Origin) +uses to manage code contributions. + +We simply ask that when submitting a patch for review, the developer +must include a sign-off statement in the commit message. + +Here is an example Signed-off-by line, which indicates that the +submitter accepts the DCO: + +``` +Signed-off-by: John Doe +``` + +You can include this automatically when you commit a change to your +local git repository using the following command: + +``` +git commit -s +``` + + +## Communication + +Please feel free to connect with us using the [discussion section](https://github.com/DS4SD/docling/discussions). + + + +## Developing + +### Usage of Poetry + +We use Poetry to manage dependencies. + + +#### Install + +To install, see the documentation here: https://python-poetry.org/docs/master/#installing-with-the-official-installer + +1. Install the Poetry globally in your machine + ```bash + curl -sSL https://install.python-poetry.org | python3 - + ``` + The installation script will print the installation bin folder `POETRY_BIN` which you need in the next steps. + +2. Make sure Poetry is in your `$PATH` + - for `zsh` + ```sh + echo 'export PATH="POETRY_BIN:$PATH"' >> ~/.zshrc + ``` + - for `bash` + ```sh + echo 'export PATH="POETRY_BIN:$PATH"' >> ~/.bashrc + ``` + +3. The official guidelines linked above include useful details on the configuration of autocomplete for most shell environments, e.g. Bash and Zsh. + + +#### Create a Virtual Environment and Install Dependencies + +To activate the Virtual Environment, run: + +```bash +poetry shell +``` + +To spawn a shell with the Virtual Environment activated. If the Virtual Environment doesn't exist, Poetry will create one for you. Then, to install dependencies, run: + +```bash +poetry install +``` + +**(Advanced) Use a Specific Python Version** + +If for whatever reason you need to work in a specific (older) version of Python, run: + +```bash +poetry env use $(which python3.11) +``` + +This creates a Virtual Environment with Python 3.11. For other versions, replace `$(which python3.11)` by the path to the interpreter (e.g., `/usr/bin/python3.11`) or use `$(which pythonX.Y)`. + + +#### Add a new dependency + +```bash +poetry add NAME +``` + +## Coding style guidelines + +We use the following tools to enforce code style: + +- iSort, to sort imports +- Black, to format code + + +We run a series of checks on the code base on every commit, using `pre-commit`. To install the hooks, run: + +```bash +pre-commit install +``` + +To run the checks on-demand, run: + +``` +pre-commit run --all-files +``` + +Note: Checks like `Black` and `isort` will "fail" if they modify files. This is because `pre-commit` doesn't like to see files modified by their Hooks. In these cases, `git add` the modified files and `git commit` again. + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8aa2645 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) [year] [fullname] + +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/MAINTAINERS.md b/MAINTAINERS.md new file mode 100644 index 0000000..e4549bd --- /dev/null +++ b/MAINTAINERS.md @@ -0,0 +1,10 @@ +# MAINTAINERS + +- Christoph Auer - [@cau-git](https://github.com/cau-git) +- Michele Dolfi - [@dolfim-ibm](https://github.com/dolfim-ibm) +- Maxim Lysak - [@maxmnemonic](https://github.com/maxmnemonic) +- Nikos Livathinos - [@nikos-livathinos](https://github.com/nikos-livathinos) +- Ahmed Nassar - [@nassarofficial](https://github.com/nassarofficial) +- Peter Staar - [@PeterStaar-IBM](https://github.com/PeterStaar-IBM) + +Maintainers can be contacted at [deepsearch-core@zurich.ibm.com](mailto:deepsearch-core@zurich.ibm.com). diff --git a/README.md b/README.md new file mode 100644 index 0000000..6e5aac4 --- /dev/null +++ b/README.md @@ -0,0 +1,127 @@ +# Docling-models + +AI modules to support the Dockling PDF document conversion project. + +- TableFormer is an AI module that recognizes the structure of a table and the bounding boxes of the table content. +- Layout model is an AI model that provides among other things ability to detect tables on the page. This package contains inference code for Layout model. + + +## Installation Instructions + +### MacOS / Linux + +To install `poetry` locally, use either `pip` or `homebrew`. + +To install `poetry` on a docker container, do the following: +``` +ENV POETRY_NO_INTERACTION=1 \ + POETRY_VIRTUALENVS_CREATE=false + +# Install poetry +RUN curl -sSL 'https://install.python-poetry.org' > install-poetry.py \ + && python install-poetry.py \ + && poetry --version \ + && rm install-poetry.py +``` + +To install and run the package, simply set up a poetry environment + +``` +poetry env use $(which python3.11) +poetry shell +``` + +and install all the dependencies, + +``` +poetry install # this will only install the deps from the poetry.lock + +poetry install --no-dev # this will skip installing dev dependencies +``` + +To update or add new dependencies from `pyproject.toml`, rebuild `poetry.lock` +``` +poetry update +``` + + +## Pipeline Overview +![Architecture](docs/tablemodel_overview_color.png) + +## Datasets +Below we list datasets used with their description, source, and ***"TableFormer Format"***. The TableFormer Format is our processed version of the version of the original format to work with the dataloader out of the box, and to augment the dataset when necassary to add missing groundtruth (bounding boxes for empty cells). + + +| Name | Description | URL | +| ------------- |:-------------:|----| +| PubTabNet | PubTabNet contains heterogeneous tables in both image and HTML format, 516k+ tables in the PubMed Central Open Access Subset | [PubTabNet](https://developer.ibm.com/exchanges/data/all/pubtabnet/) | +| FinTabNet| A dataset for Financial Report Tables with corresponding ground truth location and structure. 112k+ tables included.| [FinTabNet](https://developer.ibm.com/exchanges/data/all/fintabnet/) | +| TableBank| TableBank is a new image-based table detection and recognition dataset built with novel weak supervision from Word and Latex documents on the internet, contains 417K high-quality labeled tables. | [TableBank](https://github.com/doc-analysis/TableBank) | + +## Models + +### TableModel04: +![TableModel04](docs/tbm04.png) +**TableModel04rs (OTSL)** is our SOTA method that using transformers in order to predict table structure and bounding box. + + +## Configuration file + +Example configuration can be seen inside test `tests/test_tf_predictor.py` +These are the main sections of the configuration file: + +- `dataset`: The directory for prepared data and the parameters used during the data loading. +- `model`: The type, name and hyperparameters of the model. Also the directory to save/load the + trained checkpoint files. +- `train`: Parameters for the training of the model. +- `predict`: Parameters for the evaluation of the model. +- `dataset_wordmap`: Very important part that contains token maps. + + +## Model weights + +You can download the model weights and config files from the links: + +- [TableFormer Checkpoint](https://huggingface.co/ds4sd/docling-models/tree/main/model_artifacts/tableformer) +- [beehive_v0.0.5](https://huggingface.co/ds4sd/docling-models/tree/main/model_artifacts/layout/beehive_v0.0.5) + +Place the downloaded files into `tests/test_data/model_artifacts/` directory. + + +## Inference Tests + +This contains unit tests for Docling models. + +First download the model weights (see above), then run: +``` +./devtools/check_code.sh +``` + +This will also generate prediction and matching visualizations that can be found here: +`tests\test_data\viz\` + +Visualization outlines: +- `Light Pink`: border of recognized table +- `Grey`: OCR cells +- `Green`: prediction bboxes +- `Red`: OCR cells matched with prediction +- `Blue`: Post processed, match +- `Bold Blue`: column header +- `Bold Magenta`: row header +- `Bold Brown`: section row (if table have one) + + +## Demo + +A demo application allows to apply the `LayoutPredictor` on a directory `` that contains +`png` images and visualize the predictions inside another directory ``. + +First download the model weights (see above), then run: +``` +python -m demo.demo_layout_predictor -i -v +``` + +e.g. +``` +python -m demo.demo_layout_predictor -i tests/test_data/samples -v viz/ +``` diff --git a/demo/demo_layout_predictor.py b/demo/demo_layout_predictor.py new file mode 100644 index 0000000..c6484c9 --- /dev/null +++ b/demo/demo_layout_predictor.py @@ -0,0 +1,126 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import argparse +import logging +import os +import sys +import time +from pathlib import Path + +import numpy as np +from PIL import Image, ImageDraw + +from docling_ibm_models.layoutmodel.layout_predictor import LayoutPredictor + +ARTIFACT_PATH = "tests/test_data/model_artifacts" + + +def demo( + logger: logging.Logger, + artifact_path: str, + num_threads: int, + img_dir: str, + viz_dir: str, +): + r""" + Apply LayoutPredictor on the input image directory + + If you want to load from PDF: + pdf_image = pyvips.Image.new_from_file("test_data/ADS.2007.page_123.pdf", page=0) + """ + # Create the layout predictor + lpredictor = LayoutPredictor(artifact_path, num_threads=num_threads) + logger.info("LayoutPredictor settings: {}".format(lpredictor.info())) + + # Predict all test png images + for img_fn in Path(img_dir).rglob("*.png"): + logger.info("Predicting '%s'...", img_fn) + start_t = time.time() + + with Image.open(img_fn) as image: + # Predict layout + preds = list(lpredictor.predict(image)) + dt_ms = 1000 * (time.time() - start_t) + logger.debug("Time elapsed for prediction(ms): %s", dt_ms) + + # Draw predictions + out_img = image.copy() + draw = ImageDraw.Draw(out_img) + + for i, pred in enumerate(preds): + scr = pred["confidence"] + lab = pred["label"] + box = [ + round(pred["l"]), + round(pred["t"]), + round(pred["r"]), + round(pred["b"]), + ] + + if lab == "Table": + draw.rectangle( + box, + outline="red", + ) + draw.text( + (box[0], box[1]), + text=str(lab), + fill="blue", + ) + logger.info("Table %s: bbox=%s", i, box) + + save_fn = os.path.join(viz_dir, os.path.basename(img_fn)) + out_img.save(save_fn) + logger.info("Saving prediction visualization in: '%s'", save_fn) + + +def main(args): + r""" """ + num_threads = int(args.num_threads) if args.num_threads is not None else None + img_dir = args.img_dir + viz_dir = args.viz_dir + + # Initialize logger + logger = logging.getLogger("LayoutPredictor") + logger.setLevel(logging.DEBUG) + if not logger.hasHandlers(): + handler = logging.StreamHandler(sys.stdout) + formatter = logging.Formatter( + "%(asctime)s %(name)-12s %(levelname)-8s %(message)s" + ) + handler.setFormatter(formatter) + logger.addHandler(handler) + + # Ensure the viz dir + Path(viz_dir).mkdir(parents=True, exist_ok=True) + + # Test the LayoutPredictor + demo(logger, ARTIFACT_PATH, num_threads, img_dir, viz_dir) + + +if __name__ == "__main__": + r""" + python -m demo.demo_layout_predictor -i + """ + parser = argparse.ArgumentParser(description="Test the LayoutPredictor") + parser.add_argument( + "-n", "--num_threads", required=False, default=None, help="Number of threads" + ) + parser.add_argument( + "-i", + "--img_dir", + required=True, + help="PNG images input directory", + ) + parser.add_argument( + "-v", + "--viz_dir", + required=False, + default="viz/", + help="Directory to save prediction visualizations", + ) + + args = parser.parse_args() + main(args) diff --git a/devtools/check_code.sh b/devtools/check_code.sh new file mode 100755 index 0000000..29384d4 --- /dev/null +++ b/devtools/check_code.sh @@ -0,0 +1,96 @@ +#!/bin/bash + +set -e + +# Disabled pylint messages +# C0114, C0116: Missing module docstring (missing-module-docstring) +# C0209: Formatting a regular string which could be a f-string (consider-using-f-string) +# C0103: Variable name doesn't conform to snake_case naming style (invalid-name) +# R0801: Similar lines in %s files %s +# W0621: Redefining name from outer scope +# W1514: Using open without explicitly specifying an encoding (unspecified-encoding) +# R0912: Too many branches (too-many-branches) +# R0913: Too many arguments +# R0914: Too many local variables (too-many-locals) +# R0915: Too many statements (too-many-statements) +# R1702: Too many nested blocks (too-many-nested-blocks) +# R0902: Too many instance attributes +# R0903: Too few public methods +# W0221: Arguments differ +# C0415: Import outside toplevel +# C0302: Too many lines in module +# W0718: Catching too general exception Exception +# R0902: Too many instance attributes +# R1702: Too many nested blocks +PYLINT_DISABLED="C0114,C0116,C0209,C0103,R0801,W0621,W1514,R0912,R0913,R0914,R0915,R1702" +PYLINT_DISABLED+=",R0902,R0903,W0221,C0415,C0302,R0401,W0718,R0902,R1702" + +readonly MAX_LINE_LENGTH=100 +readonly INDENT_SPACES=4 + +########################################################################################## +# Functions +# + +Usage() { + echo "Check codebase with " + echo "Usage:" + echo "$0 [-c] [-h]" + echo + echo "-c: Clear cache before invoking PyTest" + echo "-h: Print this help message" + echo + echo "$0" +} + + +########################################################################################## +# Main +# +clear_cache=0 +while getopts ":hc" option; do + case "${option}" in + c ) clear_cache=1;; + h ) Usage; exit;; + \? ) Usage; exit;; + : ) # Missing required argument + Usage; exit;; + esac +done + +# PEP8 +echo "Flake8 check:" +flake8 \ + --max-line-length=${MAX_LINE_LENGTH} \ + --indent-size=${INDENT_SPACES} \ + --ignore=E121,E123,E126,E226,E24,E704,W503,W504,W605,E203 \ + --extend-exclude '_*' \ + docling_ibm_models/ tests/ +echo "Flake8 - OK" +echo + +# # Pylint +# echo "Pylint check:" +# indent_string=$(printf '%*s' ${INDENT_SPACES} "" | tr ' ' 'n' | tr 'n' ' ') +# # echo "indent_string: '${indent_string}'" +# pylint \ +# --max-line-length ${MAX_LINE_LENGTH} \ +# --indent-string "${indent_string}" \ +# --disable ${PYLINT_DISABLED} \ +# --extension-pkg-whitelist='pydantic' \ +# --ignore-patterns '[!_]' \ +# docling_ibm_models/ tests/ +# +# echo "Pylint check - OK" +# echo + +# Unit tests with PyTest +echo "PyTest:" +if [ ${clear_cache} -eq 1 ]; then + echo "Clear pytest cache first" + echo + python -m pytest -n auto --cache-clear --ignore=docling_ibm_models/ tests/ +else + python -m pytest -n auto --ignore=docling_ibm_models/ tests/ +fi +echo "PyTest check - OK" diff --git a/docling_ibm_models/layoutmodel/layout_predictor.py b/docling_ibm_models/layoutmodel/layout_predictor.py new file mode 100644 index 0000000..c5451d5 --- /dev/null +++ b/docling_ibm_models/layoutmodel/layout_predictor.py @@ -0,0 +1,171 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import os +from collections.abc import Iterable +from typing import Union + +import numpy as np +import onnxruntime as ort +from PIL import Image + +MODEL_CHECKPOINT_FN = "model.pt" +DEFAULT_NUM_THREADS = 4 + + +# Classes: +CLASSES_MAP = { + 0: "background", + 1: "Caption", + 2: "Footnote", + 3: "Formula", + 4: "List-item", + 5: "Page-footer", + 6: "Page-header", + 7: "Picture", + 8: "Section-header", + 9: "Table", + 10: "Text", + 11: "Title", + 12: "Document Index", + 13: "Code", + 14: "Checkbox-Selected", + 15: "Checkbox-Unselected", + 16: "Form", + 17: "Key-Value Region", +} + + +class LayoutPredictor: + r""" + Document layout prediction using ONNX + """ + + def __init__( + self, artifact_path: str, num_threads: int = None, use_cpu_only: bool = False + ): + r""" + Provide the artifact path that contains the LayoutModel ONNX file + + The number of threads is decided, in the following order, by: + 1. The init method parameter `num_threads`, if it is set. + 2. The envvar "OMP_NUM_THREADS", if it is set. + 3. The default value DEFAULT_NUM_THREADS. + + The execution provided is decided, in the following order: + 1. If the init method parameter `cpu_only` is True or the envvar "USE_CPU_ONLY" is set, + it uses the "CPUExecutionProvider". + 3. Otherwise if the "CUDAExecutionProvider" is present, use: + ["CUDAExecutionProvider", "CPUExecutionProvider"]: + + Parameters + ---------- + artifact_path: Path for the model ONNX file. + num_threads: (Optional) Number of threads to run the inference. + use_cpu_only: (Optional) If True, it forces CPU as the execution provider. + + Raises + ------ + FileNotFoundError when the model's ONNX file is missing + """ + # Set basic params + self._threshold = 0.6 # Score threshold + self._image_size = 640 + self._size = np.asarray([[self._image_size, self._image_size]], dtype=np.int64) + + # Get env vars + self._use_cpu_only = use_cpu_only or ("USE_CPU_ONLY" in os.environ) + if num_threads is None: + num_threads = int(os.environ.get("OMP_NUM_THREADS", DEFAULT_NUM_THREADS)) + self._num_threads = num_threads + + # Decide the execution providers + if ( + not self._use_cpu_only + and "CUDAExecutionProvider" in ort.get_available_providers() + ): + providers = ["CUDAExecutionProvider", "CPUExecutionProvider"] + else: + providers = ["CPUExecutionProvider"] + self._providers = providers + + # Model ONNX file + self._onnx_fn = os.path.join(artifact_path, MODEL_CHECKPOINT_FN) + if not os.path.isfile(self._onnx_fn): + raise FileNotFoundError("Missing ONNX file: {}".format(self._onnx_fn)) + + # ONNX options + self._options = ort.SessionOptions() + self._options.intra_op_num_threads = self._num_threads + self.sess = ort.InferenceSession( + self._onnx_fn, + sess_options=self._options, + providers=self._providers, + ) + + def info(self) -> dict: + r""" + Get information about the configuration of LayoutPredictor + """ + info = { + "onnx_file": self._onnx_fn, + "intra_op_num_threads": self._num_threads, + "use_cpu_only": self._use_cpu_only, + "providers": self._providers, + "image_size": self._image_size, + "threshold": self._threshold, + } + return info + + def predict(self, orig_img: Union[Image, np.array]) -> Iterable[dict]: + r""" + Predict bounding boxes for a given image. + The origin (0, 0) is the top-left corner and the predicted bbox coords are provided as: + [left, top, right, bottom] + + Parameter + --------- + origin_img: Image to be predicted as a PIL Image object or numpy array. + + Yield + ----- + Bounding box as a dict with the keys: "label", "confidence", "l", "t", "r", "b" + + Raises + ------ + TypeError when the input image is not supported + """ + # Convert image format + if isinstance(orig_img, Image.Image): + page_img = orig_img.convert("RGB") + elif isinstance(orig_img, np.ndarray): + page_img = Image.fromarray(orig_img).convert("RGB") + else: + raise TypeError("Not supported input image format") + + w, h = page_img.size + page_img = page_img.resize((self._image_size, self._image_size)) + page_data = np.array(page_img, dtype=np.uint8) / np.float32(255.0) + page_data = np.expand_dims(np.transpose(page_data, axes=[2, 0, 1]), axis=0) + + # Predict + labels, boxes, scores = self.sess.run( + output_names=None, + input_feed={ + "images": page_data, + "orig_target_sizes": self._size, + }, + ) + + # Yield output + for label, box, score in zip(labels[0], boxes[0], scores[0]): + if score > self._threshold: + yield { + "l": box[0] / self._image_size * w, + "t": box[1] / self._image_size * h, + "r": box[2] / self._image_size * w, + "b": box[3] / self._image_size * h, + "label": CLASSES_MAP[label], + "confidence": score, + } diff --git a/docling_ibm_models/tableformer/__init__.py b/docling_ibm_models/tableformer/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/docling_ibm_models/tableformer/common.py b/docling_ibm_models/tableformer/common.py new file mode 100644 index 0000000..92c14ea --- /dev/null +++ b/docling_ibm_models/tableformer/common.py @@ -0,0 +1,200 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import argparse +import json +import logging +import os + +import torch + +import docling_ibm_models.tableformer.settings as s +from docling_ibm_models.tableformer.models.common.base_model import BaseModel + +LOG_LEVEL = logging.DEBUG +logger = s.get_custom_logger("common", LOG_LEVEL) + + +def validate_config(config): + r""" + Validate the provided configuration file. + A ValueError exception will be thrown in case the config file is invalid + + Parameters + ---------- + config : dictionary + Configuration for the tablemodel + + Returns + ------- + bool : True on success + """ + if "model" not in config: + return True + if "preparation" not in config: + return True + assert ( + "max_tag_len" in config["preparation"] + ), "Config error: 'preparation.max_tag_len' parameter is missing" + if "seq_len" in config["model"]: + assert ( + config["model"]["seq_len"] > 0 + ), "Config error: 'model.seq_len' should be positive" + assert config["model"]["seq_len"] <= ( + config["preparation"]["max_tag_len"] + 2 + ), "Config error: 'model.seq_len' should be up to 'preparation.max_tag_len' + 2" + + return True + + +def parse_arguments(): + r""" + Parse the input arguments + A ValueError exception will be thrown in case the config file is invalid + """ + parser = argparse.ArgumentParser(description="Train the TableModel") + parser.add_argument( + "-c", "--config", required=True, default=None, help="configuration file (JSON)" + ) + args = parser.parse_args() + config_filename = args.config + + assert os.path.isfile(config_filename), "FAILURE: Config file not found." + return read_config(config_filename) + + +def read_config(config_filename): + with open(config_filename, "r") as fd: + config = json.load(fd) + + # Validate the config file + validate_config(config) + + return config + + +def safe_get_parameter(input_dict, index_path, default=None, required=False): + r""" + Safe get parameter from a nested dictionary. + + Provide a nested dictionary (dictionary of dictionaries) and a list of indices: + - If the whole index path exists the value pointed by it is returned + - Otherwise the default value is returned. + + Input: + input_dict: Data structure of nested dictionaries. + index_path: List with the indices path to follow inside the input_dict. + default: Default value to return if the indices path is broken. + required: If true a ValueError exception will be raised in case the parameter does not exist + Output: + The value pointed by the index path or "default". + """ + if input_dict is None or index_path is None: + return default + + d = input_dict + for i in index_path[:-1]: + if i not in d: + if required: + raise ValueError("Missing parameter: {}".format(i)) + return default + d = d[i] + + last_index = index_path[-1] + if last_index not in d: + if required: + raise ValueError("Missing parameter: {}".format(last_index)) + return default + + return d[last_index] + + +def get_prepared_data_filename(prepared_data_part, dataset_name): + r""" + Build the full filename of the prepared data part + + Parameters + ---------- + prepared_data_part : string + Part of the prepared data + dataset_name : string + Name of the dataset + + Returns + ------- + string + The full filename for the prepared file + """ + template = s.PREPARED_DATA_PARTS[prepared_data_part] + if "" in template: + template = template.replace("", dataset_name) + return template + + +def create_dataset_and_model(config, purpose, fixed_padding=False): + r""" + Gets a model from configuration + + Parameters + --------- + config : Dictionary + The configuration of the model + purpose : string + One of "train", "eval", "predict" + fixed_padding : bool + Parameter passed to the constructor of the DataLoader + + Returns + ------- + In case a Model cannot be initialized return None, None, None. Otherwise: + + device : selected device + dataset : Instance of the DataLoader + model : Instance of the model + """ + from docling_ibm_models.tableformer.data_management.tf_dataset import TFDataset + + model_type = config["model"]["type"] + model = None + + # Get env vars: + use_cpu_only = os.environ.get("USE_CPU_ONLY", False) + use_cuda_only = not use_cpu_only + + # Use the cpu for the evaluation + device = "cpu" # Default, run on CPU + num_gpus = torch.cuda.device_count() # Check if GPU is available + if use_cuda_only: + device = "cuda:0" if num_gpus > 0 else "cpu" # Run on first available GPU + else: + device = "cpu" + + # Create the DataLoader + # loader = DataLoader(config, purpose, fixed_padding=fixed_padding) + dataset = TFDataset(config, purpose, fixed_padding=fixed_padding) + dataset.set_device(device) + dataset_val = None + if config["train"]["validation"] and purpose == "train": + dataset_val = TFDataset(config, "val", fixed_padding=fixed_padding) + dataset_val.set_device(device) + if model_type == "TableModel04_rs": + from docling_ibm_models.tableformer.models.table04_rs.tablemodel04_rs import ( # noqa: F401 + TableModel04_rs, + ) + # Find the model class and create an instance of it + for candidate in BaseModel.__subclasses__(): + if candidate.__name__ == model_type: + init_data = dataset.get_init_data() + model = candidate(config, init_data, purpose, device) + + if model is None: + logger.warn("Not found model: " + str(model_type)) + return None, None, None + + logger.info("Found model: " + str(model_type)) + + if purpose == s.PREDICT_PURPOSE: + return device, dataset, model + else: + return device, dataset, dataset_val, model diff --git a/docling_ibm_models/tableformer/data_management/__init__.py b/docling_ibm_models/tableformer/data_management/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/docling_ibm_models/tableformer/data_management/data_transformer.py b/docling_ibm_models/tableformer/data_management/data_transformer.py new file mode 100644 index 0000000..9f527cc --- /dev/null +++ b/docling_ibm_models/tableformer/data_management/data_transformer.py @@ -0,0 +1,504 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import copy +import logging +import os +import random + +import cv2 +import numpy as np +import torch +import torchvision.transforms as transforms +from PIL import Image, ImageDraw + +import docling_ibm_models.tableformer.data_management.transforms as T +import docling_ibm_models.tableformer.settings as s + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +class DataTransformer: + r""" + Data transformations for the images and bboxes + + Check the "help" fields inside the config file for an explanation of each parameter + """ + + def __init__(self, config): + self._config = config + + print("DataTransformer Init!") + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def append_id(self, filename): + name, ext = os.path.splitext(filename) + return "{name}_{uid}{ext}".format(name=name, uid="resized", ext=ext) + + def load_image(self, img_fn): + r""" + Load an image from the disk + + Parameters + ---------- + img_fn: The filename of the image + + Returns + ------- + PIL image object + """ + + img = Image.open(img_fn) + return img + + def load_image_cv2(self, img_fn): + r"""Load an image from the disk + + Parameters + ---------- + img_fn: The filename of the image + + Returns + ------- + CV2 image object + """ + img = cv2.imread(img_fn) + return img + + def save_image(self, img, img_fn): + img.save(self.append_id(img_fn)) + + def renderbboxes(self, img, bboxes): + draw_img = ImageDraw.Draw(img) + for i in range(len(bboxes)): + draw_img.rectangle(bboxes[i], fill=None, outline=(255, 0, 0)) + return img + + def get_dataset_settings(self): + dataset = {} + debug = {"save_debug_images": False} + + if "dataset" in self._config: + dataset = self._config["dataset"] + if "debug" in self._config: + debug = self._config["debug"] + + return dataset, debug + + def _prepare_image_from_file(self, image_fn, bboxes, convert_box=True): + r""" + Load the image from file and prepare it + + Parameters + ---------- + image_fn : string + Filename to load the image + bboxes : dict + Bounding boxes of the image + convert_box : bool + If true the bboxes are converted to xcycwh format + + Returns + ------- + PIL image + A PIL image object with the image prepared according to the settings in the config file + bboxes : dict + Converted bboxes of the image + """ + im = self.load_image(image_fn) + return self._prepare_image(im, bboxes, convert_box, image_fn) + + def _prepare_image(self, im, bboxes, convert_box=True, image_fn=None): + r""" + Parameters + ---------- + im : PIL image object + bboxes : dict + Bounding boxes of the image + convert_box : bool + If true the bboxes are converted to xcycwh format + image_fn : string + Filename of the original image or None. It is used to save augmented image for debugging + + Returns + ------- + PIL image + A PIL image object with the image prepared according to the settings in the config file + bboxes : dict + Converted bboxes of the image + """ + debug_settings = False + settings, debug_settings = self.get_dataset_settings() + + desired_size = settings["resized_image"] + old_size = im.size + + # Calculate Aspect Ratio if needed + if settings["keep_AR"]: + ratio = float(desired_size) / max(old_size) + else: + ratio = 1 # Square image + + new_size = old_size + if max(old_size) < desired_size: + # Image is smaller than desired + # Upscale? + if settings["up_scaling_enabled"]: + # Calculate new image size, taking into account aspect ratio + new_size = tuple([int(x * ratio) for x in old_size]) + else: + new_size = old_size + else: + if settings["keep_AR"]: + new_size = tuple([int(x * ratio) for x in old_size]) + else: + new_size = [desired_size, desired_size] + + if not settings["keep_AR"]: + if settings["up_scaling_enabled"]: + new_size = [desired_size, desired_size] + + ###################################################################################### + # Use OpenCV to resize the image + # + # im = im.resize(new_size, Image.ANTIALIAS) + + import cv2 + + np_im = np.array(im) + np_resized = cv2.resize(np_im, new_size, interpolation=cv2.INTER_LANCZOS4) + im = Image.fromarray(np_resized) + ###################################################################################### + + new_bboxes = copy.deepcopy(bboxes) + + # Resize bboxes (in pixels) + x_scale = new_size[0] / old_size[0] + y_scale = new_size[1] / old_size[1] + # loop over bboxes + for i in range(len(new_bboxes)): + new_bboxes[i][0] = x_scale * bboxes[i][0] + new_bboxes[i][1] = y_scale * bboxes[i][1] + new_bboxes[i][2] = x_scale * bboxes[i][2] + new_bboxes[i][3] = y_scale * bboxes[i][3] + + # Set background color for padding + br = settings["padding_color"][0] + bg = settings["padding_color"][1] + bb = settings["padding_color"][2] + bcolor = (br, bg, bb) + # Create empty canvas of background color and desired size + new_im = Image.new(mode="RGB", size=(desired_size, desired_size), color=bcolor) + + if "grayscale" in settings: + if settings["grayscale"]: + im = im.convert("LA") + + if settings["padding_mode"] == "frame": + # If paddinds are around image, paste resized image in the center + x_pad = (desired_size - new_size[0]) // 2 + y_pad = (desired_size - new_size[1]) // 2 + # Paste rescaled image + new_im.paste(im, (x_pad, y_pad)) + # Offset (pad) bboxes + # loop over bboxes + for i in range(len(new_bboxes)): + new_bboxes[i][0] += x_pad + new_bboxes[i][1] += y_pad + new_bboxes[i][2] += x_pad + new_bboxes[i][3] += y_pad + else: + # Otherwise paste in the 0,0 coordinates + new_im.paste(im, (0, 0)) + + if debug_settings: + if debug_settings["save_debug_images"]: + aug_im = self.renderbboxes(new_im, bboxes) + if "grayscale" in settings: + if settings["grayscale"]: + aug_im = aug_im.convert("LA") + self.save_image(aug_im, image_fn) + if convert_box: + bboxes = self.xyxy_to_xcycwh(new_bboxes, desired_size) + return new_im, bboxes + + # convert bboxes from [x1, y1, x2, y2] format to [xc, yc, w, h] format + def xyxy_to_xcycwh(self, bboxes, size): + # Use the "dataset.bbox_format" parameter to decide which bbox format to use + bbox_format = self._config["dataset"].get("bbox_format", "4plet") + + conv_bboxes = [] + for i in range(len(bboxes)): + x1 = bboxes[i][0] / size # X1 + y1 = bboxes[i][1] / size # Y1 + x2 = bboxes[i][2] / size # X2 + y2 = bboxes[i][3] / size # Y2 + xc = (x1 + x2) / 2 + yc = (y1 + y2) / 2 + bw = abs(x2 - x1) + bh = abs(y2 - y1) + + if bbox_format == "5plet": + cls = bboxes[i][4] + conv_bboxes.append([xc, yc, bw, bh, cls]) + else: + conv_bboxes.append([xc, yc, bw, bh]) + + # conv_bboxes = bboxes + return conv_bboxes + + def rescale_in_memory(self, image, normalization): + r""" + Receive image and escale it in memory + + Parameters + ---------- + image : PIL image + The image data to rescale + normalization : dictionary + The normalization information with the format: + "state": "true or false if image normalization is to be enabled", + "mean": "mean values to use if state is true", + "std": "std values to use if state is true" + Returns + ------- + npimgc : FloatTensor + The loaded and properly transformed image data + """ + settings, debug_settings = self.get_dataset_settings() + new_image, _ = self._prepare_image(image, {}, convert_box=False, image_fn=None) + # Convert to nparray + npimg = np.asarray(new_image) # (width, height, channels) + + # Convert to float? + npimgc = npimg.copy() + + # Transpose numpy array (image) + npimgc = npimgc.transpose(2, 0, 1) # (channels, width, height) + npimgc = torch.FloatTensor(npimgc / 255.0) + + if normalization: + transform = transforms.Compose( + [ + transforms.Normalize( + mean=self._config["dataset"]["image_normalization"]["mean"], + std=self._config["dataset"]["image_normalization"]["std"], + ) + ] + ) + npimgc = transform(npimgc) + + return npimgc + + def _rescale(self, image_fn, bboxes, normalization): + r""" + Rescale, resize, pad the given image and its associated bboxes according to the settings + from the config + + Parameters + ---------- + image_fn: full image file name + bboxes: List with bboxes in the format [x1, y1, x2, y2] with box's top-right, + bottom-left points + statistics: Dictionary with statistics over the whole image dataset. + The keys are: "mean", "variance", "std" and each value is a list with the + coresponding statistical value for each channel. Normally there are 3 + channels. + + Returns + ------- + npimgc : FloatTensor + The loaded and properly transformed image data + bboxes: List with bboxes in the format [xc, yc, w, h] where xc, yc are the coords of the + center, w, h the width and height of the bbox and all are normalized to the + scaled size of the image + + Raises + ------ + ValueError + In case the configuration and the image dimensions make it impossible to rescale the + image throw a ValueError exception + """ + settings, debug_settings = self.get_dataset_settings() + # new_image is a PIL object + new_image, new_bboxes = self._prepare_image_from_file(image_fn, bboxes) + # Convert to nparray + npimg = np.asarray(new_image) # (width, height, channels) + # Convert to float? + npimgc = npimg.copy() + # Transpose numpy array (image) + npimgc = npimgc.transpose(2, 0, 1) # (channels, width, height) + npimgc = torch.FloatTensor(npimgc / 255.0) + + if normalization: + transform = transforms.Compose( + [ + transforms.Normalize( + mean=self._config["dataset"]["image_normalization"]["mean"], + std=self._config["dataset"]["image_normalization"]["std"], + ) + ] + ) + npimgc = transform(npimgc) + return npimgc, new_bboxes + + def rescale_old(self, image, bboxes, statistics=None): + r""" + Rescale, resize, pad the given image and its associated bboxes according to the settings + from the config + + Input: + image: np array (channels, width, height) + bboxes: List with bboxes in the format [x1, y1, x2, y2] with box's top-right, + bottom-left points + statistics: Dictionary with statistics over the whole image dataset. + The keys are: "mean", "variance", "std" and each value is a list with the + coresponding statistical value for each channel. Normally there are 3 + channels. + + Output: + image: np array (channels, resized_image, resized_image) + bboxes: List with bboxes in the format (xc, yc, w, h) where xc, yc are the coords of the + center, w, h the width and height of the bbox and all are normalized to the + scaled size of the image + + Exceptions: + In case the configuration and the image dimensions make it impossible to rescale the + image throw a ValueError exception + """ + image_size = 448 + # Convert the image to (width, height, channels) + image = image.transpose(1, 2, 0) + + # Convert to PIL format and resize + image = Image.fromarray(image) + image = image.resize((image_size, image_size), Image.ANTIALIAS) + return image, bboxes + + def rescale_batch(self, images, bboxes, statistics=None): + r""" + Rescale, resize, pad the given batch of images and its associated bboxes according to the + settings from the config. + + Input: + images: np array (batch_size, channels, width, height) + bboxes: + statistics: Dictionary with statistics over the whole image dataset. + The keys are: "mean", "variance", "std" and each value is a list with the + coresponding statistical value for each channel. Normally there are 3 + channels. + + Output: + image batch: np array (batch_size, channels, resized_image, resized_image) + bboxes: + + Exceptions: + In case the configuration and the image dimensions make it impossible to rescale the + image throw a ValueError exception + """ + pass + + def sample_preprocessor(self, image_fn, bboxes, purpose, table_bboxes=None): + r""" + Rescale, resize, pad the given image and its associated bboxes according to the settings + from the config + + Parameters + ---------- + image_fn: full image file name + bboxes: List with bboxes in the format [x1, y1, x2, y2] with box's top-right, + bottom-left points + statistics: Dictionary with statistics over the whole image dataset. + The keys are: "mean", "variance", "std" and each value is a list with the + coresponding statistical value for each channel. Normally there are 3 + channels. + + Returns + ------- + npimgc : FloatTensor + The loaded and properly transformed image data + bboxes: List with bboxes in the format [xc, yc, w, h] where xc, yc are the coords of the + center, w, h the width and height of the bbox and all are normalized to the + scaled size of the image + + Raises + ------ + ValueError + In case the configuration and the image dimensions make it impossible to rescale the + image throw a ValueError exception + """ + settings, debug_settings = self.get_dataset_settings() + img = self.load_image_cv2(image_fn) + img = np.ascontiguousarray(img) + + target = { + "size": [img.shape[1], img.shape[2]], + "boxes": ( + torch.from_numpy(np.array(bboxes)[:, :4]) + if purpose != s.PREDICT_PURPOSE + else None + ), + "classes": ( + np.array(bboxes)[:, -1] if purpose != s.PREDICT_PURPOSE else None + ), + "area": img.shape[1] * img.shape[2], + } + + optional_transforms = [T.NoTransformation()] + + # Necessary preprocessing ends here, experimental options begin below. + # DETR format, might be necessary to keep this structure to share other functions used by + # the community + + if purpose == s.TRAIN_PURPOSE: + if self._config["dataset"]["color_jitter"]: + jitter = T.ColorJitter( + brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1 + ) + optional_transforms.append(jitter) + + if self._config["dataset"]["rand_pad"]: + pad_val = random.randint(0, 50) + rand_pad = T.RandomPad(pad_val) + optional_transforms.append(rand_pad) + + if table_bboxes is not None: + if self._config["dataset"]["rand_crop"]: + w_, h_, _ = img.shape[0], img.shape[1], img.shape[2] + w_c, h_c = table_bboxes[0], table_bboxes[1] + f_w, f_h = random.randint(0, w_c), random.randint(0, h_c) + rand_crop = T.RandomCrop((w_, h_), (f_w, f_h)) + optional_transforms.append(rand_crop) + + # transform_opt = random.choice(optional_transforms) + normalize = T.Normalize( + mean=self._config["dataset"]["image_normalization"]["mean"], + std=self._config["dataset"]["image_normalization"]["std"], + ) + resized_size = self._config["dataset"]["resized_image"] + resize = T.Resize([resized_size, resized_size]) + + transformations = T.RandomChoice(optional_transforms) + + img, target = transformations(img, target) + img, target = normalize(img, target) + img, target = resize(img, target) + + img = img.transpose(2, 1, 0) # (channels, width, height) + img = torch.FloatTensor(img / 255.0) + bboxes_ = target["boxes"] + classes_ = target["classes"] + desired_size = img.shape[1] + + if purpose != s.PREDICT_PURPOSE: + bboxes_ = np.concatenate( + (bboxes_, np.expand_dims(classes_, axis=1)), axis=1 + ) + bboxes_ = self.xyxy_to_xcycwh(bboxes_, desired_size) + + return img, bboxes_ diff --git a/docling_ibm_models/tableformer/data_management/functional.py b/docling_ibm_models/tableformer/data_management/functional.py new file mode 100644 index 0000000..0568cd9 --- /dev/null +++ b/docling_ibm_models/tableformer/data_management/functional.py @@ -0,0 +1,574 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import numbers +from collections.abc import Iterable, Sequence + +import cv2 +import numpy as np +import torch +from torchvision.transforms import functional + +cv2.setNumThreads(0) +cv2.ocl.setUseOpenCL(False) + +INTER_MODE = { + "NEAREST": cv2.INTER_NEAREST, + "BILINEAR": cv2.INTER_LINEAR, + "BICUBIC": cv2.INTER_CUBIC, +} + +PAD_MOD = { + "constant": cv2.BORDER_CONSTANT, + "edge": cv2.BORDER_REPLICATE, + "reflect": cv2.BORDER_DEFAULT, + "symmetric": cv2.BORDER_REFLECT, +} + + +def _is_tensor_image(img): + return torch.is_tensor(img) and img.ndimension() == 3 + + +def _is_numpy_image(img): + return isinstance(img, np.ndarray) and (img.ndim in {2, 3}) + + +def to_tensor(pic): + """Converts a numpy.ndarray (H x W x C) in the range + [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]. + Args: + pic (np.ndarray, torch.Tensor): Image to be converted to tensor, (H x W x C[RGB]). + Returns: + Tensor: Converted image. + """ + + if _is_numpy_image(pic): + if len(pic.shape) == 2: + pic = cv2.cvtColor(pic, cv2.COLOR_GRAY2RGB) + img = torch.from_numpy(pic.transpose((2, 0, 1))) + # backward compatibility + if isinstance(img, torch.ByteTensor) or img.max() > 1: + return img.float().div(255) + else: + return img + elif _is_tensor_image(pic): + return pic + + else: + try: + return to_tensor(np.array(pic)) + except Exception: + raise TypeError("pic should be ndarray. Got {}".format(type(pic))) + + +def to_cv_image(pic, mode=None): + """Convert a tensor to an ndarray. + Args: + pic (Tensor or numpy.ndarray): Image to be converted to PIL Image. + mode (str): color space and pixel depth of input data (optional) + for example: cv2.COLOR_RGB2BGR. + Returns: + np.array: Image converted to PIL Image. + """ + if not (_is_numpy_image(pic) or _is_tensor_image(pic)): + raise TypeError("pic should be Tensor or ndarray. Got {}.".format(type(pic))) + + npimg = pic + if isinstance(pic, torch.FloatTensor): + pic = pic.mul(255).byte() + if torch.is_tensor(pic): + npimg = np.squeeze(np.transpose(pic.numpy(), (1, 2, 0))) + + if not isinstance(npimg, np.ndarray): + raise TypeError("Input pic must be a torch.Tensor or NumPy ndarray") + if mode is None: + return npimg + + else: + return cv2.cvtColor(npimg, mode) + + +def normalize(tensor, mean, std): + """Normalize a tensor image with mean and standard deviation. + See ``Normalize`` for more details. + Args: + tensor (Tensor): Tensor image of size (C, H, W) to be normalized. + mean (sequence): Sequence of means for each channel. + std (sequence): Sequence of standard deviations for each channely. + Returns: + Tensor: Normalized Tensor image. + """ + if _is_tensor_image(tensor): + for t, m, s in zip(tensor, mean, std, strict=False): + t.sub_(m).div_(s) + return tensor + elif _is_numpy_image(tensor): + return (tensor.astype(np.float32) - 255.0 * np.array(mean)) / np.array(std) + else: + raise RuntimeError("Undefined type") + + +def resize(img, size, interpolation="BILINEAR"): + """Resize the input CV Image to the given size. + Args: + img (np.ndarray): Image to be resized. + size (tuple or int): Desired output size. If size is a sequence like + (h, w), the output size will be matched to this. If size is an int, + the smaller edge of the image will be matched to this number maintaing + the aspect ratio. i.e, if height > width, then image will be rescaled to + (size * height / width, size) + interpolation (str, optional): Desired interpolation. Default is ``BILINEAR`` + Returns: + cv Image: Resized image. + """ + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + if not (isinstance(size, int) or (isinstance(size, Iterable) and len(size) == 2)): + raise TypeError("Got inappropriate size arg: {}".format(size)) + + if isinstance(size, int): + h, w, c = img.shape + if (w <= h and w == size) or (h <= w and h == size): + return img + if w < h: + ow = size + oh = int(size * h / w) + return cv2.resize( + img, dsize=(ow, oh), interpolation=INTER_MODE[interpolation] + ) + else: + oh = size + ow = int(size * w / h) + return cv2.resize( + img, dsize=(ow, oh), interpolation=INTER_MODE[interpolation] + ) + else: + oh, ow = size + return cv2.resize( + img, dsize=(int(ow), int(oh)), interpolation=INTER_MODE[interpolation] + ) + + +def to_rgb_bgr(pic): + """Converts a color image stored in BGR sequence to RGB (BGR to RGB) + or stored in RGB sequence to BGR (RGB to BGR). + Args: + pic (np.ndarray, torch.Tensor): Image to be converted, (H x W x 3). + Returns: + Tensor: Converted image. + """ + + if _is_numpy_image(pic) or _is_tensor_image(pic): + img = pic[:, :, [2, 1, 0]] + return img + else: + try: + return to_rgb_bgr(np.array(pic)) + except Exception: + raise TypeError("pic should be numpy.ndarray or torch.Tensor.") + + +def pad(img, padding, fill=(0, 0, 0), padding_mode="constant"): + """Pad the given CV Image on all sides with speficified padding mode and fill value. + Args: + img (np.ndarray): Image to be padded. + padding (int or tuple): Padding on each border. If a single int is provided this + is used to pad all borders. If tuple of length 2 is provided this is the padding + on left/right and top/bottom respectively. If a tuple of length 4 is provided + this is the padding for the left, top, right and bottom borders + respectively. + fill (int, tuple): Pixel fill value for constant fill. Default is 0. If a tuple of + length 3, it is used to fill R, G, B channels respectively. + This value is only used when the padding_mode is constant + padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. + Default is constant. + constant: pads with a constant value, this value is specified with fill + edge: pads with the last value on the edge of the image + reflect: pads with reflection of image (without repeating the last value on the edge) + padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode + will result in [3, 2, 1, 2, 3, 4, 3, 2] + symmetric: pads with reflection of image (repeating the last value on the edge) + padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode + will result in [2, 1, 1, 2, 3, 4, 4, 3] + Returns: + CV Image: Padded image. + """ + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + + if not isinstance(padding, (numbers.Number, tuple)): + raise TypeError("Got inappropriate padding arg") + if not isinstance(fill, (numbers.Number, str, tuple)): + raise TypeError("Got inappropriate fill arg") + if not isinstance(padding_mode, str): + raise TypeError("Got inappropriate padding_mode arg") + + if isinstance(padding, Sequence) and len(padding) not in [2, 4]: + raise ValueError("Padding must be an int or a 2, or 4 element tuple") + + assert padding_mode in [ + "constant", + "edge", + "reflect", + "symmetric", + ], "Padding mode should be either constant, edge, reflect or symmetric" + + if isinstance(padding, int): + pad_left = pad_right = pad_top = pad_bottom = padding + if isinstance(padding, Sequence) and len(padding) == 2: + pad_left = pad_right = padding[0] + pad_top = pad_bottom = padding[1] + if isinstance(padding, Sequence) and len(padding) == 4: + pad_left, pad_top, pad_right, pad_bottom = padding + + if isinstance(fill, numbers.Number): + fill = (fill,) * (2 * len(img.shape) - 3) + + if padding_mode == "constant": + assert (len(fill) == 3 and len(img.shape) == 3) or ( + len(fill) == 1 and len(img.shape) == 2 + ), "channel of image is {} but length of fill is {}".format( + img.shape[-1], len(fill) + ) + + img = cv2.copyMakeBorder( + src=img, + top=pad_top, + bottom=pad_bottom, + left=pad_left, + right=pad_right, + borderType=PAD_MOD[padding_mode], + value=fill, + ) + return img + + +def crop(img, x, y, h, w): + """Crop the given CV Image. + Args: + img (np.ndarray): Image to be cropped. + x: Upper pixel coordinate. + y: Left pixel coordinate. + h: Height of the cropped image. + w: Width of the cropped image. + Returns: + CV Image: Cropped image. + """ + assert _is_numpy_image(img), "img should be CV Image. Got {}".format(type(img)) + assert h > 0 and w > 0, "h={} and w={} should greater than 0".format(h, w) + + x1, y1, x2, y2 = round(x), round(y), round(x + h), round(y + w) + + # try: + # check_point1 = img[x1, y1, ...] + # check_point2 = img[x2-1, y2-1, ...] + # except IndexError: + # img = cv2.copyMakeBorder(img, - min(0, x1), max(x2 - img.shape[0], 0), + # -min(0, y1), max(y2 - img.shape[1], 0), + # cv2.BORDER_CONSTANT, value=[0, 0, 0]) + # y2 += -min(0, y1) + # y1 += -min(0, y1) + # x2 += -min(0, x1) + # x1 += -min(0, x1) + # + # finally: + # return img[x1:x2, y1:y2, ...].copy() + return img[x1:x2, y1:y2, ...].copy() + + +def center_crop(img, output_size): + if isinstance(output_size, numbers.Number): + output_size = (int(output_size), int(output_size)) + h, w, _ = img.shape + th, tw = output_size + i = int(round((h - th) * 0.5)) + j = int(round((w - tw) * 0.5)) + return crop(img, i, j, th, tw) + + +def resized_crop(img, i, j, h, w, size, interpolation="BILINEAR"): + """Crop the given CV Image and resize it to desired size. Notably used in RandomResizedCrop. + Args: + img (np.ndarray): Image to be cropped. + i: Upper pixel coordinate. + j: Left pixel coordinate. + h: Height of the cropped image. + w: Width of the cropped image. + size (sequence or int): Desired output size. Same semantics as ``scale``. + interpolation (str, optional): Desired interpolation. Default is + ``BILINEAR``. + Returns: + np.ndarray: Cropped image. + """ + assert _is_numpy_image(img), "img should be CV Image" + img = crop(img, i, j, h, w) + img = resize(img, size, interpolation) + return img + + +def hflip(img): + """Horizontally flip the given PIL Image. + Args: + img (np.ndarray): Image to be flipped. + Returns: + np.ndarray: Horizontall flipped image. + """ + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + + return cv2.flip(img, 1) + + +def vflip(img): + """Vertically flip the given PIL Image. + Args: + img (CV Image): Image to be flipped. + Returns: + PIL Image: Vertically flipped image. + """ + if not _is_numpy_image(img): + raise TypeError("img should be PIL Image. Got {}".format(type(img))) + + return cv2.flip(img, 0) + + +def five_crop(img, size): + """Crop the given CV Image into four corners and the central crop. + .. Note:: + This transform returns a tuple of images and there may be a + mismatch in the number of inputs and targets your ``Dataset`` returns. + Args: + size (sequence or int): Desired output size of the crop. If size is an + int instead of sequence like (h, w), a square crop (size, size) is + made. + Returns: + tuple: tuple (tl, tr, bl, br, center) corresponding top left, + top right, bottom left, bottom right and center crop. + """ + if isinstance(size, numbers.Number): + size = (int(size), int(size)) + else: + assert len(size) == 2, "Please provide only two dimensions (h, w) for size." + + h, w, _ = img.shape + crop_h, crop_w = size + if crop_w > w or crop_h > h: + raise ValueError( + "Requested crop size {} is bigger than input size {}".format(size, (h, w)) + ) + tl = crop(img, 0, 0, crop_h, crop_w) + tr = crop(img, 0, w - crop_w, crop_h, crop_w) + bl = crop(img, h - crop_h, 0, crop_h, crop_w) + br = crop(img, h - crop_h, w - crop_w, crop_h, crop_w) + center = center_crop(img, (crop_h, crop_w)) + return (tl, tr, bl, br, center) + + +def ten_crop(img, size, vertical_flip=False): + """Crop the given CV Image into four corners and the central crop plus the + flipped version of these (horizontal flipping is used by default). + .. Note:: + This transform returns a tuple of images and there may be a + mismatch in the number of inputs and targets your ``Dataset`` returns. + Args: + size (sequence or int): Desired output size of the crop. If size is an + int instead of sequence like (h, w), a square crop (size, size) is + made. + vertical_flip (bool): Use vertical flipping instead of horizontal + Returns: + tuple: tuple (tl, tr, bl, br, center, tl_flip, tr_flip, bl_flip, + br_flip, center_flip) corresponding top left, top right, + bottom left, bottom right and center crop and same for the + flipped image. + """ + if isinstance(size, numbers.Number): + size = (int(size), int(size)) + else: + assert len(size) == 2, "Please provide only two dimensions (h, w) for size." + + first_five = five_crop(img, size) + + if vertical_flip: + img = vflip(img) + else: + img = hflip(img) + + second_five = five_crop(img, size) + return first_five + second_five + + +def adjust_brightness(img, brightness_factor): + """Adjust brightness of an Image. + Args: + img (np.ndarray): CV Image to be adjusted. + brightness_factor (float): How much to adjust the brightness. Can be + any non negative number. 0 gives a black image, 1 gives the + original image while 2 increases the brightness by a factor of 2. + Returns: + np.ndarray: Brightness adjusted image. + """ + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + + im = img.astype(np.float32) * brightness_factor + im = im.clip(min=0, max=255) + return im.astype(img.dtype) + + +def adjust_contrast(img, contrast_factor): + """Adjust contrast of an Image. + Args: + img (np.ndarray): CV Image to be adjusted. + contrast_factor (float): How much to adjust the contrast. Can be any + non negative number. 0 gives a solid gray image, 1 gives the + original image while 2 increases the contrast by a factor of 2. + Returns: + np.ndarray: Contrast adjusted image. + """ + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + im = img.astype(np.float32) + mean = round(cv2.cvtColor(im, cv2.COLOR_RGB2GRAY).mean()) + im = (1 - contrast_factor) * mean + contrast_factor * im + im = im.clip(min=0, max=255) + return im.astype(img.dtype) + + +def adjust_saturation(img, saturation_factor): + """Adjust color saturation of an image. + Args: + img (np.ndarray): CV Image to be adjusted. + saturation_factor (float): How much to adjust the saturation. 0 will + give a gray image, 1 will give the original image while + 2 will enhance the saturation by a factor of 2. + Returns: + np.ndarray: Saturation adjusted image. + """ + if not _is_numpy_image(img): + raise TypeError("img should be PIL Image. Got {}".format(type(img))) + + im = img.astype(np.float32) + degenerate = cv2.cvtColor(cv2.cvtColor(im, cv2.COLOR_RGB2GRAY), cv2.COLOR_GRAY2RGB) + im = (1 - saturation_factor) * degenerate + saturation_factor * im + im = im.clip(min=0, max=255) + return im.astype(img.dtype) + + +def adjust_hue(img, hue_factor): + """Adjust hue of an image. + The image hue is adjusted by converting the image to HSV and + cyclically shifting the intensities in the hue channel (H). + The image is then converted back to original image mode. + `hue_factor` is the amount of shift in H channel and must be in the + interval `[-0.5, 0.5]`. + See https://en.wikipedia.org/wiki/Hue for more details on Hue. + Args: + img (np.ndarray): CV Image to be adjusted. + hue_factor (float): How much to shift the hue channel. Should be in + [-0.5, 0.5]. 0.5 and -0.5 give complete reversal of hue channel in + HSV space in positive and negative direction respectively. + 0 means no shift. Therefore, both -0.5 and 0.5 will give an image + with complementary colors while 0 gives the original image. + Returns: + np.ndarray: Hue adjusted image. + """ + if not (-0.5 <= hue_factor <= 0.5): + raise ValueError("hue_factor is not in [-0.5, 0.5].") + + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + + im = img.astype(np.uint8) + hsv = cv2.cvtColor(im, cv2.COLOR_RGB2HSV_FULL) + hsv[..., 0] += np.uint8(hue_factor * 255) + + im = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB_FULL) + return im.astype(img.dtype) + + +def adjust_gamma(img, gamma, gain=1): + """Perform gamma correction on an image. + Also known as Power Law Transform. Intensities in RGB mode are adjusted + based on the following equation: + I_out = 255 * gain * ((I_in / 255) ** gamma) + See https://en.wikipedia.org/wiki/Gamma_correction for more details. + Args: + img (np.ndarray): CV Image to be adjusted. + gamma (float): Non negative real number. gamma larger than 1 make the + shadows darker, while gamma smaller than 1 make dark regions + lighter. + gain (float): The constant multiplier. + """ + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + + if gamma < 0: + raise ValueError("Gamma should be a non-negative real number") + + im = img.astype(np.float32) + im = 255.0 * gain * np.power(im / 255.0, gamma) + im = im.clip(min=0.0, max=255.0) + return im.astype(img.dtype) + + +def to_grayscale(img, num_output_channels=1): + """Convert image to grayscale version of image. + Args: + img (np.ndarray): Image to be converted to grayscale. + Returns: + CV Image: Grayscale version of the image. + if num_output_channels == 1 : returned image is single channel + if num_output_channels == 3 : returned image is 3 channel with r == g == b + """ + if not _is_numpy_image(img): + raise TypeError("img should be CV Image. Got {}".format(type(img))) + + if num_output_channels == 1: + img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) + elif num_output_channels == 3: + img = cv2.cvtColor(cv2.cvtColor(img, cv2.COLOR_RGB2GRAY), cv2.COLOR_GRAY2RGB) + else: + raise ValueError("num_output_channels should be either 1 or 3") + + return img + + +def gaussian_noise(img: np.ndarray, mean, std): + imgtype = img.dtype + gauss = np.random.normal(mean, std, img.shape).astype(np.float32) + noisy = np.clip((1 + gauss) * img.astype(np.float32), 0, 255) + return noisy.astype(imgtype) + + +def poisson_noise(img): + imgtype = img.dtype + img = img.astype(np.float32) / 255.0 + vals = len(np.unique(img)) + vals = 2 ** np.ceil(np.log2(vals)) + noisy = 255 * np.clip( + np.random.poisson(img.astype(np.float32) * vals) / float(vals), 0, 1 + ) + return noisy.astype(imgtype) + + +def salt_and_pepper(img, prob=0.01): + """Adds "Salt & Pepper" noise to an image. + prob: probability (threshold) that controls level of noise + """ + imgtype = img.dtype + rnd = np.random.rand(img.shape[0], img.shape[1]) + noisy = img.copy() + noisy[rnd < prob / 2] = 0.0 + noisy[rnd > 1 - prob / 2] = 255.0 + return noisy.astype(imgtype) + + +def cv_transform(img): + img = salt_and_pepper(img) + return to_tensor(img) + + +def pil_transform(img): + return functional.to_tensor(img) diff --git a/docling_ibm_models/tableformer/data_management/matching_post_processor.py b/docling_ibm_models/tableformer/data_management/matching_post_processor.py new file mode 100644 index 0000000..8e896ec --- /dev/null +++ b/docling_ibm_models/tableformer/data_management/matching_post_processor.py @@ -0,0 +1,1325 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import json +import logging +import statistics + +import docling_ibm_models.tableformer.settings as s +from docling_ibm_models.tableformer.data_management.tf_cell_matcher import CellMatcher + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +class MatchingPostProcessor: + r""" + The MatchingPostProcessor aims to improve the matchings between the predicted table cells and + the pdf cells + """ + + def __init__(self, config): + self._config = config + self._cell_matcher = CellMatcher(config) + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def _get_table_dimension(self, table_cells): + r""" + Get dimensions (columns, rows) of a table from table_cells + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + + Returns + ------- + columns : integer, + rows : integer, + max_cell_id : integer, + highest cell_id in table_cells + """ + columns = 1 + rows = 1 + max_cell_id = 0 + + for cell in table_cells: + if cell["column_id"] > columns: + columns = cell["column_id"] + if cell["row_id"] > rows: + rows = cell["row_id"] + if cell["cell_id"] > max_cell_id: + max_cell_id = cell["cell_id"] + + return columns + 1, rows + 1, max_cell_id + + def _get_good_bad_cells_in_column(self, table_cells, column, matches): + r""" + 1. step + Get good/bad IOU predicted cells for each structural column (of minimal grid) + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + column : integer + Index of a column + matches : dictionary of lists of table_cells + A dictionary which is indexed by the pdf_cell_id as key and the value is a list + of the table_cells that fall inside that pdf cell + + Returns + ------- + good_table_cells : list of dict + cells in a column that have match + bad_table_cells : list of dict + cells in a column that don't have match + """ + good_table_cells = [] + bad_table_cells = [] + + for cell in table_cells: + if cell["column_id"] == column: + table_cell_id = cell["cell_id"] + + bad_match = True + allow_class = True + + for pdf_cell_id in matches: + # CHECK IF CELL CLASS TO BE VERIFIED HERE + if "cell_class" in cell: + if cell["cell_class"] <= 1: + allow_class = False + else: + print("***") + print("no cell_class in...") + print(cell) + print("***") + if allow_class: + match_list = matches[pdf_cell_id] + for match in match_list: + if match["table_cell_id"] == table_cell_id: + good_table_cells.append(cell) + bad_match = False + if bad_match: + bad_table_cells.append(cell) + + return good_table_cells, bad_table_cells + + def _delete_column_from_table(self, table_cells, column): + r""" + 1.a. step + If all IOU in a column are bad - eliminate column (from bboxes and structure) + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + column : integer + Index of a column + + Returns + ------- + new_table_cells : list of dict + """ + new_table_cells = [] + + for cell in table_cells: + if cell["column_id"] < column: + new_table_cells.append(cell) + if cell["column_id"] > column: + new_cell = { + "bbox": cell["bbox"], + "cell_id": cell["cell_id"], + "column_id": cell["column_id"] - 1, + "label": cell["label"], + "row_id": cell["row_id"], + "cell_class": cell["cell_class"], + } + new_table_cells.append(new_cell) + + return new_table_cells + + def _find_alignment_in_column(self, cells): + r""" + 2. step + Find alignment of good IOU cells per column + + Parameters + ---------- + cells : list of dict + Cells in a column + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + + Returns + ------- + alignment : string + column general alignment can be: "left", "right", "center" + """ + possible_alignments = ["left", "middle", "right"] + alignment = "left" # left / right / center + + lefts = [] + rights = [] + middles = [] + + for cell in cells: + x_left = cell["bbox"][0] + x_right = cell["bbox"][2] + x_middle = (x_left + x_right) / 2 + lefts.append(x_left) + rights.append(x_right) + middles.append(x_middle) + + if len(lefts) > 0: + delta_left = max(lefts) - min(lefts) + delta_middle = max(middles) - min(middles) + delta_right = max(rights) - min(rights) + + deltas = [delta_left, delta_middle, delta_right] + align_index = deltas.index(min(deltas)) + alignment = possible_alignments[align_index] + + return alignment + + def _get_median_pos_size(self, cells, alignment): + r""" + 3. step + Get median* (according to alignment) "bbox left/middle/right X" coord + for good IOU cells, get median* cell size in a column. + + Parameters + ---------- + cells : list of dict + Cells in a column + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + alignment : string + column general alignment can be: "left", "right", "center" + + Returns + ------- + median_x : number + Median X position of a cell (according to alignment) + median_y : number + Median Y position of a cell (according to alignment) + median_width : number + Median width of a cell + median_height : number + Median height of a cell + """ + median_x = 0 + median_y = 0 + median_width = 1 + median_height = 1 + + coords_x = [] + coords_y = [] + widths = [] + heights = [] + + for cell in cells: + if "rowspan_val" not in cell: + if "colspan_val" not in cell: + if cell["cell_class"] > 1: + # Use left alignment + x_coord = cell["bbox"][0] + if alignment == "middle": + # Use middle alignment + x_coord = (cell["bbox"][2] + cell["bbox"][0]) / 2 + if alignment == "right": + # Use right alignment + x_coord = cell["bbox"][2] + + coords_x.append(x_coord) + y_coord = cell["bbox"][1] + coords_y.append(y_coord) + + width = cell["bbox"][2] - cell["bbox"][0] + widths.append(width) + height = cell["bbox"][3] - cell["bbox"][1] + heights.append(height) + else: + self._log().debug("Empty cells not considered in medians") + self._log().debug(cell) + else: + self._log().debug("Colspans not considered in medians") + self._log().debug(cell) + else: + self._log().debug("Rowspans not considered in medians") + self._log().debug(cell) + + if len(coords_x) > 0: + median_x = statistics.median(coords_x) + if len(coords_y) > 0: + median_y = statistics.median(coords_y) + if len(widths) > 0: + median_width = statistics.median(widths) + if len(heights) > 0: + median_height = statistics.median(heights) + return median_x, median_y, median_width, median_height + + def _move_cells_to_left_pos( + self, cells, median_x, rescale, median_width, median_height, alignment + ): + r""" + 4. step + Move bad cells to the median* (left/middle/right) good in a column + (Additionally), re-size cell to median* size of cells in a column + + Parameters + ---------- + cells : list of dict + Cells in a column + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + median_x : number + Median X position of a cell (according to alignment) + rescale : boolean + should cells be re-sized to median or not + median_width : number + Median width of a cell + median_height : number + Median height of a cell + alignment : string + column general alignment can be: "left", "right", "center" + + Returns + ------- + + new_table_cells : list of dict + Cells in a column + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + """ + new_table_cells = [] + + for cell in cells: + new_cell = { + "bbox": [], + "cell_id": 0, + "column_id": 0, + "label": "", + "row_id": 0, + "cell_class": 0, + } + x1 = cell["bbox"][0] + y1 = cell["bbox"][1] + x2 = cell["bbox"][2] + y2 = cell["bbox"][3] + original_width = x2 - x1 + # original_height = y2 - y1 + + # Move to left by default + new_x1 = median_x + new_y1 = y1 + new_x2 = median_x + original_width + new_y2 = y2 + + if rescale: + new_x2 = median_x + median_width + # Next line does vertical resizing of BBOX: + new_y2 = y1 + median_height + + # Move to middle + if alignment == "middle": + # TODO + new_x1 = median_x - (original_width / 2) + new_x2 = new_x1 + original_width + if rescale: + new_x1 = median_x - (median_width / 2) + new_x2 = median_x + (median_width / 2) + + # Move to right + if alignment == "right": + new_x1 = median_x - original_width + new_x2 = median_x + if rescale: + new_x1 = median_x - median_width + + new_cell["bbox"] = [new_x1, new_y1, new_x2, new_y2] + new_cell["cell_id"] = cell["cell_id"] + new_cell["column_id"] = cell["column_id"] + new_cell["label"] = cell["label"] + new_cell["row_id"] = cell["row_id"] + new_cell["cell_class"] = cell["cell_class"] + # Add spans if present + if "rowspan_val" in cell: + new_cell["rowspan_val"] = cell["rowspan_val"] + if "colspan_val" in cell: + new_cell["colspan_val"] = cell["colspan_val"] + new_table_cells.append(new_cell) + return new_table_cells + + def _run_intersection_match(self, cell_matcher, table_cells, pdf_cells): + r""" + 5. step + Generate new matches, run Intersection over cell(pdf) on a table cells + + Parameters + ---------- + cell_matcher : CellMatcher + src.data_management.cell_matcher + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + pdf_cells : list of dict + List of PDF cells as defined by Docling + + Returns + ------- + clean_matches : dictionary of lists of table_cells + A dictionary which is indexed by the pdf_cell_id as key and the value is a list + of the table_cells that fall inside that pdf cell + """ + new_matches = {} + clean_matches = {} + new_matches, matches_counter = cell_matcher._intersection_over_pdf_match( + table_cells, pdf_cells + ) + clean_matches = new_matches + # Convert to JSON and back to have string keys in the dictionary + clean_matches_string = json.dumps(clean_matches) + clean_matches = json.loads(clean_matches_string) + return clean_matches + + def _align_table_cells_to_pdf(self, table_cells, pdf_cells, matches): + r""" + USED in 8.a step + NOT USED in 6. step + + Align table cell bboxes with good matches + to encapsulate matching pdf cells + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + pdf_cells : list of dict + List of PDF cells as defined by Docling + matches : dictionary of lists of table_cells + A dictionary which is indexed by the pdf_cell_id as key and the value is a list + of the table_cells that fall inside that pdf cell + + Returns + ------- + clean_table_cells : list of dict + Aligned and cleaned table cells + """ + # 6 + # align table cells with matching pdf cells + new_table_cells = [] + + for pdf_cell_id in matches: + match_list = matches[pdf_cell_id] + one_table_cells = [] + for i in range(len(match_list)): + otc = int(match_list[i]["table_cell_id"]) + if otc not in one_table_cells: + one_table_cells.append(otc) + + # Get bbox of pdf_cell: + pdf_cell_bbox = [] + for pdf_cell in pdf_cells: + if pdf_cell["id"] == int(pdf_cell_id): + pdf_cell_bbox = pdf_cell["bbox"] + + # Get bbox of pdf_cell: + for table_cell in table_cells: + if table_cell["cell_id"] in one_table_cells: + # Align bbox vertically to cover PDF cell + new_bbox = [ + pdf_cell_bbox[0], + pdf_cell_bbox[1], + pdf_cell_bbox[2], + pdf_cell_bbox[3], + ] + # We are sure cell is not empty, + # because we assign PDF cell to it + new_table_cell_class = "2" + + if "cell_class" in table_cell: + new_table_cell_class = table_cell["cell_class"] + + new_table_cell = { + "bbox": new_bbox, + "cell_id": table_cell["cell_id"], + "column_id": table_cell["column_id"], + "label": table_cell["label"], + "row_id": table_cell["row_id"], + "cell_class": new_table_cell_class, + } + + if "colspan_val" in table_cell: + new_table_cell["colspan_val"] = table_cell["colspan_val"] + if "rowspan_val" in table_cell: + new_table_cell["rowspan_val"] = table_cell["rowspan_val"] + new_table_cells.append(new_table_cell) + + # Rebuild table_cells list deduplicating repeating cells, + # encapsulating all duplicate cells dimensions + + for new_table_cell in new_table_cells: + cell_id_to_find = new_table_cell["cell_id"] + + x1s = [] + y1s = [] + x2s = [] + y2s = [] + + found = 0 + + for found_cell in new_table_cells: + if found_cell["cell_id"] == cell_id_to_find: + found += 1 + x1s.append(found_cell["bbox"][0]) + y1s.append(found_cell["bbox"][1]) + x2s.append(found_cell["bbox"][2]) + y2s.append(found_cell["bbox"][3]) + + min_x1 = min(x1s) + min_y1 = min(y1s) + max_x2 = max(x2s) + max_y2 = max(y2s) + + if found > 1: + new_table_cell["bbox"] = [min_x1, min_y1, max_x2, max_y2] + + clean_table_cells = [ + i + for n, i in enumerate(new_table_cells) + if i not in new_table_cells[n + 1 :] + ] + return clean_table_cells + + def _deduplicate_cells(self, tab_columns, table_cells, iou_matches, ioc_matches): + r""" + 7. step + + De-duplicate columns in table_cells according to highest column score + in: matches + intersection_pdf_matches + + Parameters + ---------- + tab_columns : integer + Number of table columns + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + iou_matches : dictionary of lists of table_cells + Cell matches done using Intersection Over Union (IOU) method + ioc_matches : dictionary of lists of table_cells + Cell matches done using Intersection Over (PDF) Cell method + + Returns + ------- + new_table_cells : list of dict + New table cells with removed column duplicates + new_matches : dictionary of lists of table_cells + Matches that are in sync with new_table_cells + new_tab_columns : integer + New number of table columns + """ + pdf_cells_in_columns = [] + total_score_in_columns = [] + + for col in range(tab_columns): + column_table_cells = [] + column_pdf_cells_iou = [] + column_pdf_cells_ioc = [] + column_pdf_cells = [] + column_iou_score = 0 + column_ioc_score = 0 + + for cell in table_cells: + if cell["column_id"] == col: + table_cell_id = cell["cell_id"] + column_table_cells.append(table_cell_id) + + # SUM IOU + IOC Scores for column, collect all pdf_cell_id + for iou_key in iou_matches: + iou_match_list = iou_matches[iou_key] + for uk in range(len(iou_match_list)): + t_cell_id = iou_match_list[uk]["table_cell_id"] + if t_cell_id in column_table_cells: + if "iou" in iou_match_list[uk]: + # In case initial match was IOU + column_iou_score += iou_match_list[uk]["iou"] + elif "iopdf" in iou_match_list[uk]: + # Otherwise it's intersection over PDF match + column_iou_score += iou_match_list[uk]["iopdf"] + column_pdf_cells_iou.append(iou_key) + + for ioc_key in ioc_matches: + ioc_match_list = ioc_matches[ioc_key] + for k in range(len(ioc_match_list)): + t_cell_id = ioc_match_list[k]["table_cell_id"] + if t_cell_id in column_table_cells: + column_ioc_score += ioc_match_list[k]["iopdf"] + column_pdf_cells_ioc.append(ioc_key) + + column_pdf_cells = column_pdf_cells_iou + column_pdf_cells += list( + set(column_pdf_cells_ioc) - set(column_pdf_cells_iou) + ) + column_total_score = column_iou_score + column_ioc_score + + pdf_cells_in_columns.append(column_pdf_cells) + total_score_in_columns.append(column_total_score) + self._log().debug( + "Column: {}, Score:{}, PDF cells: {}".format( + col, column_total_score, column_pdf_cells + ) + ) + + # Eliminate duplicates in the pdf_cells_in_columns and ensure int content + # pdf_cells_in_columns: + # - initially: list of lists of str with duplicates in the inner lists + # - afterwards: list of lists of int (unique) + pdf_cells_in_columns = [ + list(set([x for x in map(lambda x: int(x), le)])) + for le in pdf_cells_in_columns + ] + cols_to_eliminate = [] + # Pairwise comparison of all columns, finding intersection, and it's length + for cl in range(tab_columns - 1): + col_a = pdf_cells_in_columns[cl] + col_b = pdf_cells_in_columns[cl + 1] + score_a = total_score_in_columns[cl] + score_b = total_score_in_columns[cl + 1] + intsct = list(set(col_a).intersection(col_b)) + int_prc = 0 + if len(col_a) > 0: + int_prc = len(intsct) / len(col_a) + logstring = "Col A: {}, Col B: {}, Int: {}, %: {}, Score A: {}, Score B: {}" + self._log().debug( + logstring.format(cl, cl + 1, len(intsct), int_prc, score_a, score_b) + ) + + # Consider structural column elimination + # if 60% of two columns pointing to the same pdf cells + if int_prc > 0.6: + if score_a >= score_b: + # Elliminate B + cols_to_eliminate.append(cl + 1) + if score_b > score_a: + # Elliminate A + cols_to_eliminate.append(cl) + + self._log().debug("Columns to eliminate: {}".format(cols_to_eliminate)) + new_table_cells = [] + new_matches = {} + + removed_table_cell_ids = [] + new_tab_columns = tab_columns - len(cols_to_eliminate) + + # Clean table_cells structure + for tab_cell in table_cells: + add_cell = True + for col_del in cols_to_eliminate: + if tab_cell["column_id"] == col_del: + removed_table_cell_ids.append(tab_cell["cell_id"]) + add_cell = False + if add_cell: + new_table_cells.append(tab_cell) + # Clean ioc_matches structure + for pdf_cell_id, pdf_cell_matches in ioc_matches.items(): + new_cell_match = [] + for pdf_match in pdf_cell_matches: + if pdf_match["table_cell_id"] not in removed_table_cell_ids: + new_cell_match.append(pdf_match) + + if len(new_cell_match) > 0: + new_matches[pdf_cell_id] = new_cell_match + + return new_table_cells, new_matches, new_tab_columns + + def _do_final_asignment(self, table_cells, iou_matches, ioc_matches): + r""" + 8. step + + Do final assignment of table bbox to pdf cell based on saved scores, + either preferring IOU over PDF Intersection, and higher Intersection over lower, + or just use PDF Intersection + Rule: 1 Table cell can contain many PDF cells, + but each PDF cell has to be asigned to one Table cell + Rule: Do not discard table bboxes at this point, asign all of them + + Iterate over matches, if PDF cell has more than 1 table cell match: + Go over all other matches and delete tab_cell match of lower score + (prefer iou match over ioc match) + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + iou_matches : dictionary of lists of table_cells + Cell matches done using Intersection Over Union (IOU) method + ioc_matches : dictionary of lists of table_cells + Cell matches done using Intersection Over (PDF) Cell method + + Returns + ------- + new_matches : dictionary of lists of table_cells + New matches with final table cell asignments + """ + new_matches = {} + + for pdf_cell_id, pdf_cell_matches in ioc_matches.items(): + max_ioc_match = max(pdf_cell_matches, key=lambda x: x["iopdf"]) + new_matches[pdf_cell_id] = [max_ioc_match] + + return new_matches + + def _merge_two_bboxes(self, bbox1, bbox2): + r""" + Merge two bboxes into one bboxes that encompasses the two + + Parameters + ---------- + bbox1 : list of numbers + bbox to be merged described as two corners [x1, y1, x2, y2] + bbox1 : list of numbers + bbox to be merged described as two corners [x1, y1, x2, y2] + + Returns + ------- + bbox_result : list of numbers + bbox that encompasses two input bboxes + """ + bbox_result = [-1, -1, -1, -1] + bbox_result[0] = min([bbox1[0], bbox2[0]]) + bbox_result[1] = min([bbox1[1], bbox2[1]]) + bbox_result[2] = max([bbox1[2], bbox2[2]]) + bbox_result[3] = max([bbox1[3], bbox2[3]]) + return bbox_result + + def _pick_orphan_cells( + self, tab_rows, tab_cols, max_cell_id, table_cells, pdf_cells, matches + ): + # 9. + # new_matches, new_table_cells, max_cell_id + r""" + 9. step + + Pick up remaining orphan cells (pdf cells that don't have any matches or intersections) + 9.a. Determine row banding per row (min/max Y per row) + match with orphan cells (intersection with band) + 9.b. Determine column banding per column (min/max X per column) + match with orphan cells (intersection with band) + 9.c. Decide to which column/row each orphan PDF cell belongs + append match to existing structural cell, or create cell + + Parameters + ---------- + tab_rows : number + Total number of rows + tab_cols : number + Total number of columns + max_cell_id : number + Highest table cell id + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + pdf_cells : list of dict + List of PDF cells as defined by Docling + matches : dictionary of lists of table_cells + A dictionary which is indexed by the pdf_cell_id as key and the value is a list + of the table_cells that fall inside that pdf cell + + Returns + ------- + new_matches : dictionary of lists of table_cells + updated matches + new_table_cells : list of dict + updated table cells + max_cell_id : number + New highest table cell id, accounting freshly added table cells (if any) + """ + + new_matches = matches + new_table_cells = table_cells + + # Identify orphan rows (START) + orphan_rows = [] + orphan_rows_depth = [] + orphan_rows_bbox = [] + + # List with pdf_ids which are used in some (any) row + used_row_pdf_ids = [] + used_row_rowid = [] + + for row in range(tab_rows): + bbox_y1s = [] # y2 > y1 + bbox_y2s = [] + row_y1 = -1 + row_y2 = -1 + row_table_cells = [] + row_table_cell_ids = [] + orphan_cells_in_row = [] + orphan_cells_in_row_depth = [] + orphan_cells_in_row_bbox = [] + + for cell in table_cells: + if cell["row_id"] == row: + # Do not consider spanned cells + if "rowspan_val" not in cell: + # Do not consider empty cells + if cell["cell_class"] > 1: + table_cell_id = cell["cell_id"] + row_table_cells.append(cell) + row_table_cell_ids.append(table_cell_id) + bbox_y1s.append(cell["bbox"][1]) + bbox_y2s.append(cell["bbox"][3]) + + # Y coordinates that define band of rows + if len(bbox_y1s) > 0: + row_y1 = min(bbox_y1s) + if len(bbox_y2s) > 0: + row_y2 = max(bbox_y2s) + + # Find "orphan" cells that intersect the band + for pdf_cell in pdf_cells: + pdf_str_id = str(pdf_cell["id"]) + if pdf_str_id not in matches: + within_band = False + depth = -1 + + centroid_band = (row_y2 + row_y1) / 2 + centroid_cell = (pdf_cell["bbox"][3] + pdf_cell["bbox"][1]) / 2 + + # pdf_cell - Orphan, and don't have any match + if pdf_cell["bbox"][1] >= row_y1 and pdf_cell["bbox"][1] <= row_y2: + depth = abs(centroid_band - centroid_cell) + within_band = True + + if pdf_cell["bbox"][3] >= row_y1 and pdf_cell["bbox"][3] <= row_y2: + depth = abs(centroid_band - centroid_cell) + within_band = True + + if pdf_cell["bbox"][1] <= row_y1 and pdf_cell["bbox"][3] >= row_y2: + depth = abs(centroid_band - centroid_cell) + within_band = True + + if within_band: + if pdf_str_id not in used_row_pdf_ids: + used_row_pdf_ids.append(pdf_str_id) + used_row_rowid.append(row) + orphan_cells_in_row.append(pdf_str_id) + orphan_cells_in_row_depth.append(round(depth)) + orphan_cells_in_row_bbox.append(pdf_cell["bbox"]) + else: + self._log().debug("Found duplicate: {}".format(pdf_str_id)) + # Get index of a row where pdf cell was already detected + used_ind = used_row_pdf_ids.index(pdf_str_id) + duplicate_id_found_in_row = used_row_rowid[used_ind] + valid_duplicate = False + if len(orphan_rows) > duplicate_id_found_in_row: + index_in_row_list = orphan_rows[ + duplicate_id_found_in_row + ].index(pdf_str_id) + valid_duplicate = True + + if valid_duplicate: + i1 = duplicate_id_found_in_row + i2 = index_in_row_list + score1 = orphan_rows_depth[i1][i2] + score2 = round(depth) + # If new cell better than the old one + if score2 < score1: + # Delete old record about the pdf cell... + orphan_rows[i1].pop(index_in_row_list) + orphan_rows_depth[i1].pop(index_in_row_list) + orphan_rows_bbox[i1].pop(index_in_row_list) + + used_row_pdf_ids.pop(used_ind) + used_row_rowid.pop(used_ind) + # Then proceed adding new cell + used_row_pdf_ids.append(pdf_str_id) + used_row_rowid.append(row) + orphan_cells_in_row.append(pdf_str_id) + orphan_cells_in_row_depth.append(round(depth)) + orphan_cells_in_row_bbox.append(pdf_cell["bbox"]) + msg = "Resolved duplicate: {} in favor of new one" + self._log().debug(msg.format(pdf_str_id)) + else: + msg = "Resolved duplicate: {} in favor of old one" + self._log().debug(msg.format(pdf_str_id)) + + log_msg = "Row: {}, Band: {}/{}, Orphan PDF cells: {}" + self._log().debug(log_msg.format(row, row_y1, row_y2, orphan_cells_in_row)) + orphan_rows.append(orphan_cells_in_row) + orphan_rows_depth.append(orphan_cells_in_row_depth) + orphan_rows_bbox.append(orphan_cells_in_row_bbox) + + # Identify orphan rows (END) + self._log().debug("...") + # Identify orphan columns + orphan_columns = [] + orphan_columns_depth = [] + orphan_columns_bbox = [] + used_col_pdf_ids = [] + used_col_columnid = [] + + for col in range(tab_cols): + bbox_x1s = [] # y2 > y1 + bbox_x2s = [] + col_x1 = -1 + col_x2 = -1 + col_table_cells = [] + col_table_cell_ids = [] + orphan_cells_in_col = [] + orphan_cells_in_col_depth = [] + orphan_cells_in_col_bbox = [] + + for cell in table_cells: + if cell["column_id"] == col: + # Do not consider spanned cells + if "colspan_val" not in cell: + # Do not consider empty cells + if cell["cell_class"] > 1: + table_cell_id = cell["cell_id"] + col_table_cells.append(cell) + col_table_cell_ids.append(table_cell_id) + bbox_x1s.append(cell["bbox"][0]) + bbox_x2s.append(cell["bbox"][2]) + else: + wrn_txt = "Orphan matching skipped cell in column {} because of colspan" + self._log().debug(wrn_txt.format(col)) + # self._log().info(cell) + + # X coordinates that define band of columns + if len(bbox_x1s) > 0: + col_x1 = min(bbox_x1s) + if len(bbox_x2s) > 0: + col_x2 = max(bbox_x2s) + + # Find "orphan" cells that intersect the band + for pdf_cell in pdf_cells: + pdf_str_id = str(pdf_cell["id"]) + if pdf_str_id not in matches: + within_band = False + depth = -1 + + centroid_band = (col_x2 + col_x1) / 2 + centroid_cell = (pdf_cell["bbox"][2] + pdf_cell["bbox"][0]) / 2 + + if pdf_cell["bbox"][0] >= col_x1 and pdf_cell["bbox"][0] <= col_x2: + depth = abs(centroid_band - centroid_cell) + within_band = True + + if pdf_cell["bbox"][2] >= col_x1 and pdf_cell["bbox"][2] <= col_x2: + depth = abs(centroid_band - centroid_cell) + within_band = True + + if pdf_cell["bbox"][0] < col_x1 and pdf_cell["bbox"][2] > col_x2: + depth = abs(centroid_band - centroid_cell) + within_band = True + + if within_band: + if pdf_str_id not in used_col_pdf_ids: + used_col_pdf_ids.append(pdf_str_id) + used_col_columnid.append(col) + orphan_cells_in_col.append(pdf_str_id) + orphan_cells_in_col_depth.append(round(depth)) + orphan_cells_in_col_bbox.append(pdf_cell["bbox"]) + else: + self._log().debug("Found duplicate: {}".format(pdf_str_id)) + # Get index of a column where pdf cell was already detected + used_ind = used_col_pdf_ids.index(pdf_str_id) + duplicate_id_found_in_column = used_col_columnid[used_ind] + + valid_col_duplicate = False + if len(orphan_columns) > duplicate_id_found_in_column: + index_in_col_list = orphan_columns[ + duplicate_id_found_in_column + ].index(pdf_str_id) + valid_col_duplicate = True + + if valid_col_duplicate: + i1 = duplicate_id_found_in_column + i2 = index_in_col_list + score1 = orphan_columns_depth[i1][i2] + score2 = round(depth) + # If new cell better than the old one + if score2 < score1: + # Delete old record about the pdf cell... + orphan_columns[i1].pop(index_in_col_list) + orphan_columns_depth[i1].pop(index_in_col_list) + orphan_columns_bbox[i1].pop(index_in_col_list) + + used_col_pdf_ids.pop(used_ind) + used_col_columnid.pop(used_ind) + # Then proceed adding new cell + used_col_pdf_ids.append(pdf_str_id) + used_col_columnid.append(col) + orphan_cells_in_col.append(pdf_str_id) + orphan_cells_in_col_depth.append(round(depth)) + orphan_cells_in_col_bbox.append(pdf_cell["bbox"]) + msg = "Resolved duplicate: {} in favor of new one" + self._log().debug(msg.format(pdf_str_id)) + else: + msg = "Resolved duplicate: {} in favor of old one" + self._log().debug(msg.format(pdf_str_id)) + + orphan_columns.append(orphan_cells_in_col) + orphan_columns_depth.append(orphan_cells_in_col_depth) + orphan_columns_bbox.append(orphan_cells_in_col_bbox) + + # Assign to structural cells and/or create new cells when absent + + for col_ind in range(len(orphan_columns)): + self._log().debug( + "Col: {}, Orphan PDF cells: {}".format(col_ind, orphan_columns[col_ind]) + ) + self._log().debug( + "Col: {}, Orphan Depth: {}".format( + col_ind, orphan_columns_depth[col_ind] + ) + ) + self._log().debug("...") + + # Collect the pdf_ids from the orphan_rows and sort them in order to produce the same + # results with the c++ implementation + orphan_rows_pdf_ids = [] + row_id_per_pdf_id = {} # pdf_cell_id -> row_id + for row_id, row_pdf_ids in enumerate(orphan_rows): + if len(row_pdf_ids) == 0: + continue + # Extend the orphan_rows_pdf_ids with the pdf_ids as int + orphan_rows_pdf_ids.extend([int(x) for x in row_pdf_ids]) + # Set the row_id for the pdf_ids + for pdf_cell_id in row_pdf_ids: + row_id_per_pdf_id[int(pdf_cell_id)] = row_id + + orphan_rows_pdf_ids.sort() + + # Assign Table cell Row ID / Table cell Column ID to orphans, + # Check if Table cell doesn't exist in the table_cells, create one, + # add match to new_matches + for pdf_cell_id_int in orphan_rows_pdf_ids: + new_row_id = row_id_per_pdf_id[pdf_cell_id_int] + new_column_id = 0 + pdf_cell_id = str(pdf_cell_id_int) + + if pdf_cell_id in used_col_pdf_ids: + new_column_id = used_col_columnid[used_col_pdf_ids.index(pdf_cell_id)] + + self._log().debug( + "new_column_id {}, pdf_cell_id {}".format( + new_column_id, pdf_cell_id + ) + ) + self._log().debug(orphan_columns[new_column_id]) + depth_index = orphan_columns[new_column_id].index(pdf_cell_id) + confidence = orphan_columns_depth[new_column_id][depth_index] + pdf_bbox = orphan_columns_bbox[new_column_id][depth_index] + + # 1. Find table_cell_id by new_row_id / new_column_id + new_table_cell_id = -1 + tcell = list( + filter( + lambda table_cell: table_cell["row_id"] == new_row_id + and table_cell["column_id"] == new_column_id, + table_cells, + ) + ) + + if len(tcell) > 0: + new_table_cell_id = tcell[0]["cell_id"] + self._log().debug( + "reusing table_cell_id: {}".format(new_table_cell_id) + ) + + for i in range(len(new_table_cells)): + if new_table_cells[i]["cell_id"] == new_table_cell_id: + bbox_tmp = self._merge_two_bboxes( + new_table_cells[i]["bbox"], pdf_bbox + ) + new_table_cells[i]["bbox"] = bbox_tmp + + if new_table_cell_id < 0: + max_cell_id += 1 + new_table_cell_id = max_cell_id + + new_table_cell = { + "bbox": pdf_bbox, + "cell_id": new_table_cell_id, + "column_id": new_column_id, + "label": "body", + "row_id": new_row_id, + "cell_class": 2, + } + self._log().debug( + "making new table_cell_id: {}".format(new_table_cell_id) + ) + new_table_cells.append(new_table_cell) + + # And then add new match to the new_matches + new_matches[str(pdf_cell_id)] = [ + {"post": confidence, "table_cell_id": new_table_cell_id} + ] + return new_matches, new_table_cells, max_cell_id + + def _clear_pdf_cells(self, pdf_cells): + r""" + Clean PDF cells from cells that have an empty string as text + + Parameters + ---------- + pdf_cells : list of dict + List of PDF cells as defined by Docling + + Returns + ------- + new_pdf_cells : list of dict + updated, cleaned list of pdf_cells + """ + new_pdf_cells = [] + for i in range(len(pdf_cells)): + if pdf_cells[i]["text"] != "": + new_pdf_cells.append(pdf_cells[i]) + return new_pdf_cells + + def process(self, matching_details): + r""" + Do post processing, see details in the comments below + + Parameters + ---------- + matching_details : dictionary + contains all the necessary information for Docling processing + already has predictions and initial (IOU) matches + + Returns + ------- + matching_details : dictionary + matching_details that contain post-processed matches + """ + + # ==================================================================================== + # Start post-processing + # ==================================================================================== + + # General description of post-processing algorithm to improve matching + + # Uses: (IOU) matches, pdf_cells, table_cells + # Generates: new_table_cells, new_matches + + # +0. Get minimal grid table dimension (cols/rows) + # +1. Get good/bad IOU predicted cells for each structural column (of minimal grid) + # +1.a. If all IOU in a column are bad - eliminate column (from bboxes and structure) + # +2. Find alignment of good IOU cells per column + # +2.a. For this, measure min-max distance for left, min-max distance for centroid, + # min-max distance for right side of cell rectangles + # smallest distance would determine Left / Center / Right alignment + # +3. Get median* (according to alignment) "bbox left/middle/right X" coord + # for good IOU cells, get median* cell size in a column. + # +4. Move bad cells to the median* (left/middle/right) good in a column + # +4.a. (Additionally), re-size cell to median* size of cells in a column + # +5. Generate new matches, run Intersection over cell(pdf) on a table cells + + # NOT USED +6. Align table cell bboxes with good matches + # to encapsulate matching pdf cells + + # +7. De-duplicate columns in table_cells according to highest column score + # in: matches + intersection_pdf_matches + # +8. Do final assignment of table bbox to pdf cell based on saved scores, + # either preferring IOU over PDF Intersection, and higher Intersection over lower, + # or just use PDF Intersection + # Rule: 1 Table cell can contain many PDF cells, + # but each PDF cell has to be asigned to one Table cell + # Rule: Do not discard table bboxes at this point, asign all of them + # +8.a. Align table cell bboxes with matched pdf cells bboxes (instead of step 6) + + # +9. Pick up remaining orphan cells + # +9.a. Determine row banding per row (min/max Y per row) + # match with orphan cells (intersection with band) + # +9.b. Determine column banding per column (min/max X per column) + # match with orphan cells (intersection with band) + # +9.c. Decide to which column/row each orphan PDF cell belongs + # append match to existing structural cell, + # or create cell + # ?9.d. For each pdf-cell from the list find closest and MATCH with row-table-cell + # (minimal rectangle to-rectangle distance) + + # *Use median instead of average to account for occasional + # colspans that would span across columns, + # as they are rare they shouldn't indfluence much a median position + # of other cells in a minimal-grid column + + self._log().debug("Start prediction post-processing...") + table_cells = matching_details["table_cells"] + pdf_cells = self._clear_pdf_cells(matching_details["pdf_cells"]) + matches = matching_details["matches"] + + # ------------------------------------------------------------------------------------------ + # -1. If initial (IOU) matches are empty, + # generate new ones based on intersection over cell + + if not matches: + self._log().debug( + "-----------------------------------------------------------------" + ) + self._log().debug( + "-----------------------------------------------------------------" + ) + self._log().debug( + "- NO INITIAL MATCHES TO POST PROCESS, GENERATING NEW ONES... -" + ) + self._log().debug( + "-----------------------------------------------------------------" + ) + self._log().debug( + "-----------------------------------------------------------------" + ) + matches = self._run_intersection_match( + self._cell_matcher, table_cells, pdf_cells + ) + + # ------------------------------------------------------------------------------------------ + # 0. Get minimal grid table dimension (cols/rows) + tab_columns, tab_rows, max_cell_id = self._get_table_dimension(table_cells) + self._log().debug( + "COLS {}/ ROWS {}/ MAX CELL ID {}".format( + tab_columns, tab_rows, max_cell_id + ) + ) + + good_table_cells = [] + bad_table_cells = [] + new_bad_table_cells = [] + fixed_table_cells = [] + + # 1. Get good/bad IOU predicted cells for each structural column (of minimal grid) + for col in range(tab_columns): + g1, g2 = self._get_good_bad_cells_in_column(table_cells, col, matches) + good_table_cells = g1 + bad_table_cells = g2 + self._log().debug( + "COLUMN {}, Good table cells: {}".format(col, len(good_table_cells)) + ) + self._log().debug( + "COLUMN {}, Bad table cells: {}".format(col, len(bad_table_cells)) + ) + + # 2. Find alignment of good IOU cells per column + alignment = self._find_alignment_in_column(good_table_cells) + self._log().debug("COLUMN {}, Alignment: {}".format(col, alignment)) + # alignment = "left" + + # 3. Get median (according to alignment) "bbox left/middle/right X" + # coordinate for good IOU cells, get median* cell size in a column. + gm1, gm2, gm3, gm4 = self._get_median_pos_size(good_table_cells, alignment) + median_x = gm1 + # median_y = gm2 + median_width = gm3 + median_height = gm4 + self._log().debug("Median good X = {}".format(median_x)) + + # 4. Move bad cells to the median* (left/middle/right) good in a column + # nc = self._move_cells_to_left_pos(bad_table_cells, median_x, True, + # TODO: + nc = self._move_cells_to_left_pos( + bad_table_cells, median_x, False, median_width, median_height, alignment + ) + new_bad_table_cells = nc + fixed_table_cells.extend(good_table_cells) + fixed_table_cells.extend(new_bad_table_cells) + + # ==================================================================================== + # Sort table_cells by cell_id before running IOU, to have correct indexes on the output + fixed_table_cells_sorted = sorted(fixed_table_cells, key=lambda k: k["cell_id"]) + + # 5. Generate new matches, run Intersection over cell(pdf) on a table cells + ip = self._run_intersection_match( + self._cell_matcher, fixed_table_cells_sorted, pdf_cells + ) + intersection_pdf_matches = ip + + # 6. NOT USED + + # 7. De-duplicate columns in aligned_table_cells + # according to highest column score in: matches + intersection_pdf_matches + # (this is easier now, because duplicated cells will have same bboxes) + dd1, dd2, dd3 = self._deduplicate_cells( + tab_columns, fixed_table_cells_sorted, matches, intersection_pdf_matches + ) + dedupl_table_cells = dd1 + dedupl_matches = dd2 + + self._log().debug("...") + + # 8. Do final assignment of table bbox to pdf cell based on saved scores, + # preferring IOU over PDF Intersection, and higher Intersection over lower + # ! IOU matches currently disabled, + # and final assigment is done only on IOC matches + final_matches = self._do_final_asignment( + dedupl_table_cells, matches, dedupl_matches + ) + + # 8.a. Re-align bboxes / re-run matching + dedupl_table_cells_sorted = sorted( + dedupl_table_cells, key=lambda k: k["cell_id"] + ) + + if len(pdf_cells) > 300: + aligned_table_cells2 = dedupl_table_cells_sorted + else: + aligned_table_cells2 = self._align_table_cells_to_pdf( + dedupl_table_cells_sorted, pdf_cells, final_matches + ) + + # 9. Distance-match orphans + po1, po2, po3 = self._pick_orphan_cells( + tab_rows, + tab_columns, + max_cell_id, + aligned_table_cells2, + pdf_cells, + final_matches, + ) + final_matches_wo = po1 + table_cells_wo = po2 + max_cell_id = po3 + + self._log().debug("*** final_matches_wo") + self._log().debug(final_matches_wo) + self._log().debug("*** table_cells_wo") + self._log().debug(table_cells_wo) + + for pdf_cell_id in range(len(final_matches_wo)): + if str(pdf_cell_id) in final_matches_wo: + pdf_cell_match = final_matches_wo[str(pdf_cell_id)] + if len(pdf_cell_match) > 1: + l1 = "!!! Multiple - {}x pdf cell match with id: {}" + self._log().info(l1.format(len(pdf_cell_match), pdf_cell_id)) + if pdf_cell_match: + tcellid = pdf_cell_match[0]["table_cell_id"] + for tcell in table_cells_wo: + if tcell["cell_id"] == tcellid: + mrow = tcell["row_id"] + mcol = tcell["column_id"] + l2 = "pdf cell: {} -> row: {} | col:{}" + self._log().debug(l2.format(pdf_cell_id, mrow, mcol)) + else: + self._log().debug( + "!!! pdf cell doesn't have match: {}".format(pdf_cell_id) + ) + + # Example of an object: + # matching_details = { + # "iou_threshold": self._iou_thres, + # "table_bbox": table_bbox, + # "prediction": prediction, + # "pdf_cells": pdf_cells, + # "page_height": docling_table["page_height"], + # "page_width": docling_table["page_width"], + # "table_cells": table_cells, + # "matches": matches + # } + + matching_details["table_cells"] = table_cells_wo + matching_details["matches"] = final_matches_wo + matching_details["pdf_cells"] = pdf_cells + + self._log().debug("Done prediction matching and post-processing!") + return matching_details diff --git a/docling_ibm_models/tableformer/data_management/tf_cell_matcher.py b/docling_ibm_models/tableformer/data_management/tf_cell_matcher.py new file mode 100644 index 0000000..8a925c7 --- /dev/null +++ b/docling_ibm_models/tableformer/data_management/tf_cell_matcher.py @@ -0,0 +1,596 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import copy +import logging +import re + +import numpy as np + +import docling_ibm_models.tableformer.otsl as otsl +import docling_ibm_models.tableformer.settings as s + +# LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG +LOG_LEVEL = logging.WARN + +# Cell labels +BODY = "body" +COL_HEADER = "col_header" +MULTI_COL_HEADER = "multi_col_header" +MULTI_ROW_HEADER = "multi_row_header" +MULTI_ROW = "multi_row" +MULTI_COL = "multi_col" + + +def validate_bboxes_page(bboxes): + r""" + Useful function for Debugging + + Validate that the bboxes have a positive area in the page coordinate system + + Parameters + ---------- + bboxes : list of 4 + Each element of the list is expected to be a bbox in the page coordinates system + + Returns + ------- + int + The number of invalid bboxes. + """ + invalid_counter = 0 + for i, bbox in enumerate(bboxes): + area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) + + if area < 0: + print("Wrong bbox: {} - {}".format(i, bbox)) + invalid_counter += 1 + + if invalid_counter > 0: + print("Invalid bboxes in total: {}".format(invalid_counter)) + return invalid_counter + + +def find_intersection(b1, b2): + r""" + Compute the intersection between 2 bboxes + + Parameters + ---------- + b1 : list of 4 + The page x1y1x2y2 coordinates of the bbox + b2 : list of 4 + The page x1y1x2y2 coordinates of the bbox + + Returns + ------- + The bbox of the intersection or None if there is no intersection + """ + # Check when the bboxes do NOT intersect + if b1[2] < b2[0] or b2[2] < b1[0] or b1[1] > b2[3] or b2[1] > b2[3]: + return None + + i_bbox = [ + max(b1[0], b2[0]), + max(b1[1], b2[1]), + min(b1[2], b2[2]), + min(b1[3], b2[3]), + ] + return i_bbox + + +class CellMatcher: + r""" + Match the table cells to the pdf page cells. + + NOTICE: PDF page coordinate system vs table coordinate system. + In both systems the bboxes are described in as (x1, y1, x2, y2) with the following meaning: + + Page coordinate system: + - Origin (0, 0) at the lower-left corner + - (x1, y1) the lower left corner of the box + - (x2, y2) the upper right corner of the box + + Table coordinate system: + - Origin (0, 0) at the upper-left corner + - (x1, y1) the upper left corner of the box + - (x2, y2) the lower right corner of the box + """ + + def __init__(self, config): + self._config = config + self._iou_thres = config["predict"]["pdf_cell_iou_thres"] + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def match_cells(self, iocr_page, table_bbox, prediction): + r""" + Convert the tablemodel prediction into the Docling format + + Parameters + ---------- + iocr_page : dict + The original Docling provided table data + prediction : dict + The dictionary has the keys: + "tag_seq": The sequence in indices from the WORDMAP + "html_seq": The sequence as html tags + "bboxes": The bounding boxes + + Returns + ------- + matching_details : dict + Dictionary with all details about the mathings between the table and pdf cells + """ + pdf_cells = copy.deepcopy(iocr_page["tokens"]) + for word in pdf_cells: + word["bbox"] = [ + word["bbox"]["l"], + word["bbox"]["t"], + word["bbox"]["r"], + word["bbox"]["b"], + ] + table_bboxes = prediction["bboxes"] + table_classes = prediction["classes"] + # BBOXES transformed... + table_bboxes_page = self._translate_bboxes(table_bbox, table_bboxes) + + # Combine the table tags and bboxes into TableCells + html_seq = prediction["html_seq"] + otsl_seq = prediction["rs_seq"] + table_cells = self._build_table_cells( + html_seq, otsl_seq, table_bboxes_page, table_classes + ) + matches, matches_counter = self._intersection_over_pdf_match( + table_cells, pdf_cells + ) + + self._log().debug("matches_counter: {}".format(matches_counter)) + + # Build output + matching_details = { + "iou_threshold": self._iou_thres, + "table_bbox": table_bbox, + "prediction_bboxes_page": table_bboxes_page, # Make easier the comparison with c++ + "prediction": prediction, + "pdf_cells": pdf_cells, + "page_height": iocr_page["height"], + "page_width": iocr_page["width"], + "table_cells": table_cells, + "pdf_cells": pdf_cells, + "matches": matches, + } + return matching_details + + def match_cells_dummy(self, iocr_page, table_bbox, prediction): + r""" + Convert the tablemodel prediction into the Docling format + DUMMY version doesn't do matching with text cells, but propagates predicted bboxes, + respecting the rest of the format + + Parameters + ---------- + iocr_page : dict + The original Docling provided table data + prediction : dict + The dictionary has the keys: + "tag_seq": The sequence in indices from the WORDMAP + "html_seq": The sequence as html tags + "bboxes": The bounding boxes + + Returns + ------- + matching_details : dict + Dictionary with all details about the mathings between the table and pdf cells + """ + pdf_cells = copy.deepcopy(iocr_page["tokens"]) + for word in pdf_cells: + word["bbox"] = [ + word["bbox"]["l"], + word["bbox"]["t"], + word["bbox"]["r"], + word["bbox"]["b"], + ] + + table_bboxes = prediction["bboxes"] + table_classes = prediction["classes"] + # BBOXES transformed... + table_bboxes_page = self._translate_bboxes(table_bbox, table_bboxes) + + # Combine the table tags and bboxes into TableCells + html_seq = prediction["html_seq"] + otsl_seq = prediction["rs_seq"] + + table_cells = self._build_table_cells( + html_seq, otsl_seq, table_bboxes_page, table_classes + ) + + # Build output + matching_details = { + "iou_threshold": self._iou_thres, + "table_bbox": table_bbox, + "prediction_bboxes_page": table_bboxes_page, + "prediction": prediction, + "pdf_cells": pdf_cells, + "page_height": iocr_page["height"], + "page_width": iocr_page["width"], + "table_cells": table_cells, + "pdf_cells": pdf_cells, + "matches": {}, + } + return matching_details + + def _build_table_cells(self, html_seq, otsl_seq, bboxes, table_classes): + r""" + Combine the tags and bboxes of the table into unified TableCell objects. + Each TableCell takes a row_id, column_id index based on the html structure provided by + html_seq. + It is assumed that the bboxes are in sync with the appearence of the closing + + Parameters + ---------- + html_seq : list + List of html tags + bboxes : list of lists of 4 + Bboxes for the table cells at the page origin + + Returns + ------- + list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + """ + table_html_structure = { + "html": {"structure": {"tokens": html_seq}}, + "split": "predict", + "filename": "memory", + } + + otsl_spans = {} + + # r, o = otsl.html_to_otsl(table, writer, true, extra_debug, include_html) + r, o = otsl.html_to_otsl(table_html_structure, None, False, False, True, False) + if not r: + ermsg = "ERR#: COULD NOT CONVERT TO RS THIS TABLE TO COMPUTE SPANS" + print(ermsg) + else: + otsl_spans = o["otsl_spans"] + + table_cells = [] + + # It is assumed that the bboxes appear in sync (at the same order) as the TDs + cell_id = 0 + + row_id = -1 + column_id = -1 + in_header = False + in_body = False + multicol_tag = "" + colspan_val = 0 + rowspan_val = 0 + + mode = "OTSL" + if mode == "HTML": + for tag in html_seq: + label = None + if tag == "": + in_header = True + multicol_tag = "" + colspan_val = 0 + rowspan_val = 0 + elif tag == "": + in_header = False + multicol_tag = "" + colspan_val = 0 + rowspan_val = 0 + elif tag == "": + in_body = True + multicol_tag = "" + colspan_val = 0 + rowspan_val = 0 + elif tag == "": + in_body = False + multicol_tag = "" + colspan_val = 0 + rowspan_val = 0 + elif tag == "" or tag == "": + row_id += 1 + column_id = -1 + multicol_tag = "" + colspan_val = 0 + rowspan_val = 0 + elif "colspan" in tag: + label = MULTI_COL + multicol_tag += tag + colspan_val = int(re.findall(r'"([^"]*)"', tag)[0]) + elif "rowspan" in tag: + label = MULTI_ROW + multicol_tag += tag + rowspan_val = int(re.findall(r'"([^"]*)"', tag)[0]) + elif tag == "": # Create a TableCell on each closing td + if len(multicol_tag) > 0: + multicol_tag += tag + if in_header: + if label is None: + label = COL_HEADER + elif label == MULTI_COL: + label = MULTI_COL_HEADER + elif label == MULTI_ROW: + label = MULTI_ROW_HEADER + if label is None and in_body: + label = BODY + + err_mismatch = "Mismatching bboxes with closing TDs {} < {}".format( + cell_id, len(bboxes) + ) + assert cell_id < len(bboxes), err_mismatch + bbox = bboxes[cell_id] + cell_class = table_classes[cell_id] + + table_cell = {} + table_cell["cell_id"] = cell_id + table_cell["row_id"] = row_id + table_cell["column_id"] = column_id + table_cell["bbox"] = bbox + table_cell["cell_class"] = cell_class + table_cell["label"] = label + table_cell["multicol_tag"] = multicol_tag + if colspan_val > 0: + table_cell["colspan_val"] = colspan_val + column_id += ( + colspan_val - 1 + ) # Shift column index to account for span + if rowspan_val > 0: + table_cell["rowspan_val"] = rowspan_val + + table_cells.append(table_cell) + cell_id += 1 + + if mode == "OTSL": + row_id = 0 + column_id = 0 + multicol_tag = "" + otsl_line = [] + cell_id_line = [] + + for tag in otsl_seq: + otsl_line.append(tag) + if tag == "nl": + row_id += 1 + column_id = 0 + otsl_line = [] + cell_id_line = [] + if tag in ["fcel", "ecel", "xcel", "ched", "rhed", "srow"]: + cell_id_line.append(cell_id) + bbox = [0.0, 0.0, 0.0, 0.0] + if cell_id < len(bboxes): + bbox = bboxes[cell_id] + + cell_class = 2 + if cell_id < len(table_classes): + cell_class = table_classes[cell_id] + label = tag + + table_cell = {} + table_cell["cell_id"] = cell_id + table_cell["row_id"] = row_id + table_cell["column_id"] = column_id + table_cell["bbox"] = bbox + table_cell["cell_class"] = cell_class + table_cell["label"] = label + table_cell["multicol_tag"] = multicol_tag + + colspan_val = 0 + rowspan_val = 0 + + if cell_id in otsl_spans: + colspan_val = otsl_spans[cell_id][0] + rowspan_val = otsl_spans[cell_id][1] + if colspan_val > 0: + table_cell["colspan_val"] = colspan_val + if rowspan_val > 0: + table_cell["rowspan_val"] = rowspan_val + + table_cells.append(table_cell) + cell_id += 1 + if tag != "nl": + column_id += 1 + + return table_cells + + def _translate_bboxes(self, table_bbox, cell_bboxes): + r""" + Translate table cell bboxes to the lower-left corner of the page. + + The cells of the table are given: + - Origin at the top left corner + - Point A: Top left corner + - Point B: Low right corner + - Coordinate values are normalized to the table width/height + + Parameters + ---------- + table_bbox : list of 4 + The whole table bbox page coordinates + cell_bboxes : list of lists of 4 + The bboxes of the table cells + + Returns + ------- + list of 4 + The translated bboxes of the table cells + """ + W = table_bbox[2] - table_bbox[0] + H = table_bbox[3] - table_bbox[1] + b = np.asarray(cell_bboxes) + t_mask = np.asarray( + [table_bbox[0], table_bbox[3], table_bbox[0], table_bbox[3]] + ) + m = np.asarray([W, -H, W, -H]) + page_bboxes_y_flipped = t_mask + m * b + page_bboxes = page_bboxes_y_flipped[:, [0, 3, 2, 1]] # Flip y1' with y2' + page_bboxes_list = page_bboxes.tolist() + + t_height = table_bbox[3] + page_bboxes_list1 = [] + for page_bbox in page_bboxes_list: + page_bbox1 = [ + page_bbox[0], + t_height - page_bbox[3] + table_bbox[1], + page_bbox[2], + t_height - page_bbox[1] + table_bbox[1], + ] + page_bboxes_list1.append(page_bbox1) + return page_bboxes_list1 + + def _intersection_over_pdf_match(self, table_cells, pdf_cells): + r""" + Compute Intersection between table cells and pdf cells, + match 1 pdf cell with highest intersection with only 1 table cell. + + First compute and cache the areas for all involved bboxes. + Then compute the pairwise intersections + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + + pdf_cells : list of dict + Each element of the list is a dictionary which should have the keys: "id", "bbox" + Returns + ------- + dictionary of lists of table_cells + Return a dictionary which is indexed by the pdf_cell_id as key and the value is a list + of the table_cells that fall inside that pdf cell + int + Number of total matches + """ + pdf_bboxes = np.asarray([p["bbox"] for p in pdf_cells]) + pdf_bboxes_areas = (pdf_bboxes[:, 2] - pdf_bboxes[:, 0]) * ( + pdf_bboxes[:, 3] - pdf_bboxes[:, 1] + ) + + # key: pdf_cell_id, value: list of TableCell that fall inside that pdf_cell + matches = {} + matches_counter = 0 + + # Compute Intersections and build matches + for i, table_cell in enumerate(table_cells): + table_cell_id = table_cell["cell_id"] + t_bbox = table_cell["bbox"] + + for j, pdf_cell in enumerate(pdf_cells): + pdf_cell_id = pdf_cell["id"] + p_bbox = pdf_cell["bbox"] + + # Compute intersection + i_bbox = find_intersection(t_bbox, p_bbox) + if i_bbox is None: + continue + + # Compute IOU and filter on threshold + i_bbox_area = (i_bbox[2] - i_bbox[0]) * (i_bbox[3] - i_bbox[1]) + iopdf = 0 + if float(pdf_bboxes_areas[j]) > 0: + iopdf = i_bbox_area / float(pdf_bboxes_areas[j]) + + if iopdf > 0: + match = {"table_cell_id": table_cell_id, "iopdf": iopdf} + if pdf_cell_id not in matches: + matches[pdf_cell_id] = [match] + matches_counter += 1 + else: + # Check if the same match was not already counted + if match not in matches[pdf_cell_id]: + matches[pdf_cell_id].append(match) + matches_counter += 1 + return matches, matches_counter + + def _iou_match(self, table_cells, pdf_cells): + r""" + Use Intersection over Union to decide the matching between table cells and pdf cells + + First compute and cache the areas for all involved bboxes. + Then compute the pairwise intersections and IOUs and keep those pairs that exceed the IOU + threshold + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", "bbox", "label" + + pdf_cells : list of dict + Each element of the list is a dictionary which should have the keys: "id", "bbox" + Returns + ------- + dictionary of lists of table_cells + Return a dictionary which is indexed by the pdf_cell_id as key and the value is a list + of the table_cells that fall inside that pdf cell + int + Number of total matches + """ + table_bboxes = np.asarray([t["bbox"] for t in table_cells]) + pdf_bboxes = np.asarray([p["bbox"] for p in pdf_cells]) + + # Cache the areas for table bboxes and pdf bboxes + table_bboxes_areas = (table_bboxes[:, 2] - table_bboxes[:, 0]) * ( + table_bboxes[:, 3] - table_bboxes[:, 1] + ) + + pdf_bboxes_areas = (pdf_bboxes[:, 2] - pdf_bboxes[:, 0]) * ( + pdf_bboxes[:, 3] - pdf_bboxes[:, 1] + ) + + # key: pdf_cell_id, value: list of TableCell that fall inside that pdf_cell + matches = {} + matches_counter = 0 + + # Compute IOUs and build matches + for i, table_cell in enumerate(table_cells): + table_cell_id = table_cell["cell_id"] + t_bbox = table_cell["bbox"] + + for j, pdf_cell in enumerate(pdf_cells): + pdf_cell_id = pdf_cell["id"] + pdf_cell_text = pdf_cell["text"] + p_bbox = pdf_cell["bbox"] + + # Compute intersection + i_bbox = find_intersection(t_bbox, p_bbox) + if i_bbox is None: + continue + + # Compute IOU and filter on threshold + i_bbox_area = (i_bbox[2] - i_bbox[0]) * (i_bbox[3] - i_bbox[1]) + iou = 0 + div_area = float( + table_bboxes_areas[i] + pdf_bboxes_areas[j] - i_bbox_area + ) + if div_area > 0: + iou = i_bbox_area / div_area + if iou < self._iou_thres: + continue + + if pdf_cell_id not in matches: + matches[pdf_cell_id] = [] + + match = { + "table_cell_id": table_cell_id, + "iou": iou, + "text": pdf_cell_text, + } + matches[pdf_cell_id].append(match) + matches_counter += 1 + + return matches, matches_counter diff --git a/docling_ibm_models/tableformer/data_management/tf_dataset.py b/docling_ibm_models/tableformer/data_management/tf_dataset.py new file mode 100644 index 0000000..db42f07 --- /dev/null +++ b/docling_ibm_models/tableformer/data_management/tf_dataset.py @@ -0,0 +1,1233 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import json +import logging +import os +from glob import glob +from html import escape + +import jsonlines +import numpy as np +import torch +import torch.utils.data +from lxml import html +from PIL import Image +from torch.nn.utils.rnn import pad_sequence +from torch.utils.data import Dataset +from tqdm import tqdm + +import docling_ibm_models.tableformer.common as c +import docling_ibm_models.tableformer.settings as s +import docling_ibm_models.tableformer.utils.utils as u +from docling_ibm_models.tableformer.data_management.data_transformer import ( + DataTransformer, +) + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +class TFDataset(Dataset): + def __init__(self, config, purpose, fixed_padding=False): + r""" + Parameters + ---------- + config : Dictionary + The input configuration file + purpose : string + One of s.TRAIN_PURPOSE, s.VAL_PURPOSE, s.PREDICT_PURPOSE + fixed_padding : bool + If False (default), the produced tag sequences will be truncated to the maximum + actual length among the tag sequences of the batch + If True the produced tag and cell sequences will have fixed length equal to + max_tag_len and max_cell_len respectively. + """ + self.cml_task = {} + self.cml_logger = {} + self._config = config + self._fixed_padding = fixed_padding + self._index = 0 # Index to the current image file + self._max_tag_len = c.safe_get_parameter( + config, ["preparation", "max_tag_len"], required=True + ) + self._max_cell_len = c.safe_get_parameter( + config, ["preparation", "max_cell_len"], required=True + ) + self._resized_image = c.safe_get_parameter( + config, ["dataset", "resized_image"], required=True + ) + self.annotation = c.safe_get_parameter( + config, ["preparation", "annotation"], required=True + ) + self._image_normalization = config["dataset"]["image_normalization"] + + self._load_cells = c.safe_get_parameter( + config, ["dataset", "load_cells"], required=False + ) + self._predict_dir = c.safe_get_parameter( + config, ["predict", "predict_dir"], required=False + ) + self._train_bbox = c.safe_get_parameter( + config, ["train", "bbox"], required=False + ) + self._predict_bbox = c.safe_get_parameter( + config, ["predict", "bbox"], required=False + ) + + self._log().debug("purpose: {}".format(purpose)) + self._log().debug("resized_image: {}".format(self._resized_image)) + self._log().debug("image_normalization: {}".format(self._image_normalization)) + + # Check the type of the dataset + dataset_type = c.safe_get_parameter(config, ["dataset", "type"]) + if dataset_type not in s.supported_datasets: + msg = "Unsupported dataset type: " + dataset_type + self._log().error(msg) + raise NotImplementedError(msg) + self._dataset_type = dataset_type + + # Check the purpose of the object + if purpose not in [ + s.TRAIN_PURPOSE, + s.VAL_PURPOSE, + s.TEST_PURPOSE, + s.PREDICT_PURPOSE, + ]: + msg = "Unsupported purpose: " + purpose + self._log().error(msg) + raise Exception(msg) + self._purpose = purpose + + # The batch_size is grounded to 1 in case of VAL, PREDICT + if purpose == s.TRAIN_PURPOSE: + self._batch_size = c.safe_get_parameter( + config, ["train", "batch_size"], required=True + ) + else: + self._batch_size = 1 + self._log().debug("batch_size: {}".format(self._batch_size)) + + self._transformer = DataTransformer(config) + if purpose == s.PREDICT_PURPOSE: + self._build_predict_cache() + else: + self._build_cache() + + self._index = 0 # Index to the current image file + self._ind = np.array(range(self._dataset_size)) + + def set_device(self, device): + r""" + Set the device to be used to place the tensors when looping over the data + + Parameters + ---------- + device : torch.device or int + The device to do the training + """ + self._device = device + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def __len__(self): + return int(self._dataset_size) + + def get_batch_num(self): + return int(np.ceil(self._dataset_size / self._batch_size)) + + def _pad_tensors_from_batch(self, batch, field): + r""" + Retrieves data about tensor - "field" from the raw DataLoader batch list + And pads it to maximum batch length, to be further collated in the + custom collator function + + Parameters + ---------- + batch : list + The list of samples, obtained by DataLoader from the sampler + a non-collated batch + field: string + Name of the tensor data-point from the sample, that has to be collated, + and because of that has to be padded to max length of the tensor in the batch + + Returns + ------- + batchoftensors: list + The list of padded tensors + """ + # Make list of selected items by field name + list_of_items = [x[field] for x in batch] + tagseqlens = [] + # Identify lengths of tensor "lists" + for i, ten in enumerate(list_of_items): + tagnum = ten[0].size()[0] + tagseqlens.append(tagnum) + # Get the biggest length + maxbatchtaglen = max(tagseqlens) + + # Prepare new list with padded tensors + batchoftensors = [] + for i, ten in enumerate(list_of_items): + tagtensor = ten + newtagtensor = torch.zeros( + 1, maxbatchtaglen, dtype=torch.long, device=self._device + ) + newtagtensor[:, : tagtensor.size()[1]] = tagtensor + batchoftensors.append(newtagtensor) + + return batchoftensors + + def bcol(self, batch): + r""" + Custom collate fucntion for Pytorch DataLoader, to collate items prepared + by TFDataset into batches + + Parameters + ---------- + batch : list + The list of samples, obtained by DataLoader from the sampler + a non-collated batch + + Returns + ------- + batchoftensors: tuple + Tuple of lists of items, properly collated into batches + """ + collated = {} + test_gt = {} + if bool(batch[0]["test_gt"]): + for x in batch: + test_gt.update(x["test_gt"]) + + if len(batch) > 1: + # In case batch length is more than 1 we want to collate all elements in batch + # Every element has it's own rule how to collate + + if self._load_cells: + cells = [ + item for sublist in [x["cells"] for x in batch] for item in sublist + ] + else: + cells = [] + cell_lens = [ + item for sublist in [x["cell_lens"] for x in batch] for item in sublist + ] + cell_bboxes = [] + + if "cell_bboxes" in batch[0] and batch[0]["cell_bboxes"]: + for x in batch: + cell_bboxes.append( + { + "boxes": x["cell_bboxes"][0][0], + "labels": x["cell_bboxes"][0][1], + } + ) + + samples = [ + item for sublist in [x["samples"] for x in batch] for item in sublist + ] + + # Sequences of tags have to be padded and then collated: + batchoftags = self._pad_tensors_from_batch(batch, "tags") + tags = pad_sequence(batchoftags, batch_first=True) + tags = torch.squeeze(tags, 1) + + tag_lens = pad_sequence([x["tag_lens"] for x in batch], batch_first=True) + tag_lens = torch.squeeze(tag_lens, 1) + num_cells = pad_sequence([x["num_cells"] for x in batch], batch_first=True) + num_cells = torch.squeeze(num_cells, 1) + + collated = ( + torch.cat([x["imgs"] for x in batch], dim=0), + tags, + tag_lens, + num_cells, + cells, + cell_lens, + cell_bboxes, + samples, + test_gt, + ) + else: + # In case batch length is 1 we just formulate the expected output + cell_bboxes = None + if "cell_bboxes" in batch[0] and batch[0]["cell_bboxes"]: + cell_bboxes = { + "boxes": batch[0]["cell_bboxes"][0][0], + "labels": batch[0]["cell_bboxes"][0][1], + } + + collated = ( + batch[0]["imgs"], + batch[0]["tags"], + batch[0]["tag_lens"], + batch[0]["num_cells"], + batch[0]["cells"], + batch[0]["cell_lens"], + cell_bboxes, + batch[0]["samples"], + test_gt, + ) + return collated + + def __getitem__(self, idx): + r""" + Retrieve data by the specific index from the cache + Required for Pytorch DataSampler, and to be used together with DataLoader + Depending on the "purpose" different returned objects can be None. + + Returns + (All data points presented in a dictionary, each wrapped into a list, + for easier batching and collating later on) + ------- + imgs : tensor (batch_size, image_channels, resized_image, resized_image) + Batch with the rescaled images + tags : The tags of the images. The object is one of: + None : If purpose is not "train" + (batch_size, max_tag_len + 2) : If purpose is "train" and "fixed_padding" is true. + The +2 over the max_tag_len is for the + (batch_size, batch_max_tag_len) : If purpose is "train" and "fixed_padding" is false, + where "batch_max_tag_len" is the max length of the + tags in batch + tag_lens : The real length of the tags per image in the batch. The object is one of: + None : If purpose is not "train" + (batch_size, 1) : If purpose is "train" + num_cells : The number of cells per image in the batch. The object is one of: + None : If purpose is not "train" + (batch_size, 1) : If purpose is "train" + cells : The cell tags for the images in the batch. The object is one of: + None : If purpose is not "train" + list with LongTensor: If purpose is "train" + cell_lens : The length of the cell tags per image in the batch. The object is one of: + None : If purpose is not "train" + list with LongTensor: If purpose is "train" + cell_bboxes : The transformed (rescaled, padded, etc) bboxes of the cells for all images in + batch. Each list is a bbox in the format [xc, yc, w, h] where xc, yc are the + coords of the center, w, h the width and height of the bbox and all are + normalized to the scaled size of the image. The object is one of: + None : If purpose is not "train" + list of lists: If purpose is "train" + samples : list of string + The filenames in the batch + val_gt : The ground turth raw attributes for the validation split. The object is one of: + None : If purpose is not "val" + dictionary : If purpose is "val" + """ + + # Check if index out of bounds + if idx >= self._dataset_size: + return None + + # Move current _index to requested idx + # self._index = idx + + # Images, __getitem__ provides only 1 image for specified index + # (batch_size, image_channels, resized_image, resized_image) + imgs = torch.zeros( + 1, self._img_ch, self._resized_image, self._resized_image, dtype=torch.float + ).to(self._device) + + # Initialize all output objects to None + # Depending on the "purpose" some of them will be populated + tags = None + tag_lens = None + num_cells = None + cells = None + cell_lens = None + cell_bboxes = None + + val_tags = None + val_tag_lens = None + val_num_cells = None + val_cells = None + val_cell_lens = None + val_cell_bboxes = None + + test_gt = {} + test_tags = None + test_tag_lens = None + + # Train specific output + if self._purpose == s.TRAIN_PURPOSE: + tag_len = self._taglens[idx] + fixed_tag_len = self._max_tag_len + 2 # ... + if self._fixed_padding: + tags = torch.zeros( + 1, fixed_tag_len, dtype=torch.long, device=self._device + ) + else: + tags = torch.zeros(1, tag_len, dtype=torch.long, device=self._device) + + tag_lens = torch.zeros(1, 1, dtype=torch.long).to(self._device) + num_cells = torch.zeros(1, 1, dtype=torch.long).to(self._device) + cells = [] + cell_lens = [] + cell_bboxes = [] + # val specific output + elif self._purpose == s.VAL_PURPOSE: + val_tag_len = self._val_taglens[idx] + val_fixed_tag_len = self._max_tag_len + 2 # ... + if self._fixed_padding: + val_tags = torch.zeros( + 1, val_fixed_tag_len, dtype=torch.long, device=self._device + ) + else: + val_tags = torch.zeros( + 1, val_tag_len, dtype=torch.long, device=self._device + ) + + val_tag_lens = torch.zeros(1, 1, dtype=torch.long).to(self._device) + val_num_cells = torch.zeros(1, 1, dtype=torch.long).to(self._device) + val_cells = [] + val_cell_lens = [] + val_cell_bboxes = [] + + elif self._purpose == s.TEST_PURPOSE: + if len(self._test_taglens) > 0: + # Dictionary with the raw attributes for the groundtruth. Keys are the filenames + test_gt = {} + tag_len = self._test_taglens[idx] + fixed_tag_len = self._max_tag_len + 2 # ... + if self._fixed_padding: + test_tags = torch.zeros( + 1, fixed_tag_len, dtype=torch.long, device=self._device + ) + else: + test_tags = torch.zeros( + 1, tag_len, dtype=torch.long, device=self._device + ) + test_tag_lens = torch.zeros(1, 1, dtype=torch.long).to(self._device) + cells = [] + cell_lens = [] + cell_bboxes = [] + + sample = self._image_fns[idx] + # Rescale/convert the image and bboxes + bboxes = self._bboxes[sample] + sample_fn = self._get_image_path(sample) + + if not self._table_bboxes: + table_bbox = None + else: + if sample in self._table_bboxes: + table_bbox = self._table_bboxes[sample] + else: + table_bbox = None + scaled_img, scaled_bboxes = self._transformer.sample_preprocessor( + sample_fn, bboxes, self._purpose, table_bbox + ) + + imgs[0] = scaled_img.to(self._device) + + # Train specific output + if self._purpose == s.TRAIN_PURPOSE: + # Remove the padding from tags and cells + if self._fixed_padding: + tags[0] = torch.LongTensor(self._tags[idx]).to(self._device) + else: + tags[0] = torch.LongTensor(self._tags[idx][:tag_len]).to(self._device) + + tag_lens[0] = torch.LongTensor([self._taglens[idx]]).to(self._device) + num_cells[0] = len(self._cell_lens[idx]) + + if len(self._cell_lens[idx]) > 0: + sample_max_cell_len = max(self._cell_lens[idx]) + else: + sample_max_cell_len = 0 + + if self._load_cells: + image_trimmed_cells = [ + self._cells[idx][x][0:sample_max_cell_len] + for x in range(0, len(self._cells[idx])) + ] + cells.append(torch.LongTensor(image_trimmed_cells).to(self._device)) + + cell_lens.append(torch.LongTensor(self._cell_lens[idx]).to(self._device)) + if self._train_bbox: + + cell_bboxes.append( + [ + torch.from_numpy( + np.array(scaled_bboxes, dtype=np.float32)[:, :4] + ).to(self._device), + torch.from_numpy( + np.array(scaled_bboxes, dtype=np.compat.long)[:, -1] + ).to(self._device), + ] + ) + + elif self._purpose == s.VAL_PURPOSE: + # Remove the padding from tags and cells + if self._fixed_padding: + val_tags[0] = torch.LongTensor(self._val_tags[idx]).to(self._device) + else: + val_tags[0] = torch.LongTensor(self._val_tags[idx][:val_tag_len]).to( + self._device + ) + + val_tag_lens[0] = torch.LongTensor([self._val_taglens[idx]]).to( + self._device + ) + val_num_cells[0] = len(self._val_cell_lens[idx]) + + if len(self._val_cell_lens[idx]) > 0: + sample_max_cell_len = max(self._val_cell_lens[idx]) + else: + sample_max_cell_len = 0 + + if self._load_cells: + val_image_trimmed_cells = [ + self._val_cells[idx][x][0:sample_max_cell_len] + for x in range(0, len(self._cells[idx])) + ] + val_cells.append( + torch.LongTensor(val_image_trimmed_cells).to(self._device) + ) + + val_cell_lens.append( + torch.LongTensor(self._val_cell_lens[idx]).to(self._device) + ) + if self._train_bbox: + val_cell_bboxes.append( + [ + torch.from_numpy( + np.array(scaled_bboxes, dtype=np.float32)[:, :4] + ).to(self._device), + torch.from_numpy( + np.array(scaled_bboxes, dtype=np.compat.long)[:, -1] + ).to(self._device), + ] + ) + # val specific output + elif self._purpose == s.TEST_PURPOSE: + if test_gt is not None: + test_gt[sample] = self._test[sample] + + # Remove the padding from tags and cells + if self._fixed_padding: + test_tags[0] = torch.LongTensor(self._test_tags[idx]).to( + self._device + ) + else: + test_tags[0] = torch.LongTensor(self._test_tags[idx][:tag_len]).to( + self._device + ) + test_tag_lens[0] = torch.LongTensor([self._test_taglens[idx]]).to( + self._device + ) + if self._predict_bbox: + cell_bboxes.append( + [ + torch.from_numpy( + np.array(scaled_bboxes, dtype=np.float32)[:, :4] + ).to(self._device), + torch.from_numpy( + np.array(scaled_bboxes, dtype=np.compat.long)[:, -1] + ).to(self._device), + ] + ) + + output = {} + + # Samples is a list with the given image filename + samples = [self._image_fns[idx]] + # All data points presented in a dictionary, each wrapped into a list, + # for easier batching and collating later on + if self._purpose == s.TRAIN_PURPOSE: + output["imgs"] = imgs + output["tags"] = tags + output["tag_lens"] = tag_lens + output["num_cells"] = num_cells + output["cells"] = cells + output["cell_lens"] = cell_lens + output["cell_bboxes"] = cell_bboxes + output["samples"] = samples + output["test_gt"] = test_gt + elif self._purpose == s.VAL_PURPOSE: + output["imgs"] = imgs + output["tags"] = val_tags + output["tag_lens"] = val_tag_lens + output["num_cells"] = val_num_cells + output["cells"] = val_cells + output["cell_lens"] = val_cell_lens + output["cell_bboxes"] = val_cell_bboxes + output["samples"] = samples + output["test_gt"] = test_gt + elif self._purpose == s.TEST_PURPOSE: + output["imgs"] = imgs + output["tags"] = test_tags + output["tag_lens"] = test_tag_lens + output["num_cells"] = num_cells + output["cells"] = cells + output["cell_lens"] = cell_lens + output["cell_bboxes"] = cell_bboxes + output["samples"] = samples + output["test_gt"] = test_gt + else: + output["imgs"] = imgs + output["tags"] = tags + output["tag_lens"] = tag_lens + output["num_cells"] = num_cells + output["cells"] = cells + output["cell_lens"] = cell_lens + output["cell_bboxes"] = cell_bboxes + output["samples"] = samples + output["test_gt"] = test_gt + return output + + def get_batch_size(self): + r""" + Return the actual batch_size + """ + return self._batch_size + + def reset(self): + self._index = 0 + + def __iter__(self): + return self + + def is_valid(self, img, config): + max_tag_len = config["preparation"]["max_tag_len"] + max_cell_len = config["preparation"]["max_cell_len"] + check_limits = True + if "check_limits" in config["preparation"]: + check_limits = config["preparation"]["check_limits"] + if check_limits: + if len(img["html"]["structure"]["tokens"]) > max_tag_len: + self._log().debug( + "========================================= TAG LEN REJECTED" + ) + self._log().debug("File name: {}".format(img["filename"])) + tokens_len = len(img["html"]["structure"]["tokens"]) + self._log().debug("Structure token len: {}".format(tokens_len)) + self._log().debug("More than max_tag_len: {}".format(max_tag_len)) + self._log().debug( + "==========================================================" + ) + return False + for cell in img["html"]["cells"]: + if len(cell["tokens"]) > max_cell_len: + self._log().debug( + "======================================== CELL LEN REJECTED" + ) + self._log().debug("File name: {}".format(img["filename"])) + self._log().debug("Cell len: {}".format(len(cell["tokens"]))) + self._log().debug("More than max_cell_len: {}".format(max_cell_len)) + self._log().debug( + "==========================================================" + ) + return False + self.raw_data_dir = config["preparation"]["raw_data_dir"] + with Image.open( + os.path.join(self.raw_data_dir, img["split"], img["filename"]) + ) as im: + max_image_size = config["preparation"]["max_image_size"] + if im.width > max_image_size or im.height > max_image_size: + # IMG SIZE REJECTED + return False + return True + + def __next__(self): + r""" + Get the next batch or raise the StopIteration + + In order to have the batch size fixed also in the last iteration, we wrap over the dataset + and repeat some of the first elements. + + Depending on the "purpose" different returned objects can be None. + + Returns + ------- + imgs : tensor (batch_size, image_channels, resized_image, resized_image) + Batch with the rescaled images + tags : The tags of the images. The object is one of: + None : If purpose is not "train" + (batch_size, max_tag_len + 2) : If purpose is "train" and "fixed_padding" is true. + The +2 over the max_tag_len is for the + (batch_size, batch_max_tag_len) : If purpose is "train" and "fixed_padding" is false, + where "batch_max_tag_len" is the max length of the + tags in batch + tag_lens : The real length of the tags per image in the batch. The object is one of: + None : If purpose is not "train" + (batch_size, 1) : If purpose is "train" + num_cells : The number of cells per image in the batch. The object is one of: + None : If purpose is not "train" + (batch_size, 1) : If purpose is "train" + cells : The cell tags for the images in the batch. The object is one of: + None : If purpose is not "train" + list with LongTensor: If purpose is "train" + cell_lens : The length of the cell tags per image in the batch. The object is one of: + None : If purpose is not "train" + list with LongTensor: If purpose is "train" + cell_bboxes : The transformed (rescaled, padded, etc) bboxes of the cells for all images in + batch. Each list is a bbox in the format [xc, yc, w, h] where xc, yc are the + coords of the center, w, h the width and height of the bbox and all are + normalized to the scaled size of the image. The object is one of: + None : If purpose is not "train" + list of lists: If purpose is "train" + samples : list of string + The filenames in the batch + val_gt : The ground turth raw attributes for the validation split. The object is one of: + None : If purpose is not "val" + dictionary : If purpose is "val" + """ + + if self._index >= self._dataset_size: + raise StopIteration() + + # Compute the next sample + if ( + self._dataset_size - self._index >= self._batch_size + ): # Full batch_size sample + step = self._batch_size + sample_indices = self._ind[self._index : self._index + step] + else: + # skip last batch + raise StopIteration() + + batch = [] + # Loop over the batch indices and collect items for the batch + for i, idx in enumerate(sample_indices): + item = self.__getitem__(idx) + batch.append(item) + # Collate batch + output = self.bcol(batch) + self._index += step + + return output + + def shuffle(self): + r""" + Shuffle the training images + This takes place only in case of training, otherwise it just returns + + Output: True in case a shuffling took place, False otherwise + """ + if self._purpose != s.TRAIN_PURPOSE: + return False + + # image_fns_np = np.asarray(self._image_fns) + # To get a deterministic random shuffle, we need to seed our random + # with a deterministic seed (int) + np.random.seed(42) + # Then shuffle after seeding + self._ind = np.random.permutation(self._dataset_size) + self._index = 0 + return True + + def get_init_data(self): + r""" + Create a dictionary with all kind of initialization data necessary for all models. + This data should not be served by the __next__ method. + """ + init_data = {"word_map": self._word_map, "statistics": self._statistics} + return init_data + + def _get_image_path(self, img_fn): + r""" + Get the full image path out of the image file name + """ + if self._dataset_type == "TF_prepared": + if self._purpose == s.TRAIN_PURPOSE: + full_fn = os.path.join(self._raw_data_dir, "train", img_fn) + elif self._purpose == s.VAL_PURPOSE: + full_fn = os.path.join(self._raw_data_dir, "val", img_fn) + elif self._purpose == s.TEST_PURPOSE: + full_fn = os.path.join(self._raw_data_dir, "test", img_fn) + else: + full_fn = os.path.join(self._raw_data_dir, img_fn) + + if full_fn is None or not os.path.isfile(full_fn): + self._log().error("File not found: " + full_fn) + return None + + return full_fn + + def format_html(self, img): + r""" + Formats HTML code from tokenized annotation of img + """ + tag_len = len(img["html"]["structure"]["tokens"]) + if self._load_cells: + cell_len_max = max([len(c["tokens"]) for c in img["html"]["cells"]]) + else: + cell_len_max = 0 + + HTML = img["html"]["structure"]["tokens"].copy() + to_insert = [i for i, tag in enumerate(HTML) if tag in ("", ">")] + + if self._load_cells: + for i, cell in zip(to_insert[::-1], img["html"]["cells"][::-1]): + if cell: + cell = "".join( + [ + escape(token) if len(token) == 1 else token + for token in cell["tokens"] + ] + ) + HTML.insert(i + 1, cell) + + HTML = "%s
" % "".join(HTML) + root = html.fromstring(HTML) + if self._predict_bbox: + for td, cell in zip(root.iter("td"), img["html"]["cells"]): + if "bbox" in cell: + bbox = cell["bbox"] + td.attrib["x"] = str(bbox[0]) + td.attrib["y"] = str(bbox[1]) + td.attrib["width"] = str(bbox[2] - bbox[0]) + td.attrib["height"] = str(bbox[3] - bbox[1]) + HTML = html.tostring(root, encoding="utf-8").decode() + return HTML, tag_len, cell_len_max + + def _build_predict_cache(self): + r""" + populate cache with image file names that need to be predicted + """ + self._prepared_data_dir = c.safe_get_parameter( + self._config, ["dataset", "prepared_data_dir"], required=False + ) + self._data_name = c.safe_get_parameter( + self._config, ["dataset", "name"], required=True + ) + + if self._prepared_data_dir is None: + + self._statistics = c.safe_get_parameter( + self._config, ["dataset", "image_normalization"], required=True + ) + + self._word_map = c.safe_get_parameter( + self._config, ["dataset_wordmap"], required=True + ) + + else: + # Load statistics + statistics_fn = c.get_prepared_data_filename("STATISTICS", self._data_name) + with open(os.path.join(self._prepared_data_dir, statistics_fn), "r") as f: + self._log().debug("Load statistics from: {}".format(statistics_fn)) + self._statistics = json.load(f) + + # Load word_map + word_map_fn = c.get_prepared_data_filename("WORDMAP", self._data_name) + with open(os.path.join(self._prepared_data_dir, word_map_fn), "r") as f: + self._log().debug("Load WORDMAP from: {}".format(word_map_fn)) + self._word_map = json.load(f) + + # Get Image File Names for Prediction + self._image_fns = [] + self._bboxes = {} + self._bboxes_table = {} + self._raw_data_dir = self._predict_dir + self._table_bboxes = {} + + if self._predict_dir[-1] != "/": + self._predict_dir += "/" + for path in list(glob(self._predict_dir + "**/*.png", recursive=True)): + filename = os.path.basename(path) + self._image_fns.append(filename) + self._log().info("Image found: {}".format(filename)) + self._bboxes[filename] = [] + + # Get size of a dataset to predict + self._dataset_size = len(self._image_fns) + + # Get the number of image channels + self._log().info( + "To test load... {}".format(self._predict_dir + self._image_fns[0]) + ) + img = u.load_image(self._predict_dir + self._image_fns[0]) + if img is None: + msg = "Cannot load image" + self._log().error(msg) + raise Exception(msg) + self._img_ch = img.shape[0] + + def _build_cache(self): + r""" + Cache with small data + """ + all_bboxes = {} # Keep original bboxes for all images + table_bboxes = {} + self._log().info("Building the cache...") + self._raw_data_dir = c.safe_get_parameter( + self._config, ["dataset", "raw_data_dir"], required=True + ) + self._prepared_data_dir = c.safe_get_parameter( + self._config, ["dataset", "prepared_data_dir"], required=False + ) + + self._data_name = c.safe_get_parameter( + self._config, ["dataset", "name"], required=True + ) + + if self._prepared_data_dir is None: + + self._statistics = c.safe_get_parameter( + self._config, ["dataset", "image_normalization"], required=True + ) + + self._word_map = c.safe_get_parameter( + self._config, ["dataset_wordmap"], required=True + ) + + else: + # Load statistics + statistics_fn = c.get_prepared_data_filename("STATISTICS", self._data_name) + with open(os.path.join(self._prepared_data_dir, statistics_fn), "r") as f: + self._log().debug("Load statistics from: {}".format(statistics_fn)) + self._statistics = json.load(f) + + # Load word_map + word_map_fn = c.get_prepared_data_filename("WORDMAP", self._data_name) + with open(os.path.join(self._prepared_data_dir, word_map_fn), "r") as f: + self._log().debug("Load WORDMAP from: {}".format(word_map_fn)) + self._word_map = json.load(f) + + word_map_cell = self._word_map["word_map_cell"] + word_map_tag = self._word_map["word_map_tag"] + # Read image paths and captions for each image + train_image_paths = [] + train_images = [] + val_image_paths = [] + val_images = [] + test_image_paths = [] + test_images = [] + predict_images = [] + + train_image_tags = ( + [] + ) # List of list of structure tokens for each image in the train set + train_image_cells = [] + train_image_cells_len = [] + + val_image_tags = ( + [] + ) # List of list of structure tokens for each image in the train set + val_image_cells = [] + val_image_cells_len = [] + + test_image_tags = [] + test_gt = dict() + + invalid_files = 0 + total_files = 0 + + self._log().debug( + "Create lists with image filenames per split, train tags/cells and GT" + ) + with jsonlines.open(self.annotation, "r") as reader: + for img in tqdm(reader): + total_files += 1 + img_filename = img["filename"] + path = os.path.join(self._raw_data_dir, img["split"], img_filename) + + # Keep bboxes for all images + all_cell_bboxes = [] + for cell in img["html"]["cells"]: + if "bbox" not in cell: + continue + all_cell_bboxes.append(cell["bbox"]) + all_bboxes[img_filename] = all_cell_bboxes + + # if dataset does include bbox for the table itself + if "table_bbox" in img: + table_bboxes[img_filename] = img["table_bbox"] + if img["split"] == "train": + if self._purpose == s.TRAIN_PURPOSE: + # Skip invalid images + if not self.is_valid(img, self._config): + invalid_files += 1 + continue + tags = [] + cells = [] + cell_lens = [] + tags.append(img["html"]["structure"]["tokens"]) + + if self._load_cells: + for cell in img["html"]["cells"]: + cells.append(cell["tokens"]) + cell_lens.append(len(cell["tokens"]) + 2) + else: + for cell in img["html"]["cells"]: + cell_lens.append(len(cell["tokens"]) + 2) + + train_images.append(img_filename) + train_image_paths.append(path) + train_image_tags.append(tags) + train_image_cells.append(cells) + train_image_cells_len.append(cell_lens) + if img["split"] == "val": + if self._purpose == s.VAL_PURPOSE: + # Skip invalid images + if not self.is_valid(img, self._config): + invalid_files += 1 + continue + + val_tags = [] + val_cells = [] + val_cell_lens = [] + val_tags.append(img["html"]["structure"]["tokens"]) + + if self._load_cells: + for cell in img["html"]["cells"]: + val_cells.append(cell["tokens"]) + val_cell_lens.append(len(cell["tokens"]) + 2) + else: + for cell in img["html"]["cells"]: + val_cell_lens.append(len(cell["tokens"]) + 2) + + with Image.open(path) as im: + HTML, tag_len, cell_len_max = self.format_html(img) + lt1 = [">", "lcel", "ucel", "xcel"] + lt2 = img["html"]["structure"]["tokens"] + tcheck = any(item in lt1 for item in lt2) + if tcheck: + gtt = "complex" + else: + gtt = "simple" + test_gt[img_filename] = { + "html": HTML, + "tag_len": tag_len, + "cell_len_max": cell_len_max, + "width": im.width, + "height": im.height, + "type": gtt, + "html_tags": img["html"]["structure"]["tokens"], + } + + val_images.append(img_filename) + val_image_paths.append(path) + val_image_tags.append(val_tags) + val_image_cells.append(val_cells) + val_image_cells_len.append(val_cell_lens) + + elif img["split"] == "test": + if self._purpose == s.TEST_PURPOSE: + # Skip invalid images + if not self.is_valid(img, self._config): + invalid_files += 1 + continue + + with Image.open(path) as im: + HTML, tag_len, cell_len_max = self.format_html(img) + lt1 = [">", "lcel", "ucel", "xcel"] + lt2 = img["html"]["structure"]["tokens"] + tcheck = any(item in lt1 for item in lt2) + if tcheck: + gtt = "complex" + else: + gtt = "simple" + test_gt[img_filename] = { + "html": HTML, + "tag_len": tag_len, + "cell_len_max": cell_len_max, + "width": im.width, + "height": im.height, + "type": gtt, + "html_tags": img["html"]["structure"]["tokens"], + } + test_images.append(img_filename) + + test_tags = [] + test_tags.append(img["html"]["structure"]["tokens"]) + test_image_paths.append(path) + test_image_tags.append(test_tags) + else: + if self._purpose == s.PREDICT_PURPOSE: + predict_images.append(img_filename) + + image_fns = { + s.TRAIN_SPLIT: train_images, + s.VAL_SPLIT: val_images, + s.TEST_SPLIT: test_images, + } + + self._log().debug("Keep the split data pointed by the purpose") + # Images + # Filter out the images for the particual split + self._image_fns = image_fns[self._purpose] + self._dataset_size = len(self._image_fns) + assert len(self._image_fns) > 0, "Empty image split: " + self._purpose + + # Get the number of image channels + img = u.load_image(self._get_image_path(self._image_fns[0])) + if img is None: + msg = "Cannot load image" + self._log().error(msg) + raise Exception(msg) + self._img_ch = img.shape[0] + + # img_name -> list of bboxes, each bbox is a list with x1y1x2y2 + split_bboxes = {} + img_names = set(self._image_fns) # Set will speed up search + for img_name, bbox in all_bboxes.items(): + if img_name not in img_names: + continue + if img_name not in split_bboxes: + split_bboxes[img_name] = [] + # we should use extend not append, otherwise we get list within list + split_bboxes[img_name].extend(bbox) + self._bboxes = split_bboxes + self._table_bboxes = table_bboxes + # ------------------------------------------------------------------------------- + # Train specific + # ------------------------------------------------------------------------------- + # Compute encoded tags and cells + enc_tags = [] + tag_lens = [] + enc_cells = [] + cell_lens = [] + + val_enc_tags = [] + val_tag_lens = [] + val_enc_cells = [] + val_cell_lens = [] + + test_enc_tags = [] + test_tag_lens = [] + + # Based on the "purpose" + if self._purpose == s.TRAIN_PURPOSE: + self._log().debug("Convert train tags and cell tags to indices") + for i, path in enumerate(tqdm(train_image_paths)): + for tag in train_image_tags[i]: + # Encode tags + # Notice that at this point we don't have images longer than max_tag_length + # The same happens with the cell tokens + enc_tag = ( + [word_map_tag[""]] + + [ + word_map_tag.get(word, word_map_tag[""]) + for word in tag + ] + + [word_map_tag[""]] + + [word_map_tag[""]] * (self._max_tag_len - len(tag)) + ) + # Find caption lengths + tag_len = len(tag) + 2 + + enc_tags.append(enc_tag) + tag_lens.append(tag_len) + + enc_cell_seq = [] + cell_seq_len = [] + + if self._load_cells: + for cell in train_image_cells[i]: + # Encode captions + enc_cell = ( + [word_map_cell[""]] + + [ + word_map_cell.get(word, word_map_cell[""]) + for word in cell + ] + + [word_map_cell[""]] + + [word_map_cell[""]] + * (self._max_cell_len - len(cell)) + ) + enc_cell_seq.append(enc_cell) + # Find caption lengths + cell_len = len(cell) + 2 + cell_seq_len.append(cell_len) + else: + for cell in train_image_cells_len[i]: + cell_seq_len.append(cell) + enc_cells.append(enc_cell_seq) + cell_lens.append(cell_seq_len) + + if self._purpose == s.VAL_PURPOSE: + self._log().debug("Convert train tags and cell tags to indices") + for i, path in enumerate(tqdm(val_image_paths)): + for tag in val_image_tags[i]: + # Encode tags + # Notice that at this point we don't have images longer than max_tag_length + # The same happens with the cell tokens + val_enc_tag = ( + [word_map_tag[""]] + + [ + word_map_tag.get(word, word_map_tag[""]) + for word in tag + ] + + [word_map_tag[""]] + + [word_map_tag[""]] * (self._max_tag_len - len(tag)) + ) + # Find caption lengths + val_tag_len = len(tag) + 2 + + val_enc_tags.append(val_enc_tag) + val_tag_lens.append(val_tag_len) + + val_enc_cell_seq = [] + val_cell_seq_len = [] + + if self._load_cells: + for cell in val_image_cells[i]: + # Encode captions + val_enc_cell = ( + [word_map_cell[""]] + + [ + word_map_cell.get(word, word_map_cell[""]) + for word in cell + ] + + [word_map_cell[""]] + + [word_map_cell[""]] + * (self._max_cell_len - len(cell)) + ) + val_enc_cell_seq.append(val_enc_cell) + + # Find caption lengths + cell_len = len(cell) + 2 + val_cell_seq_len.append(cell_len) + else: + for cell in val_image_cells_len[i]: + val_cell_seq_len.append(cell) + val_enc_cells.append(val_enc_cell_seq) + val_cell_lens.append(val_cell_seq_len) + + if self._purpose == s.TEST_PURPOSE: + self._log().debug("Convert val tags to indices") + for i, path in enumerate(tqdm(test_image_paths)): + for tag in test_image_tags[i]: + # Encode tags + # Notice that at this point we don't have images longer than max_tag_length + # The same happens with the cell tokens + test_enc_tag = ( + [word_map_tag[""]] + + [ + word_map_tag.get(word, word_map_tag[""]) + for word in tag + ] + + [word_map_tag[""]] + + [word_map_tag[""]] * (self._max_tag_len - len(tag)) + ) + + # Find caption lengths + test_tag_len = len(tag) + 2 + + test_enc_tags.append(test_enc_tag) + test_tag_lens.append(test_tag_len) + + self._tags = enc_tags + self._taglens = tag_lens + self._cells = enc_cells + self._cell_lens = cell_lens + + # ------------------------------------------------------------------------------- + # val specific + # ------------------------------------------------------------------------------- + self._val_tags = val_enc_tags + self._val_taglens = val_tag_lens + self._val_cells = val_enc_cells + self._val_cell_lens = val_cell_lens + # ------------------------------------------------------------------------------- + # test / evaluation specific + # ------------------------------------------------------------------------------- + self._test = test_gt + self._test_tags = test_enc_tags + self._test_taglens = test_tag_lens diff --git a/docling_ibm_models/tableformer/data_management/tf_predictor.py b/docling_ibm_models/tableformer/data_management/tf_predictor.py new file mode 100644 index 0000000..0be5503 --- /dev/null +++ b/docling_ibm_models/tableformer/data_management/tf_predictor.py @@ -0,0 +1,1020 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import json +import logging +import os +from itertools import groupby + +import cv2 +import numpy as np +import torch + +import docling_ibm_models.tableformer.common as c +import docling_ibm_models.tableformer.data_management.functional as F +import docling_ibm_models.tableformer.data_management.transforms as T +import docling_ibm_models.tableformer.settings as s +import docling_ibm_models.tableformer.utils.utils as u +from docling_ibm_models.tableformer.data_management.matching_post_processor import ( + MatchingPostProcessor, +) +from docling_ibm_models.tableformer.data_management.tf_cell_matcher import CellMatcher +from docling_ibm_models.tableformer.models.common.base_model import BaseModel +from docling_ibm_models.tableformer.otsl import otsl_to_html +from docling_ibm_models.tableformer.utils.app_profiler import AggProfiler + +# LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG +LOG_LEVEL = logging.WARN + + +class bcolors: + HEADER = "\033[95m" + OKBLUE = "\033[94m" + OKCYAN = "\033[96m" + OKGREEN = "\033[92m" + WARNING = "\033[93m" + FAIL = "\033[91m" + ENDC = "\033[0m" + BOLD = "\033[1m" + UNDERLINE = "\033[4m" + + +def otsl_sqr_chk(rs_list, logdebug): + rs_list_split = [ + list(group) for k, group in groupby(rs_list, lambda x: x == "nl") if not k + ] + isSquare = True + if len(rs_list_split) > 0: + init_tag_len = len(rs_list_split[0]) + 1 + + totcelnum = rs_list.count("fcel") + rs_list.count("ecel") + if logdebug: + print("Total number of cells = {}".format(totcelnum)) + + for ind, ln in enumerate(rs_list_split): + ln.append("nl") + if logdebug: + print("{}".format(ln)) + if len(ln) != init_tag_len: + isSquare = False + if isSquare: + if logdebug: + print( + "{}*OK* Table is square! *OK*{}".format( + bcolors.OKGREEN, bcolors.ENDC + ) + ) + else: + if logdebug: + err_name = "{}***** ERR ******{}" + print(err_name.format(bcolors.FAIL, bcolors.ENDC)) + print( + "{}*ERR* Table is not square! *ERR*{}".format( + bcolors.FAIL, bcolors.ENDC + ) + ) + return isSquare + + +def decide_device(config: dict) -> str: + r""" + Decide the inference device based on the "predict.device_mode" parameter + """ + device_mode = config["predict"].get("device_mode", "cpu") + num_gpus = torch.cuda.device_count() + + if device_mode == "auto": + device = "cuda:0" if num_gpus > 0 else "cpu" + elif device_mode in ["gpu", "cuda"]: + device = "cuda:0" + else: + device = "cpu" + return device + + +class TFPredictor: + r""" + Table predictions for the in-memory Docling API + """ + + def __init__(self, config): + r""" + Parameters + ---------- + config : dict + Parameters configuration + Raises + ------ + ValueError + When the model cannot be found + """ + self._device = decide_device(config) + self._log().info("Running on device: {}".format(self._device)) + + self._config = config + self.enable_post_process = True + + self._padding = config["predict"].get("padding", False) + self._padding_size = config["predict"].get("padding_size", 10) + + self._cell_matcher = CellMatcher(config) + self._post_processor = MatchingPostProcessor(config) + + self._init_word_map() + # Load the model + self._model = self._load_model() + self._model.eval() + self._prof = config["predict"].get("profiling", False) + self._profiling_agg_window = config["predict"].get("profiling_agg_window", None) + if self._profiling_agg_window is not None: + AggProfiler(self._profiling_agg_window) + else: + AggProfiler() + + def _init_word_map(self): + self._prepared_data_dir = c.safe_get_parameter( + self._config, ["dataset", "prepared_data_dir"], required=False + ) + + if self._prepared_data_dir is None: + self._word_map = c.safe_get_parameter( + self._config, ["dataset_wordmap"], required=True + ) + else: + data_name = c.safe_get_parameter( + self._config, ["dataset", "name"], required=True + ) + word_map_fn = c.get_prepared_data_filename("WORDMAP", data_name) + + # Load word_map + with open(os.path.join(self._prepared_data_dir, word_map_fn), "r") as f: + self._log().debug("Load WORDMAP from: {}".format(word_map_fn)) + self._word_map = json.load(f) + + self._init_data = {"word_map": self._word_map} + # Prepare a reversed index for the word map + self._rev_word_map = {v: k for k, v in self._word_map["word_map_tag"].items()} + + def get_init_data(self): + r""" + Return the initialization data + """ + return self._init_data + + def get_model(self): + r""" + Return the loaded model + """ + return self._model + + def _load_model(self): + r""" + Load the proper model + """ + + self._model_type = self._config["model"]["type"] + # Added import here to avoid loading turbotransformer library unnecessarily + if self._model_type == "TableModel04_rs": + from docling_ibm_models.tableformer.models.table04_rs.tablemodel04_rs import ( # noqa + TableModel04_rs, + ) + for candidate in BaseModel.__subclasses__(): + if candidate.__name__ == self._model_type: + model = candidate( + self._config, self._init_data, s.PREDICT_PURPOSE, self._device + ) + + if model is None: + err_msg = "Not able to initiate a model for {}".format(self._model_type) + self._log().error(err_msg) + raise ValueError(err_msg) + + self._remove_padding = False + if self._model_type == "TableModel02": + self._remove_padding = True + + # Load model from checkpoint + success, _, _, _, _ = model.load() + if not success: + err_msg = "Cannot load the model" + self._log().error(err_msg) + raise ValueError(err_msg) + + return model + + def get_device(self): + return self._device + + def get_model_type(self): + return self._model_type + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def _deletebbox(self, listofbboxes, index): + newlist = [] + for i in range(len(listofbboxes)): + bbox = listofbboxes[i] + if i not in index: + newlist.append(bbox) + return newlist + + def _remove_bbox_span_desync(self, prediction): + # Delete 1 extra bbox after span tag + index_to_delete_from = 0 + indexes_to_delete = [] + newbboxes = [] + for html_elem in prediction["html_seq"]: + if html_elem == "": + index_to_delete_from += 1 + if html_elem == ">": + index_to_delete_from += 1 + # remove element from bboxes + self._log().debug( + "========= DELETE BBOX INDEX: {}".format(index_to_delete_from) + ) + indexes_to_delete.append(index_to_delete_from) + + newbboxes = self._deletebbox(prediction["bboxes"], indexes_to_delete) + return newbboxes + + def _check_bbox_sync(self, prediction): + bboxes = [] + match = False + # count bboxes + count_bbox = len(prediction["bboxes"]) + # count td tags + count_td = 0 + for html_elem in prediction["html_seq"]: + if html_elem == "" or html_elem == ">": + count_td += 1 + if html_elem in ["fcel", "ecel", "ched", "rhed", "srow"]: + count_td += 1 + self._log().debug( + "======================= PREDICTED BBOXES: {}".format(count_bbox) + ) + self._log().debug( + "======================= PREDICTED CELLS: {}".format(count_td) + ) + if count_bbox != count_td: + bboxes = self._remove_bbox_span_desync(prediction) + else: + bboxes = prediction["bboxes"] + match = True + return match, bboxes + + def page_coords_to_table_coords(self, bbox, table_bbox, im_width, im_height): + r""" + Transforms given bbox from page coordinate system into table image coordinate system + + Parameters + ---------- + bbox : list + bbox to transform in page coordinates + table_bbox : list + table bbox, in page coordinates + im_width : integer + width of an image with rendered table (in pixels) + im_height : integer + height of an image height rendered table (in pixels) + + Returns + ------- + bbox: list + bbox with transformed coordinates + """ + # Coordinates of given bbox + x1 = bbox[0] + y1 = bbox[1] + x2 = bbox[2] + y2 = bbox[3] + + # Coordinates of table bbox + t_x1 = table_bbox[0] + t_y1 = table_bbox[1] + t_x2 = table_bbox[2] + t_y2 = table_bbox[3] + + # Table width / height + tw = t_x2 - t_x1 + th = t_y2 - t_y1 + new_bbox = [0, 0, 0, 0] + # Flip corners, substract table coordinates and rescale to new image size + new_bbox[0] = im_width * (x1 - t_x1) / tw + new_bbox[1] = im_height * (t_y2 - y2) / th + new_bbox[2] = im_width * (x2 - t_x1) / tw + new_bbox[3] = im_height * (t_y2 - y1) / th + + return new_bbox + + def _depad_bboxes(self, bboxes, new_image_ratio): + r""" + Removes padding from predicted bboxes for previously padded image + + Parameters + ---------- + bboxes : list of lists + list of bboxes that have to be recalculated to remove implied padding + new_image_ratio : float + Ratio of padded image size to the original image size + + Returns + ------- + new_bboxes: list + bboxes with transformed coordinates + """ + new_bboxes = [] + c_x = 0.5 + c_y = 0.5 + + self._log().debug("PREDICTED BBOXES: {}".format(bboxes)) + self._log().debug("new_image_ratio: {}".format(new_image_ratio)) + + for bbox in bboxes: + # 1. corner coords -> center coords + cb_x1 = bbox[0] - c_x + cb_y1 = bbox[1] - c_y + cb_x2 = bbox[2] - c_x + cb_y2 = bbox[3] - c_y + + # 2. center coords * new_image_ratio + r_cb_x1 = cb_x1 * new_image_ratio + r_cb_y1 = cb_y1 * new_image_ratio + r_cb_x2 = cb_x2 * new_image_ratio + r_cb_y2 = cb_y2 * new_image_ratio + + # 3. center coords -> corner coords + x1 = r_cb_x1 + c_x + y1 = r_cb_y1 + c_y + x2 = r_cb_x2 + c_x + y2 = r_cb_y2 + c_y + + x1 = np.clip(x1, 0.0, 1.0) + y1 = np.clip(y1, 0.0, 1.0) + x2 = np.clip(x2, 0.0, 1.0) + y2 = np.clip(y2, 0.0, 1.0) + + new_bbox = [x1, y1, x2, y2] + new_bboxes.append(new_bbox) + + self._log().debug("DEPAD BBOXES: {}".format(new_bboxes)) + + return new_bboxes + + def _pad_image(self, iocr_page): + r""" + Adds padding to the image + + Parameters + ---------- + iocr_page : dict + Docling provided table data + + Returns + ------- + new_im: PIL image + new, padded image + new_image_ratio : float + Ratio of padded image size to the original image size + """ + _, old_iw, old_ih = iocr_page["image"].shape + + margin_i = self._padding_size # pixels + + desired_iw = old_iw + (margin_i * 2) + desired_ih = old_ih + (margin_i * 2) + + # Ratio of new image size to the original image size + new_image_ratio = desired_iw / old_iw + + bcolor = (255, 255, 255) + # Create empty canvas of background color and desired size + padded_image = F.pad( + iocr_page["image"], + (desired_iw, desired_ih, desired_iw, desired_ih), + fill=bcolor, + ) + return padded_image, new_image_ratio + + def _pre_process_image(self, iocr_page): + r""" + Pre-process table image in memory, before doing prediction + Currently just removes from the image separate PDF cells that only contain "$" sign + This is done to remove model confusion when dealing with financial reports + + Parameters + ---------- + iocr_page : dict + Docling provided table data + + Returns + ------- + iocr_page["image"] : PIL image + updated table image with "$" repainted + new_image_ratio : float + Ratio of padded image size to the original image size + """ + + new_image_ratio = 1.0 + + ic, iw, ih = iocr_page["image"].shape + + return iocr_page["image"], new_image_ratio + + def _merge_tf_output(self, docling_output, pdf_cells): + tf_output = [] + tf_cells_map = {} + max_row_idx = 0 + + for docling_item in docling_output: + r_idx = str(docling_item["start_row_offset_idx"]) + c_idx = str(docling_item["start_col_offset_idx"]) + cell_key = c_idx + "_" + r_idx + if cell_key in tf_cells_map: + for pdf_cell in pdf_cells: + if pdf_cell["id"] == docling_item["cell_id"]: + text_cell_bbox = { + "b": pdf_cell["bbox"][1], + "l": pdf_cell["bbox"][0], + "r": pdf_cell["bbox"][2], + "t": pdf_cell["bbox"][3], + "token": pdf_cell["text"], + } + tf_cells_map[cell_key]["text_cell_bboxes"].append( + text_cell_bbox + ) + else: + tf_cells_map[cell_key] = { + "bbox": docling_item["bbox"], + "row_span": docling_item["row_span"], + "col_span": docling_item["col_span"], + "start_row_offset_idx": docling_item["start_row_offset_idx"], + "end_row_offset_idx": docling_item["end_row_offset_idx"], + "start_col_offset_idx": docling_item["start_col_offset_idx"], + "end_col_offset_idx": docling_item["end_col_offset_idx"], + "indentation_level": docling_item["indentation_level"], + "text_cell_bboxes": [], + "column_header": docling_item["column_header"], + "row_header": docling_item["row_header"], + "row_section": docling_item["row_section"], + } + + if docling_item["start_row_offset_idx"] > max_row_idx: + max_row_idx = docling_item["start_row_offset_idx"] + + for pdf_cell in pdf_cells: + if pdf_cell["id"] == docling_item["cell_id"]: + text_cell_bbox = { + "b": pdf_cell["bbox"][1], + "l": pdf_cell["bbox"][0], + "r": pdf_cell["bbox"][2], + "t": pdf_cell["bbox"][3], + "token": pdf_cell["text"], + } + tf_cells_map[cell_key]["text_cell_bboxes"].append( + text_cell_bbox + ) + + for k in tf_cells_map: + tf_output.append(tf_cells_map[k]) + return tf_output + + def resize_img(self, image, width=None, height=None, inter=cv2.INTER_AREA): + # initialize the dimensions of the image to be resized and + # grab the image size + dim = None + (h, w) = image.shape[:2] + sf = 1.0 + # if both the width and height are None, then return the + # original image + if width is None and height is None: + return image, sf + # check to see if the width is None + if width is None: + # calculate the ratio of the height and construct the + # dimensions + r = height / float(h) + sf = r + dim = (int(w * r), height) + # otherwise, the height is None + else: + # calculate the ratio of the width and construct the + # dimensions + r = width / float(w) + sf = r + dim = (width, int(h * r)) + # resize the image + resized = cv2.resize(image, dim, interpolation=inter) + # return the resized image + return resized, sf + + def multi_table_predict(self, iocr_page, table_bboxes, do_matching=True): + # def multi_table_predict(self, iocr_page, page_image, table_bboxes): + multi_tf_output = [] + page_image = iocr_page["image"] + + # Prevent large image submission, by resizing input + page_image_resized, scale_factor = self.resize_img(page_image, height=1024) + + for table_bbox in table_bboxes: + # Downscale table bounding box to the size of new image + table_bbox[0] = table_bbox[0] * scale_factor + table_bbox[1] = table_bbox[1] * scale_factor + table_bbox[2] = table_bbox[2] * scale_factor + table_bbox[3] = table_bbox[3] * scale_factor + + table_image = page_image_resized[ + round(table_bbox[1]) : round(table_bbox[3]), + round(table_bbox[0]) : round(table_bbox[2]), + ] + # table_image = page_image + # Predict + if do_matching: + tf_responses, predict_details = self.predict( + iocr_page, table_bbox, table_image, scale_factor, None + ) + else: + tf_responses, predict_details = self.predict_dummy( + iocr_page, table_bbox, table_image, scale_factor, None + ) + + # ====================================================================================== + # PROCESS PREDICTED RESULTS, TO TURN PREDICTED COL/ROW IDs into Indexes + # Indexes should be in increasing order, without gaps + + # Fix col/row indexes + # Arranges all col/row indexes sequentially without gaps using input IDs + + indexing_start_cols = [] # Index of original start col IDs (not indexes) + indexing_end_cols = [] # Index of original end col IDs (not indexes) + indexing_start_rows = [] # Index of original start row IDs (not indexes) + indexing_end_rows = [] # Index of original end row IDs (not indexes) + + # First, collect all possible predicted IDs, to be used as indexes + # ID's returned by Tableformer are sequential, but might contain gaps + for tf_response_cell in tf_responses: + start_col_offset_idx = tf_response_cell["start_col_offset_idx"] + end_col_offset_idx = tf_response_cell["end_col_offset_idx"] + start_row_offset_idx = tf_response_cell["start_row_offset_idx"] + end_row_offset_idx = tf_response_cell["end_row_offset_idx"] + + # Collect all possible col/row IDs: + if start_col_offset_idx not in indexing_start_cols: + indexing_start_cols.append(start_col_offset_idx) + if end_col_offset_idx not in indexing_end_cols: + indexing_end_cols.append(end_col_offset_idx) + if start_row_offset_idx not in indexing_start_rows: + indexing_start_rows.append(start_row_offset_idx) + if end_row_offset_idx not in indexing_end_rows: + indexing_end_rows.append(end_row_offset_idx) + + indexing_start_cols.sort() + indexing_end_cols.sort() + indexing_start_rows.sort() + indexing_end_rows.sort() + + # After this - put actual indexes of IDs back into predicted structure... + for tf_response_cell in tf_responses: + tf_response_cell["start_col_offset_idx"] = indexing_start_cols.index( + tf_response_cell["start_col_offset_idx"] + ) + tf_response_cell["end_col_offset_idx"] = ( + tf_response_cell["start_col_offset_idx"] + + tf_response_cell["col_span"] + ) + tf_response_cell["start_row_offset_idx"] = indexing_start_rows.index( + tf_response_cell["start_row_offset_idx"] + ) + tf_response_cell["end_row_offset_idx"] = ( + tf_response_cell["start_row_offset_idx"] + + tf_response_cell["row_span"] + ) + # Counting matched cols/rows from actual indexes (and not ids) + predict_details["num_cols"] = len(indexing_end_cols) + predict_details["num_rows"] = len(indexing_end_rows) + # Put results into multi_tf_output + multi_tf_output.append( + {"tf_responses": tf_responses, "predict_details": predict_details} + ) + # Upscale table bounding box back, for visualization purposes + table_bbox[0] = table_bbox[0] / scale_factor + table_bbox[1] = table_bbox[1] / scale_factor + table_bbox[2] = table_bbox[2] / scale_factor + table_bbox[3] = table_bbox[3] / scale_factor + # Return grouped results of predictions + return multi_tf_output + + def predict_dummy( + self, iocr_page, table_bbox, table_image, scale_factor, eval_res_preds=None + ): + r""" + Predict the table out of an image in memory + + Parameters + ---------- + iocr_page : dict + Docling provided table data + eval_res_preds : dict + Ready predictions provided by the evaluation results + + Returns + ------- + docling_output : string + json response formatted according to Docling api expectations + + matching_details : string + json with details about the matching between the pdf cells and the table cells + """ + AggProfiler().start_agg(self._prof) + + max_steps = self._config["predict"]["max_steps"] + beam_size = self._config["predict"]["beam_size"] + image_batch = self._prepare_image(table_image) + # Make predictions + prediction = {} + + with torch.no_grad(): + # Compute predictions + if ( + eval_res_preds is not None + ): # Don't run the model, use the provided predictions + prediction["bboxes"] = eval_res_preds["bboxes"] + pred_tag_seq = eval_res_preds["tag_seq"] + elif self._config["predict"]["bbox"]: + pred_tag_seq, outputs_class, outputs_coord = self._model.predict( + image_batch, max_steps, beam_size + ) + + if outputs_coord is not None: + bbox_pred = u.box_cxcywh_to_xyxy(outputs_coord) + prediction["bboxes"] = bbox_pred.tolist() + else: + prediction["bboxes"] = [] + if outputs_class is not None: + result_class = torch.argmax(outputs_class, dim=1) + prediction["classes"] = result_class.tolist() + else: + prediction["classes"] = [] + if self._remove_padding: + pred_tag_seq, _ = u.remove_padding(pred_tag_seq) + else: + pred_tag_seq, _, _ = self._model.predict( + image_batch, max_steps, beam_size + ) + # Check if padding should be removed + if self._remove_padding: + pred_tag_seq, _ = u.remove_padding(pred_tag_seq) + + prediction["tag_seq"] = pred_tag_seq + prediction["rs_seq"] = self._get_html_tags(pred_tag_seq) + prediction["html_seq"] = otsl_to_html(prediction["rs_seq"], False) + # Remove implied padding from bbox predictions, + # that we added on image pre-processing stage + self._log().debug("----- rs_seq -----") + self._log().debug(prediction["rs_seq"]) + self._log().debug(len(prediction["rs_seq"])) + otsl_sqr_chk(prediction["rs_seq"], False) + + # Check that bboxes are in sync with predicted tags + sync, corrected_bboxes = self._check_bbox_sync(prediction) + if not sync: + prediction["bboxes"] = corrected_bboxes + + # Match the cells + matching_details = {"table_cells": [], "matches": {}} + + # Table bbox upscaling will scale predicted bboxes too within cell matcher + scaled_table_bbox = [ + table_bbox[0] / scale_factor, + table_bbox[1] / scale_factor, + table_bbox[2] / scale_factor, + table_bbox[3] / scale_factor, + ] + + if len(prediction["bboxes"]) > 0: + matching_details = self._cell_matcher.match_cells_dummy( + iocr_page, scaled_table_bbox, prediction + ) + # Generate the expected Docling responses + AggProfiler().begin("generate_docling_response", self._prof) + docling_output = self._generate_tf_response_dummy( + matching_details["table_cells"] + ) + + AggProfiler().end("generate_docling_response", self._prof) + # Add the docling_output sorted by cell_id into the matching_details + docling_output.sort(key=lambda item: item["cell_id"]) + matching_details["docling_responses"] = docling_output + # Merge docling_output and pdf_cells into one TF output, + # with deduplicated table cells + # tf_output = self._merge_tf_output_dummy(docling_output) + tf_output = docling_output + + return tf_output, matching_details + + def predict( + self, iocr_page, table_bbox, table_image, scale_factor, eval_res_preds=None + ): + r""" + Predict the table out of an image in memory + + Parameters + ---------- + iocr_page : dict + Docling provided table data + eval_res_preds : dict + Ready predictions provided by the evaluation results + + Returns + ------- + docling_output : string + json response formatted according to Docling api expectations + + matching_details : string + json with details about the matching between the pdf cells and the table cells + """ + AggProfiler().start_agg(self._prof) + + max_steps = self._config["predict"]["max_steps"] + beam_size = self._config["predict"]["beam_size"] + image_batch = self._prepare_image(table_image) + # Make predictions + prediction = {} + + with torch.no_grad(): + # Compute predictions + if ( + eval_res_preds is not None + ): # Don't run the model, use the provided predictions + prediction["bboxes"] = eval_res_preds["bboxes"] + pred_tag_seq = eval_res_preds["tag_seq"] + elif self._config["predict"]["bbox"]: + pred_tag_seq, outputs_class, outputs_coord = self._model.predict( + image_batch, max_steps, beam_size + ) + + if outputs_coord is not None: + bbox_pred = u.box_cxcywh_to_xyxy(outputs_coord) + prediction["bboxes"] = bbox_pred.tolist() + else: + prediction["bboxes"] = [] + if outputs_class is not None: + result_class = torch.argmax(outputs_class, dim=1) + prediction["classes"] = result_class.tolist() + else: + prediction["classes"] = [] + if self._remove_padding: + pred_tag_seq, _ = u.remove_padding(pred_tag_seq) + else: + pred_tag_seq, _, _ = self._model.predict( + image_batch, max_steps, beam_size + ) + # Check if padding should be removed + if self._remove_padding: + pred_tag_seq, _ = u.remove_padding(pred_tag_seq) + + prediction["tag_seq"] = pred_tag_seq + prediction["rs_seq"] = self._get_html_tags(pred_tag_seq) + prediction["html_seq"] = otsl_to_html(prediction["rs_seq"], False) + # Remove implied padding from bbox predictions, + # that we added on image pre-processing stage + self._log().debug("----- rs_seq -----") + self._log().debug(prediction["rs_seq"]) + self._log().debug(len(prediction["rs_seq"])) + otsl_sqr_chk(prediction["rs_seq"], False) + + sync, corrected_bboxes = self._check_bbox_sync(prediction) + if not sync: + prediction["bboxes"] = corrected_bboxes + + # Match the cells + matching_details = {"table_cells": [], "matches": {}} + + # Table bbox upscaling will scale predicted bboxes too within cell matcher + scaled_table_bbox = [ + table_bbox[0] / scale_factor, + table_bbox[1] / scale_factor, + table_bbox[2] / scale_factor, + table_bbox[3] / scale_factor, + ] + + if len(prediction["bboxes"]) > 0: + matching_details = self._cell_matcher.match_cells( + iocr_page, scaled_table_bbox, prediction + ) + # Post-processing + if len(prediction["bboxes"]) > 0: + if self.enable_post_process: + AggProfiler().begin("post_process", self._prof) + matching_details = self._post_processor.process(matching_details) + AggProfiler().end("post_process", self._prof) + + # Generate the expected Docling responses + AggProfiler().begin("generate_docling_response", self._prof) + docling_output = self._generate_tf_response( + matching_details["table_cells"], + matching_details["matches"], + ) + + AggProfiler().end("generate_docling_response", self._prof) + # Add the docling_output sorted by cell_id into the matching_details + docling_output.sort(key=lambda item: item["cell_id"]) + matching_details["docling_responses"] = docling_output + + # Merge docling_output and pdf_cells into one TF output, + # with deduplicated table cells + tf_output = self._merge_tf_output(docling_output, matching_details["pdf_cells"]) + + return tf_output, matching_details + + def _generate_tf_response_dummy(self, table_cells): + tf_cell_list = [] + + for table_cell in table_cells: + colspan_val = 1 + if "colspan_val" in table_cell: + colspan_val = table_cell["colspan_val"] + rowspan_val = 1 + if "rowspan_val" in table_cell: + rowspan_val = table_cell["rowspan_val"] + + column_header = False + if table_cell["label"] == "ched": + column_header = True + + row_header = False + if table_cell["label"] == "rhed": + row_header = True + + row_section = False + if table_cell["label"] == "srow": + row_section = True + + row_id = table_cell["row_id"] + column_id = table_cell["column_id"] + + cell_bbox = { + "b": table_cell["bbox"][3], + "l": table_cell["bbox"][0], + "r": table_cell["bbox"][2], + "t": table_cell["bbox"][1], + "token": "", + } + + tf_cell = { + "cell_id": table_cell["cell_id"], + "bbox": cell_bbox, # b,l,r,t,token + "row_span": rowspan_val, + "col_span": colspan_val, + "start_row_offset_idx": row_id, + "end_row_offset_idx": row_id + rowspan_val, + "start_col_offset_idx": column_id, + "end_col_offset_idx": column_id + colspan_val, + "indentation_level": 0, + # No text cell bboxes, because no matching was done + "text_cell_bboxes": [], + "column_header": column_header, + "row_header": row_header, + "row_section": row_section, + } + tf_cell_list.append(tf_cell) + return tf_cell_list + + def _generate_tf_response(self, table_cells, matches): + r""" + Convert the matching details to the expected output for Docling + + Parameters + ---------- + table_cells : list of dict + Each value is a dictionary with keys: "cell_id", "row_id", "column_id", + "bbox", "label", "class" + matches : dictionary of lists of table_cells + A dictionary which is indexed by the pdf_cell_id as key and the value is a list + of the table_cells that fall inside that pdf cell + + Returns + ------- + docling_output : string + json response formatted according to Docling api expectations + """ + + # format output to look similar to tests/examples/tf_gte_output_2.json + tf_cell_list = [] + for pdf_cell_id, pdf_cell_matches in matches.items(): + tf_cell = { + "bbox": {}, # b,l,r,t,token + "row_span": 1, + "col_span": 1, + "start_row_offset_idx": -1, + "end_row_offset_idx": -1, + "start_col_offset_idx": -1, + "end_col_offset_idx": -1, + "indentation_level": 0, + # return text cell bboxes additionally to the matched index + "text_cell_bboxes": [{}], # b,l,r,t,token + "column_header": False, + "row_header": False, + "row_section": False, + } + tf_cell["cell_id"] = int(pdf_cell_id) + + row_ids = set() + column_ids = set() + labels = set() + + for match in pdf_cell_matches: + tm = match["table_cell_id"] + tcl = list( + filter(lambda table_cell: table_cell["cell_id"] == tm, table_cells) + ) + if len(tcl) > 0: + table_cell = tcl[0] + row_ids.add(table_cell["row_id"]) + column_ids.add(table_cell["column_id"]) + labels.add(table_cell["label"]) + + if table_cell["label"] is not None: + if table_cell["label"] in ["ched"]: + tf_cell["column_header"] = True + if table_cell["label"] in ["rhed"]: + tf_cell["row_header"] = True + if table_cell["label"] in ["srow"]: + tf_cell["row_section"] = True + + tf_cell["start_col_offset_idx"] = table_cell["column_id"] + tf_cell["end_col_offset_idx"] = table_cell["column_id"] + 1 + tf_cell["start_row_offset_idx"] = table_cell["row_id"] + tf_cell["end_row_offset_idx"] = table_cell["row_id"] + 1 + + if "colspan_val" in table_cell: + tf_cell["col_span"] = table_cell["colspan_val"] + tf_cell["start_col_offset_idx"] = table_cell["column_id"] + off_idx = table_cell["column_id"] + tf_cell["col_span"] + tf_cell["end_col_offset_idx"] = off_idx + if "rowspan_val" in table_cell: + tf_cell["row_span"] = table_cell["rowspan_val"] + tf_cell["start_row_offset_idx"] = table_cell["row_id"] + tf_cell["end_row_offset_idx"] = ( + table_cell["row_id"] + tf_cell["row_span"] + ) + if "bbox" in table_cell: + table_match_bbox = table_cell["bbox"] + tf_bbox = { + "b": table_match_bbox[3], + "l": table_match_bbox[0], + "r": table_match_bbox[2], + "t": table_match_bbox[1], + } + tf_cell["bbox"] = tf_bbox + + tf_cell["row_ids"] = list(row_ids) + tf_cell["column_ids"] = list(column_ids) + tf_cell["label"] = "None" + l_labels = list(labels) + if len(l_labels) > 0: + tf_cell["label"] = l_labels[0] + tf_cell_list.append(tf_cell) + return tf_cell_list + + def _prepare_image(self, mat_image): + r""" + Rescale the image and prepare a batch of 1 with the image as as tensor + + Parameters + ---------- + mat_image: cv2.Mat + The image as an openCV Mat object + + Returns + ------- + tensor (batch_size, image_channels, resized_image, resized_image) + """ + normalize = T.Normalize( + mean=self._config["dataset"]["image_normalization"]["mean"], + std=self._config["dataset"]["image_normalization"]["std"], + ) + resized_size = self._config["dataset"]["resized_image"] + resize = T.Resize([resized_size, resized_size]) + + img, _ = normalize(mat_image, None) + img, _ = resize(img, None) + + img = img.transpose(2, 1, 0) # (channels, width, height) + img = torch.FloatTensor(img / 255.0) + image_batch = img.unsqueeze(dim=0) + image_batch = image_batch.to(device=self._device) + return image_batch + + def _get_html_tags(self, seq): + r""" + Convert indices to actual html tags + + """ + # Map the tag indices back to actual tags (without start, end) + html_tags = [self._rev_word_map[ind] for ind in seq[1:-1]] + + return html_tags diff --git a/docling_ibm_models/tableformer/data_management/transforms.py b/docling_ibm_models/tableformer/data_management/transforms.py new file mode 100644 index 0000000..4166add --- /dev/null +++ b/docling_ibm_models/tableformer/data_management/transforms.py @@ -0,0 +1,396 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +from __future__ import division + +import collections +import numbers +import random + +import torch + +from docling_ibm_models.tableformer.data_management import functional as F + + +def box_cxcywh_to_xyxy(x): + x_c, y_c, w, h = x.unbind(-1) + b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)] + return torch.stack(b, dim=-1) + + +def box_xyxy_to_cxcywh(x): + x0, y0, x1, y1 = x.unbind(-1) + b = [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0), (y1 - y0)] + return torch.stack(b, dim=-1) + + +class Lambda(object): + """Apply a user-defined lambda as a transform. + Attention: The multiprocessing used in dataloader of pytorch + is not friendly with lambda function in Windows + Args: + lambd (function): Lambda/function to be used for transform. + """ + + def __init__(self, lambd): + # assert isinstance(lambd, types.LambdaType) + self.lambd = lambd + # if 'Windows' in platform.system(): + # raise RuntimeError("Can't pickle lambda funciton in windows system") + + def __call__(self, img): + return self.lambd(img) + + def __repr__(self): + return self.__class__.__name__ + "()" + + +class RandomTransforms(object): + """Base class for a list of transformations with randomness + Args: + transforms (list or tuple): list of transformations + """ + + def __init__(self, transforms): + assert isinstance(transforms, (list, tuple)) + self.transforms = transforms + + def __call__(self, *args, **kwargs): + raise NotImplementedError() + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + for t in self.transforms: + format_string += "\n" + format_string += " {0}".format(t) + format_string += "\n)" + return format_string + + +class RandomChoice(RandomTransforms): + """Apply single transformation randomly picked from a list""" + + def __call__(self, img, target): + t = random.choice(self.transforms) + return t(img, target) + + +class RandomCrop(object): + def __init__(self, size, margin_crop): + self.size = list(size) + self.margin_crop = list(margin_crop) + # margin_crop: w, h + + def __call__(self, img, target): + # img (w,h,ch) + image_height, image_width = img.shape[0], img.shape[1] + """ + img (np.ndarray): Image to be cropped. + x: Upper pixel coordinate. + y: Left pixel coordinate. + h: Height of the cropped image. + w: Width of the cropped image. + """ + if image_width > 0 and image_height > 0: + cropped_image = F.crop( + img, + self.margin_crop[1], + self.margin_crop[0], + image_height - (self.margin_crop[1] * 2), + image_width - (self.margin_crop[0] * 2), + ) + + target_ = target.copy() + target_["boxes"][:, 0] = target_["boxes"][:, 0] - self.margin_crop[0] + target_["boxes"][:, 1] = target_["boxes"][:, 1] - self.margin_crop[1] + target_["boxes"][:, 2] = target_["boxes"][:, 2] - self.margin_crop[0] + target_["boxes"][:, 3] = target_["boxes"][:, 3] - self.margin_crop[1] + else: + cropped_image = img + return cropped_image, target_ + + +class RandomPad(object): + def __init__(self, max_pad): + self.max_pad = max_pad + + def __call__(self, img, target): + pad_x = random.randint(0, self.max_pad) + pad_y = random.randint(0, self.max_pad) + pad_x1 = random.randint(0, self.max_pad) + pad_y1 = random.randint(0, self.max_pad) + img = img.copy() + padded_image = F.pad(img, (pad_x, pad_y, pad_x1, pad_y1), fill=(255, 255, 255)) + target_ = target.copy() + if target["boxes"] is not None: + target_["boxes"][:, 0] = target_["boxes"][:, 0] + pad_x + target_["boxes"][:, 1] = target_["boxes"][:, 1] + pad_y + target_["boxes"][:, 2] = target_["boxes"][:, 2] + pad_x + target_["boxes"][:, 3] = target_["boxes"][:, 3] + pad_y + return padded_image, target_ + + +class ColorJitter(object): + """Randomly change the brightness, contrast and saturation of an image. + Args: + brightness (float): How much to jitter brightness. brightness_factor + is chosen uniformly from [max(0, 1 - brightness), 1 + brightness]. + contrast (float): How much to jitter contrast. contrast_factor + is chosen uniformly from [max(0, 1 - contrast), 1 + contrast]. + saturation (float): How much to jitter saturation. saturation_factor + is chosen uniformly from [max(0, 1 - saturation), 1 + saturation]. + hue(float): How much to jitter hue. hue_factor is chosen uniformly from + [-hue, hue]. Should be >=0 and <= 0.5. + """ + + def __init__(self, brightness=0, contrast=0, saturation=0, hue=0): + + assert isinstance(brightness, float) or ( + isinstance(brightness, collections.Iterable) and len(brightness) == 2 + ) + assert isinstance(contrast, float) or ( + isinstance(contrast, collections.Iterable) and len(contrast) == 2 + ) + assert isinstance(saturation, float) or ( + isinstance(saturation, collections.Iterable) and len(saturation) == 2 + ) + assert isinstance(hue, float) or ( + isinstance(hue, collections.Iterable) and len(hue) == 2 + ) + + self.brightness = brightness + self.contrast = contrast + self.saturation = saturation + self.hue = hue + + @staticmethod + def get_params(brightness, contrast, saturation, hue): + """Get a randomized transform to be applied on image. + Arguments are same as that of __init__. + Returns: + Transform which randomly adjusts brightness, contrast and + saturation in a random order. + """ + transforms = [] + + if isinstance(brightness, numbers.Number): + + if brightness > 0: + brightness_factor = random.uniform( + max(0, 1 - brightness), 1 + brightness + ) + transforms.append( + Lambda(lambda img: F.adjust_brightness(img, brightness_factor)) + ) + + if contrast > 0: + contrast_factor = random.uniform(max(0, 1 - contrast), 1 + contrast) + transforms.append( + Lambda(lambda img: F.adjust_contrast(img, contrast_factor)) + ) + + if saturation > 0: + saturation_factor = random.uniform( + max(0, 1 - saturation), 1 + saturation + ) + transforms.append( + Lambda(lambda img: F.adjust_saturation(img, saturation_factor)) + ) + + if hue > 0: + hue_factor = random.uniform(-hue, hue) + transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor))) + + else: + + if brightness[0] > 0 and brightness[1] > 0: + + brightness_factor = random.uniform(brightness[0], brightness[1]) + transforms.append( + Lambda(lambda img: F.adjust_brightness(img, brightness_factor)) + ) + + if contrast[0] > 0 and contrast[1] > 0: + + contrast_factor = random.uniform(contrast[0], contrast[1]) + transforms.append( + Lambda(lambda img: F.adjust_contrast(img, contrast_factor)) + ) + + if saturation[0] > 0 and saturation[1] > 0: + + saturation_factor = random.uniform(saturation[0], saturation[1]) + transforms.append( + Lambda(lambda img: F.adjust_saturation(img, saturation_factor)) + ) + + if hue[0] > 0 and hue[1] > 0: + hue_factor = random.uniform(hue[0], hue[1]) + transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor))) + + random.shuffle(transforms) + transform = ComposeSingle(transforms) + + return transform + + def __call__(self, img, target): + """ + Args: + img (np.ndarray): Input image. + Returns: + np.ndarray: Color jittered image. + """ + transform = self.get_params( + self.brightness, self.contrast, self.saturation, self.hue + ) + return transform(img), target + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + format_string += "brightness={0}".format(self.brightness) + format_string += ", contrast={0}".format(self.contrast) + format_string += ", saturation={0}".format(self.saturation) + format_string += ", hue={0})".format(self.hue) + return format_string + + +class Normalize(object): + """Normalize a tensor image with mean and standard deviation. + Given mean: ``(M1,...,Mn)`` and std: ``(S1,..,Sn)`` for ``n`` channels, this transform + will normalize each channel of the input ``torch.*Tensor`` i.e. + ``input[channel] = (input[channel] - mean[channel]) / std[channel]`` + Args: + mean (sequence): Sequence of means for each channel. + std (sequence): Sequence of standard deviations for each channel. + """ + + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, tensor, target=None): + """ + Args: + tensor (Tensor): Tensor image of size (C, H, W) to be normalized. + Returns: + Tensor: Normalized Tensor image. + """ + return F.normalize(tensor, self.mean, self.std), target + + def __repr__(self): + return self.__class__.__name__ + "(mean={0}, std={1})".format( + self.mean, self.std + ) + + +class NoTransformation(object): + """Do Nothing""" + + def __call__(self, img, target): + return img, target + + +class Compose(object): + """Composes several transforms together. + Args: + transforms (list of ``Transform`` objects): list of transforms to compose. + Example: + >>> transforms.Compose([ + >>> transforms.CenterCrop(10), + >>> transforms.ToTensor(), + >>> ]) + """ + + def __init__(self, transforms): + self.transforms = transforms + + def __call__(self, img, target): + for t in self.transforms: + img, target = t(img, target) + return img, target + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + for t in self.transforms: + format_string += "\n" + format_string += " {0}".format(t) + format_string += "\n)" + return format_string + + +class ComposeSingle(object): + """Composes several transforms together. + Args: + transforms (list of ``Transform`` objects): list of transforms to compose. + Example: + >>> transforms.Compose([ + >>> transforms.CenterCrop(10), + >>> transforms.ToTensor(), + >>> ]) + """ + + def __init__(self, transforms): + self.transforms = transforms + + def __call__(self, img): + for t in self.transforms: + img = t(img) + return img + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + for t in self.transforms: + format_string += "\n" + format_string += " {0}".format(t) + format_string += "\n)" + return format_string + + +class Resize(object): + """Resize the input PIL Image to the given size. + Args: + size (sequence or int): Desired output size. If size is a sequence like + (h, w), output size will be matched to this. If size is an int, + smaller edge of the image will be matched to this number. + i.e, if height > width, then image will be rescaled to + (size * height / width, size) + interpolation (int, optional): Desired interpolation. Default is + ``BILINEAR`` + """ + + def __init__(self, size, interpolation="BILINEAR"): + self.size = size + self.interpolation = interpolation + + def __call__(self, img, target=None): + """ + Args: + img (np.ndarray): Image to be scaled. + Returns: + np.ndarray: Rescaled image. + """ + # Resize bboxes (in pixels) + x_scale = 0 + y_scale = 0 + + if img.shape[1] > 0: + x_scale = self.size[0] / img.shape[1] + if img.shape[0] > 0: + y_scale = self.size[1] / img.shape[0] + + # loop over bboxes + if target is not None: + if target["boxes"] is not None: + target_ = target.copy() + target_["boxes"][:, 0] = x_scale * target_["boxes"][:, 0] + target_["boxes"][:, 1] = y_scale * target_["boxes"][:, 1] + target_["boxes"][:, 2] = x_scale * target_["boxes"][:, 2] + target_["boxes"][:, 3] = y_scale * target_["boxes"][:, 3] + return F.resize(img, self.size, self.interpolation), target + + def __repr__(self): + interpolate_str = self.interpolation + return self.__class__.__name__ + "(size={0}, interpolation={1})".format( + self.size, interpolate_str + ) diff --git a/docling_ibm_models/tableformer/models/__init__.py b/docling_ibm_models/tableformer/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/docling_ibm_models/tableformer/models/common/__init__.py b/docling_ibm_models/tableformer/models/common/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/docling_ibm_models/tableformer/models/common/base_model.py b/docling_ibm_models/tableformer/models/common/base_model.py new file mode 100644 index 0000000..52746f4 --- /dev/null +++ b/docling_ibm_models/tableformer/models/common/base_model.py @@ -0,0 +1,279 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import glob +import logging +import os +import time +from abc import ABC, abstractmethod +from pathlib import Path + +import torch + +import docling_ibm_models.tableformer.settings as s + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +class BaseModel(ABC): + r""" + BaseModel provides some common functionality for all models: + - Saves checkpoint files for each epoch + - Loads the model from the best available checkpoint + - Save repository branch and commit + """ + + def __init__(self, config, init_data, device): + r""" + Inputs: + config: The configuration file + init_data: Dictionary with initialization data. This dictionary can be used to pass any + kind of initialization data for the models + device: The device used to move the tensors of the model + """ + super(BaseModel, self).__init__() + + # Set config and device + self._config = config + self._init_data = init_data + + self._device = device + + self._save_dir = config["model"]["save_dir"] + self._load_checkpoint = None + if "load_checkpoint" in config["model"]: + self._load_checkpoint = config["model"]["load_checkpoint"] + + self._branch_name = "dev/next" + self._commit_sha = "1" + + # Keep a dictionary with the starting times per epoch. + # NOTICE: Epochs start from 0 + self._epoch_start_ts = {0: time.time()} + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + @abstractmethod + def predict(self, img, max_steps, beam_size, return_attention): + pass + + def count_parameters(self): + r"""Counts the number of trainable parameters of this model + + Output: + num_parameters: number of trainable parameters + """ + num_parameters = sum(p.numel() for p in self.parameters() if p.requires_grad) + + return num_parameters + + def get_code_version(self): + r"""Gets the source control version of this model code + + Returns + ------- + branch_name : str + The name of the Git branch of this model code + commit_sha : str + The unique identifier of the Git commit of this model code + """ + + return self._branch_name, self._commit_sha + + def get_save_directory(self): + r""" + Return the save directory + """ + return self._save_dir + + def is_saved(self): + r""" + This method returns True if both conditions are met: + 1. There is a checkpoint file for the model. + 2. The checkpoint file corresponds to the last training epoch set in the configuration file. + """ + # Get the saved_model + saved_model, _ = self._load_best_checkpoint() + + if saved_model is None: + return False + + epochs = self._config["train"]["epochs"] + self._log().debug( + "Best epoch in saved model: {}; Number of epochs in config: {}".format( + saved_model["epoch"], epochs + ) + ) + if epochs == saved_model["epoch"] + 1: + return True + + return False + + def save(self, epoch=None, optimizers=None, losses=None, model_parameters=None): + r""" + Save the model data to the disk as a pickle file. + + Parameters + ---------- + epoch: Training epoch + optimizers: Dictionary with the optimizers. The key specifies what the optimizer is + used for. The 'state_dict' of each optimizer will be saved in the + checkpoint file. + losses: Dictionary with the losses. The key specifies what the loss is used for. Each + value is a list + model_parameters: Dictionary with model specific parameters that we need to save in the + checkpoint file. + Returns + ------- + True if success, False otherwise + """ + # Get the checkpoint_filename + c_filename = self._build_checkpoint_filename(epoch) + self._log().debug("Trying to save checkpoint file: {}".format(c_filename)) + + # Prepare a dictionary with all data we want to save + optimizers_state_dict = None + if optimizers is not None: + optimizers_state_dict = {k: v.state_dict() for k, v in optimizers.items()} + + model_data = { + "model_state_dict": self.state_dict(), + "epoch": epoch, + "optimizers": optimizers_state_dict, + "losses": losses, + "model_parameters": model_parameters, + } + + # Add the processing time per epoch + now = time.time() + self._epoch_start_ts[epoch + 1] = now + if epoch in self._epoch_start_ts: + dt = now - self._epoch_start_ts[epoch] + model_data["epoch_start_ts"] = self._epoch_start_ts[epoch] + model_data["epoch_dt"] = dt + + # Create the save directory + Path(self._save_dir).mkdir(parents=True, exist_ok=True) + + # Save the model + torch.save(model_data, c_filename) + + # Return true if file is present, otherwise false + if not os.path.isfile(c_filename): + self._log().error("Cannot find the file to save: " + c_filename) + return False + + # store code branch name and commit + version_file = os.path.join(self._save_dir, "_version") + with open(version_file, "w") as text_file: + print("Model is using code [commit:branch]", file=text_file) + print("{}:{}".format(self._commit_sha, self._branch_name), file=text_file) + + return True + + def load(self, optimizers=None): + r""" + Load the model data from the disk. + The method will iterate over all *.check files and try to load the one from the highest + epoch. + + Input: + -optimizers: Dictionary with optimizers. If it is not null the keys will be used to + associate the corresponding state_dicts from the checkpoint file and update + the internal states of the provided optimizers. + + Output: + - Success: True/ False + - epoch: Loaded epoch or -1 if there are no checkpoint files + - optimizers: Dictionary with loaded optimizers or empty dictionary of there is no + checkpoint file + - losses: Dictionary with loaded losses or empty dictionary of there is no checkpoint + file + - model_parameters: Dictionary with the model parameters or empty dictionary if there + are no checkpoint files + """ + # Get the saved_model + saved_model, _ = self._load_best_checkpoint() + + # Restore the model + if saved_model is None: + self._log().debug("No saved model checkpoint found") + return False, -1, optimizers, {}, {} + + self._log().debug("Loading model from checkpoint file") + self.load_state_dict(saved_model["model_state_dict"]) + + epoch = 0 + if "epoch" in saved_model: + epoch = saved_model["epoch"] + losses = {} + if "losses" in saved_model: + losses = saved_model["losses"] + model_parameters = saved_model["model_parameters"] + + if optimizers is not None: + for key, optimizer_state_dict in saved_model["optimizers"].items(): + optimizers[key].load_state_dict(optimizer_state_dict) + + # Reset the start_ts of the next epoch + self._epoch_start_ts[epoch + 1] = time.time() + + return True, epoch, optimizers, losses, model_parameters + + def _load_best_checkpoint(self): + r""" + If a "load_checkpoint" file has been provided, load this one. + Otherwise use the "save_dir" and load the one with the most advanced epoch + + Returns + ------- + saved_model : dictionary + Checkpoint file contents generated by torch.load, or None + checkpoint_file : string + Filename of the loaded checkpoint, or None + """ + checkpoint_files = [] + # If a "load_checkpoint" file is provided, try to load it + if self._load_checkpoint is not None: + if not os.path.exists(self._load_checkpoint): + self._log().error( + "Cannot load the checkpoint: {}".format(self._load_checkpoint) + ) + return None, None + checkpoint_files.append(self._load_checkpoint) + else: + # Iterate over all check files from the directory by reverse alphabetical order + # This will get the biggest epoch first + checkpoint_files = glob.glob(os.path.join(self._save_dir, "*.check")) + checkpoint_files.sort(reverse=True) + + for checkpoint_file in checkpoint_files: + try: + # Try to load the file + self._log().info( + "Loading model checkpoint file: {}".format(checkpoint_file) + ) + saved_model = torch.load(checkpoint_file, map_location=self._device) + return saved_model, checkpoint_file + except RuntimeError: + self._log().error("Cannot load file: {}".format(checkpoint_file)) + + return None, None + + def _build_checkpoint_filename(self, epoch): + r""" + Construct the full path for the filename of this checkpoint + """ + dataset_name = self._config["dataset"]["name"] + model_type = self._config["model"]["type"] + model_name = self._config["model"]["name"] + filename = "{}_{}_{}_{:03}.check".format( + model_type, model_name, dataset_name, epoch + ) + c_filename = os.path.join(self._save_dir, filename) + + return c_filename diff --git a/docling_ibm_models/tableformer/models/table04_rs/__init__.py b/docling_ibm_models/tableformer/models/table04_rs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/docling_ibm_models/tableformer/models/table04_rs/bbox_decoder_rs.py b/docling_ibm_models/tableformer/models/table04_rs/bbox_decoder_rs.py new file mode 100644 index 0000000..3c055e0 --- /dev/null +++ b/docling_ibm_models/tableformer/models/table04_rs/bbox_decoder_rs.py @@ -0,0 +1,163 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import logging + +import torch +import torch.nn as nn + +import docling_ibm_models.tableformer.settings as s +import docling_ibm_models.tableformer.utils.utils as u + +# from scipy.optimize import linear_sum_assignment + +LOG_LEVEL = logging.INFO + + +class CellAttention(nn.Module): + """ + Attention Network. + """ + + def __init__(self, encoder_dim, tag_decoder_dim, language_dim, attention_dim): + """ + :param encoder_dim: feature size of encoded images + :param tag_decoder_dim: size of tag decoder's RNN + :param language_dim: size of language model's RNN + :param attention_dim: size of the attention network + """ + super(CellAttention, self).__init__() + # linear layer to transform encoded image + self._encoder_att = nn.Linear(encoder_dim, attention_dim) + # linear layer to transform tag decoder output + self._tag_decoder_att = nn.Linear(tag_decoder_dim, attention_dim) + # linear layer to transform language models output + self._language_att = nn.Linear(language_dim, attention_dim) + # linear layer to calculate values to be softmax-ed + self._full_att = nn.Linear(attention_dim, 1) + self._relu = nn.ReLU() + self._softmax = nn.Softmax(dim=1) # softmax layer to calculate weights + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def forward(self, encoder_out, decoder_hidden, language_out): + """ + Forward propagation. + :param encoder_out: encoded images, a tensor of dimension (1, num_pixels, encoder_dim) + :param decoder_hidden: tag decoder output, a tensor of dimension [(num_cells, + tag_decoder_dim)] + :param language_out: language model output, a tensor of dimension (num_cells, + language_dim) + :return: attention weighted encoding, weights + """ + att1 = self._encoder_att(encoder_out) # (1, num_pixels, attention_dim) + att2 = self._tag_decoder_att(decoder_hidden) # (num_cells, tag_decoder_dim) + att3 = self._language_att(language_out) # (num_cells, attention_dim) + att = self._full_att( + self._relu(att1 + att2.unsqueeze(1) + att3.unsqueeze(1)) + ).squeeze(2) + alpha = self._softmax(att) # (num_cells, num_pixels) + # (num_cells, encoder_dim) + attention_weighted_encoding = (encoder_out * alpha.unsqueeze(2)).sum(dim=1) + return attention_weighted_encoding, alpha + + +class BBoxDecoder(nn.Module): + """ + CellDecoder generates cell content + """ + + def __init__( + self, + device, + attention_dim, + embed_dim, + tag_decoder_dim, + decoder_dim, + num_classes, + encoder_dim=512, + dropout=0.5, + cnn_layer_stride=1, + ): + """ + :param attention_dim: size of attention network + :param embed_dim: embedding size + :param tag_decoder_dim: size of tag decoder's RNN + :param decoder_dim: size of decoder's RNN + :param vocab_size: size of vocabulary + :param encoder_dim: feature size of encoded images + :param dropout: dropout + :param mini_batch_size: batch size of cells to reduce GPU memory usage + """ + super(BBoxDecoder, self).__init__() + self._device = device + self._encoder_dim = encoder_dim + self._attention_dim = attention_dim + self._embed_dim = embed_dim + self._decoder_dim = decoder_dim + self._dropout = dropout + self._num_classes = num_classes + + if cnn_layer_stride is not None: + self._input_filter = u.resnet_block(stride=cnn_layer_stride) + # attention network + self._attention = CellAttention( + encoder_dim, tag_decoder_dim, decoder_dim, attention_dim + ) + # decoder LSTMCell + self._init_h = nn.Linear(encoder_dim, decoder_dim) + + # linear layer to create a sigmoid-activated gate + self._f_beta = nn.Linear(decoder_dim, encoder_dim) + self._sigmoid = nn.Sigmoid() + self._dropout = nn.Dropout(p=self._dropout) + self._class_embed = nn.Linear(512, self._num_classes + 1) + self._bbox_embed = u.MLP(512, 256, 4, 3) + + def _init_hidden_state(self, encoder_out, batch_size): + mean_encoder_out = encoder_out.mean(dim=1) + h = self._init_h(mean_encoder_out).expand(batch_size, -1) + return h + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def inference(self, encoder_out, tag_H): + """ + Inference on test images with beam search + """ + if hasattr(self, "_input_filter"): + encoder_out = self._input_filter(encoder_out.permute(0, 3, 1, 2)).permute( + 0, 2, 3, 1 + ) + + encoder_dim = encoder_out.size(3) + + # Flatten encoding (1, num_pixels, encoder_dim) + encoder_out = encoder_out.view(1, -1, encoder_dim) + + num_cells = len(tag_H) + predictions_bboxes = [] + predictions_classes = [] + + for c_id in range(num_cells): + # Start decoding + h = self._init_hidden_state(encoder_out, 1) + cell_tag_H = tag_H[c_id] + awe, _ = self._attention(encoder_out, cell_tag_H, h) + gate = self._sigmoid(self._f_beta(h)) + awe = gate * awe + h = awe * h + + predictions_bboxes.append(self._bbox_embed(h).sigmoid()) + predictions_classes.append(self._class_embed(h)) + if len(predictions_bboxes) > 0: + predictions_bboxes = torch.stack([x[0] for x in predictions_bboxes]) + if len(predictions_classes) > 0: + predictions_classes = torch.stack([x[0] for x in predictions_classes]) + + return predictions_classes, predictions_bboxes diff --git a/docling_ibm_models/tableformer/models/table04_rs/encoder04_rs.py b/docling_ibm_models/tableformer/models/table04_rs/encoder04_rs.py new file mode 100644 index 0000000..56d7861 --- /dev/null +++ b/docling_ibm_models/tableformer/models/table04_rs/encoder04_rs.py @@ -0,0 +1,72 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import logging + +import torch.nn as nn +import torchvision + +import docling_ibm_models.tableformer.settings as s + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +class Encoder04(nn.Module): + """ + Encoder based on resnet-18 + """ + + def __init__(self, enc_image_size, enc_dim=512): + r""" + Parameters + ---------- + enc_image_size : int + Assuming that the encoded image is a square, this is the length of the image side + """ + + super(Encoder04, self).__init__() + self.enc_image_size = enc_image_size + self._encoder_dim = enc_dim + + resnet = torchvision.models.resnet18(pretrained=False) + modules = list(resnet.children())[:-3] + + self._resnet = nn.Sequential(*modules) + self._adaptive_pool = nn.AdaptiveAvgPool2d( + (self.enc_image_size, self.enc_image_size) + ) + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def get_encoder_dim(self): + return self._encoder_dim + + def forward(self, images): + """ + Forward propagation + The encoder_dim 512 is decided by the structure of the image network (modified resnet-19) + + Parameters + ---------- + images : tensor (batch_size, image_channels, resized_image, resized_image) + images input + + Returns + ------- + tensor : (batch_size, enc_image_size, enc_image_size, 256) + encoded images + """ + out = self._resnet(images) # (batch_size, 256, 28, 28) + self._log().debug("forward: resnet out: {}".format(out.size())) + out = self._adaptive_pool(out) + out = out.permute( + 0, 2, 3, 1 + ) # (batch_size, enc_image_size, enc_image_size, 256) + + self._log().debug("enc forward: final out: {}".format(out.size())) + + return out diff --git a/docling_ibm_models/tableformer/models/table04_rs/tablemodel04_rs.py b/docling_ibm_models/tableformer/models/table04_rs/tablemodel04_rs.py new file mode 100644 index 0000000..acfacbe --- /dev/null +++ b/docling_ibm_models/tableformer/models/table04_rs/tablemodel04_rs.py @@ -0,0 +1,324 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import logging + +import torch +import torch.nn as nn + +import docling_ibm_models.tableformer.settings as s +from docling_ibm_models.tableformer.models.common.base_model import BaseModel +from docling_ibm_models.tableformer.models.table04_rs.bbox_decoder_rs import BBoxDecoder +from docling_ibm_models.tableformer.models.table04_rs.encoder04_rs import Encoder04 +from docling_ibm_models.tableformer.models.table04_rs.transformer_rs import ( + Tag_Transformer, +) +from docling_ibm_models.tableformer.utils.app_profiler import AggProfiler + +LOG_LEVEL = logging.WARN +# LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +class TableModel04_rs(BaseModel, nn.Module): + r""" + TableNet04Model encoder, dual-decoder model with OTSL+ support + """ + + def __init__(self, config, init_data, purpose, device): + super(TableModel04_rs, self).__init__(config, init_data, device) + + self._prof = config["predict"].get("profiling", False) + self._device = device + # Extract the word_map from the init_data + word_map = init_data["word_map"] + + # Encoder + self._enc_image_size = config["model"]["enc_image_size"] + self._encoder_dim = config["model"]["hidden_dim"] + self._encoder = Encoder04(self._enc_image_size, self._encoder_dim).to(device) + + tag_vocab_size = len(word_map["word_map_tag"]) + + td_encode = [] + for t in ["ecel", "fcel", "ched", "rhed", "srow"]: + if t in word_map["word_map_tag"]: + td_encode.append(word_map["word_map_tag"][t]) + self._log().debug("td_encode length: {}".format(len(td_encode))) + self._log().debug("td_encode: {}".format(td_encode)) + + self._tag_attention_dim = config["model"]["tag_attention_dim"] + self._tag_embed_dim = config["model"]["tag_embed_dim"] + self._tag_decoder_dim = config["model"]["tag_decoder_dim"] + self._decoder_dim = config["model"]["hidden_dim"] + self._dropout = config["model"]["dropout"] + + self._bbox = config["train"]["bbox"] + self._bbox_attention_dim = config["model"]["bbox_attention_dim"] + self._bbox_embed_dim = config["model"]["bbox_embed_dim"] + self._bbox_decoder_dim = config["model"]["hidden_dim"] + + self._enc_layers = config["model"]["enc_layers"] + self._dec_layers = config["model"]["dec_layers"] + self._n_heads = config["model"]["nheads"] + + self._num_classes = config["model"]["bbox_classes"] + self._enc_image_size = config["model"]["enc_image_size"] + + self._max_pred_len = config["predict"]["max_steps"] + + self._tag_transformer = Tag_Transformer( + device, + tag_vocab_size, + td_encode, + self._decoder_dim, + self._enc_layers, + self._dec_layers, + self._enc_image_size, + n_heads=self._n_heads, + ).to(device) + + self._bbox_decoder = BBoxDecoder( + device, + self._bbox_attention_dim, + self._bbox_embed_dim, + self._tag_decoder_dim, + self._bbox_decoder_dim, + self._num_classes, + self._encoder_dim, + self._dropout, + ).to(device) + + def _log(self): + # Setup a custom logger + return s.get_custom_logger(self.__class__.__name__, LOG_LEVEL) + + def mergebboxes(self, bbox1, bbox2): + new_w = (bbox2[0] + bbox2[2] / 2) - (bbox1[0] - bbox1[2] / 2) + new_h = (bbox2[1] + bbox2[3] / 2) - (bbox1[1] - bbox1[3] / 2) + + new_left = bbox1[0] - bbox1[2] / 2 + new_top = min((bbox2[1] - bbox2[3] / 2), (bbox1[1] - bbox1[3] / 2)) + + new_cx = new_left + new_w / 2 + new_cy = new_top + new_h / 2 + + bboxm = torch.tensor([new_cx, new_cy, new_w, new_h]) + return bboxm + + def predict(self, imgs, max_steps, k, return_attention=False): + r""" + Inference. + The input image must be preprocessed and transformed. + + Parameters + ---------- + img : tensor FloatTensor - torch.Size([1, 3, 448, 448]) + Input image for the inference + + Returns + ------- + seq : list + Predictions for the tags as indices over the word_map + outputs_class : tensor(x, 3) + Classes of predicted bboxes. x is the number of bboxes. There are 3 bbox classes + + outputs_coord : tensor(x, 4) + Coords of predicted bboxes. x is the number of bboxes. Each bbox is in [cxcywh] format + """ + AggProfiler().begin("predict_total", self._prof) + + # Invoke encoder + self._tag_transformer.eval() + enc_out = self._encoder(imgs) + AggProfiler().end("model_encoder", self._prof) + + word_map = self._init_data["word_map"]["word_map_tag"] + n_heads = self._tag_transformer._n_heads + # [1, 28, 28, 512] + encoder_out = self._tag_transformer._input_filter( + enc_out.permute(0, 3, 1, 2) + ).permute(0, 2, 3, 1) + + batch_size = encoder_out.size(0) + encoder_dim = encoder_out.size(-1) + enc_inputs = encoder_out.view(batch_size, -1, encoder_dim).to(self._device) + enc_inputs = enc_inputs.permute(1, 0, 2) + positions = enc_inputs.shape[0] + + encoder_mask = torch.zeros( + (batch_size * n_heads, positions, positions), device=self._device + ) == torch.ones( + (batch_size * n_heads, positions, positions), device=self._device + ) + + # Invoking tag transformer encoder before the loop to save time + AggProfiler().begin("model_tag_transformer_encoder", self._prof) + encoder_out = self._tag_transformer._encoder(enc_inputs, mask=encoder_mask) + AggProfiler().end("model_tag_transformer_encoder", self._prof) + + decoded_tags = ( + torch.LongTensor([word_map[""]]).to(self._device).unsqueeze(1) + ) + output_tags = [] + cache = None + tag_H_buf = [] + + skip_next_tag = True + prev_tag_ucel = False + line_num = 0 + + # Populate bboxes_to_merge, indexes of first lcel, and last cell in a span + first_lcel = True + bboxes_to_merge = {} + cur_bbox_ind = -1 + bbox_ind = 0 + + # i = 0 + while len(output_tags) < self._max_pred_len: + decoded_embedding = self._tag_transformer._embedding(decoded_tags) + decoded_embedding = self._tag_transformer._positional_encoding( + decoded_embedding + ) + AggProfiler().begin("model_tag_transformer_decoder", self._prof) + decoded, cache = self._tag_transformer._decoder( + decoded_embedding, + encoder_out, + cache, + memory_key_padding_mask=encoder_mask, + ) + AggProfiler().end("model_tag_transformer_decoder", self._prof) + # Grab last feature to produce token + AggProfiler().begin("model_tag_transformer_fc", self._prof) + logits = self._tag_transformer._fc(decoded[-1, :, :]) # 1, vocab_size + AggProfiler().end("model_tag_transformer_fc", self._prof) + new_tag = logits.argmax(1).item() + + # STRUCTURE ERROR CORRECTION + # Correction for first line xcel... + if line_num == 0: + if new_tag == word_map["xcel"]: + new_tag = word_map["lcel"] + + # Correction for ucel, lcel sequence... + if prev_tag_ucel: + if new_tag == word_map["lcel"]: + new_tag = word_map["fcel"] + + # End of generation + if new_tag == word_map[""]: + output_tags.append(new_tag) + decoded_tags = torch.cat( + [ + decoded_tags, + torch.LongTensor([new_tag]).unsqueeze(1).to(self._device), + ], + dim=0, + ) # current_output_len, 1 + break + output_tags.append(new_tag) + + # BBOX PREDICTION + + # MAKE SURE TO SYNC NUMBER OF CELLS WITH NUMBER OF BBOXes + if not skip_next_tag: + if new_tag in [ + word_map["fcel"], + word_map["ecel"], + word_map["ched"], + word_map["rhed"], + word_map["srow"], + word_map["nl"], + word_map["ucel"], + ]: + # GENERATE BBOX HERE TOO (All other cases)... + tag_H_buf.append(decoded[-1, :, :]) + if first_lcel is not True: + # Mark end index for horizontal cell bbox merge + bboxes_to_merge[cur_bbox_ind] = bbox_ind + bbox_ind += 1 + + # Treat horisontal span bboxes... + if new_tag != word_map["lcel"]: + first_lcel = True + else: + if first_lcel: + # GENERATE BBOX HERE (Beginning of horisontal span)... + tag_H_buf.append(decoded[-1, :, :]) + first_lcel = False + # Mark start index for cell bbox merge + cur_bbox_ind = bbox_ind + bboxes_to_merge[cur_bbox_ind] = -1 + bbox_ind += 1 + + if new_tag in [word_map["nl"], word_map["ucel"], word_map["xcel"]]: + skip_next_tag = True + else: + skip_next_tag = False + + # Register ucel in sequence... + if new_tag == word_map["ucel"]: + prev_tag_ucel = True + else: + prev_tag_ucel = False + + decoded_tags = torch.cat( + [ + decoded_tags, + torch.LongTensor([new_tag]).unsqueeze(1).to(self._device), + ], + dim=0, + ) # current_output_len, 1 + seq = decoded_tags.squeeze().tolist() + + if self._bbox: + AggProfiler().begin("model_bbox_decoder", self._prof) + outputs_class, outputs_coord = self._bbox_decoder.inference( + enc_out, tag_H_buf + ) + AggProfiler().end("model_bbox_decoder", self._prof) + else: + outputs_class, outputs_coord = None, None + + outputs_class.to(self._device) + outputs_coord.to(self._device) + + ######################################################################################## + # Merge First and Last predicted BBOX for each span, according to bboxes_to_merge + ######################################################################################## + + outputs_class1 = [] + outputs_coord1 = [] + boxes_to_skip = [] + + for box_ind in range(len(outputs_coord)): + box1 = outputs_coord[box_ind].to(self._device) + cls1 = outputs_class[box_ind].to(self._device) + if box_ind in bboxes_to_merge: + box2 = outputs_coord[bboxes_to_merge[box_ind]].to(self._device) + boxes_to_skip.append(bboxes_to_merge[box_ind]) + boxm = self.mergebboxes(box1, box2).to(self._device) + outputs_coord1.append(boxm) + outputs_class1.append(cls1) + else: + if box_ind not in boxes_to_skip: + outputs_coord1.append(box1) + outputs_class1.append(cls1) + + if len(outputs_coord1) > 0: + outputs_coord1 = torch.stack(outputs_coord1) + if len(outputs_class1) > 0: + outputs_class1 = torch.stack(outputs_class1) + + outputs_class = outputs_class1 + outputs_coord = outputs_coord1 + + # Do the rest of the steps... + AggProfiler().end("predict_total", self._prof) + num_tab_cells = seq.count(4) + seq.count(5) + num_rows = seq.count(9) + self._log().info( + "OTSL predicted table cells#: {}; rows#: {}".format(num_tab_cells, num_rows) + ) + return seq, outputs_class, outputs_coord diff --git a/docling_ibm_models/tableformer/models/table04_rs/transformer_rs.py b/docling_ibm_models/tableformer/models/table04_rs/transformer_rs.py new file mode 100644 index 0000000..3b54724 --- /dev/null +++ b/docling_ibm_models/tableformer/models/table04_rs/transformer_rs.py @@ -0,0 +1,203 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import logging +import math +from typing import Optional + +import torch +from torch import Tensor, nn + +import docling_ibm_models.tableformer.utils.utils as u + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +class PositionalEncoding(nn.Module): + def __init__(self, d_model, dropout=0.1, max_len=1024): + super(PositionalEncoding, self).__init__() + self.dropout = nn.Dropout(p=dropout) + + pe = torch.zeros(max_len, d_model) + position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) + div_term = torch.exp( + torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model) + ) + pe[:, 0::2] = torch.sin(position * div_term) + pe[:, 1::2] = torch.cos(position * div_term) + pe = pe.unsqueeze(0).transpose(0, 1) + self.register_buffer("pe", pe) + + def forward(self, x): + x = x + self.pe[: x.size(0), :] + return self.dropout(x) + + +class TMTransformerDecoder(nn.TransformerDecoder): + def forward( + self, + tgt: Tensor, + memory: Optional[Tensor] = None, + cache: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + ) -> Tensor: + """ + Args: + tgt (Tensor): encoded tags. (tags_len,bsz,hidden_dim) + memory (Tensor): encoded image (enc_image_size,bsz,hidden_dim) + cache (Optional[Tensor]): None during training, only used during inference. + Returns: + output (Tensor): (tags_len,bsz,hidden_dim) + """ + + output = tgt + + # cache + tag_cache = [] + for i, mod in enumerate(self.layers): + output = mod(output, memory) + tag_cache.append(output) + if cache is not None: + output = torch.cat([cache[i], output], dim=0) + + if cache is not None: + out_cache = torch.cat([cache, torch.stack(tag_cache, dim=0)], dim=1) + else: + out_cache = torch.stack(tag_cache, dim=0) + + return output, out_cache + + +class TMTransformerDecoderLayer(nn.TransformerDecoderLayer): + def forward( + self, + tgt: Tensor, + memory: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + ) -> Tensor: + """ + Args: + same as TMTransformerDecoder + Returns: + Tensor: + During training (seq_len,bsz,hidden_dim) + If eval mode: embedding of last tag: (1,bsz,hidden_dim) + """ + + # From PyTorch but modified to only use the last tag + tgt_last_tok = tgt[-1:, :, :] + + tmp_tgt = self.self_attn( + tgt_last_tok, + tgt, + tgt, + attn_mask=None, # None, because we only care about the last tag + key_padding_mask=tgt_key_padding_mask, + )[0] + tgt_last_tok = tgt_last_tok + self.dropout1(tmp_tgt) + tgt_last_tok = self.norm1(tgt_last_tok) + + if memory is not None: + tmp_tgt = self.multihead_attn( + tgt_last_tok, + memory, + memory, + attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask, + )[0] + tgt_last_tok = tgt_last_tok + self.dropout2(tmp_tgt) + tgt_last_tok = self.norm2(tgt_last_tok) + + tmp_tgt = self.linear2( + self.dropout(self.activation(self.linear1(tgt_last_tok))) + ) + tgt_last_tok = tgt_last_tok + self.dropout3(tmp_tgt) + tgt_last_tok = self.norm3(tgt_last_tok) + return tgt_last_tok + + +class Tag_Transformer(nn.Module): + """ + "Attention Is All You Need" - https://arxiv.org/abs/1706.03762 + """ + + def __init__( + self, + device, + vocab_size, + td_encode, + embed_dim, + encoder_layers, + decoder_layers, + enc_image_size, + dropout=0.1, + n_heads=4, + dim_ff=1024, + ): + + super(Tag_Transformer, self).__init__() + + self._device = device + self._n_heads = n_heads + self._embedding = nn.Embedding(vocab_size, embed_dim) + self._positional_encoding = PositionalEncoding(embed_dim) + self._td_encode = td_encode + + self._encoder = nn.TransformerEncoder( + nn.TransformerEncoderLayer( + d_model=embed_dim, nhead=n_heads, dim_feedforward=dim_ff + ), + num_layers=encoder_layers, + ) + + self._decoder = TMTransformerDecoder( + TMTransformerDecoderLayer( + d_model=embed_dim, + nhead=n_heads, + dim_feedforward=dim_ff, + ), + num_layers=decoder_layers, + ) + + self._decoder_dim = embed_dim + self._enc_image_size = enc_image_size + self._input_filter = u.resnet_block(stride=1) + self._fc = nn.Linear(embed_dim, vocab_size) + + def inference(self, enc_inputs, tags, tag_lens, num_cells): + # CNN backbone image encoding + enc_inputs = self._input_filter(enc_inputs.permute(0, 3, 1, 2)).permute( + 0, 2, 3, 1 + ) + + batch_size = enc_inputs.size(0) + encoder_dim = enc_inputs.size(-1) + + enc_inputs = enc_inputs.view(batch_size, -1, encoder_dim).to(self._device) + + enc_inputs = enc_inputs.permute(1, 0, 2) + positions = enc_inputs.shape[0] + # Transformer Encoder Encoded Image mask need to check if its useful + encoder_mask = torch.zeros( + (batch_size * self._n_heads, positions, positions), device=self._device + ) == torch.ones( + (batch_size * self._n_heads, positions, positions), device=self._device + ) + + # Transformer Encoder + encoder_out = self._encoder(enc_inputs, mask=encoder_mask) + + decode_lengths = (tag_lens - 1).tolist() + + tgt = self._positional_encoding(self._embedding(tags).permute(1, 0, 2)) + + decoded = self._decoder(tgt, memory=encoder_out) + decoded = decoded.permute(1, 0, 2) + predictions = self._fc(decoded) + return predictions, decode_lengths diff --git a/docling_ibm_models/tableformer/otsl.py b/docling_ibm_models/tableformer/otsl.py new file mode 100644 index 0000000..3c52fc7 --- /dev/null +++ b/docling_ibm_models/tableformer/otsl.py @@ -0,0 +1,541 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import copy +import logging +from itertools import groupby + +import docling_ibm_models.tableformer.settings as s + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG +logger = s.get_custom_logger("consolidate", LOG_LEVEL) +png_files = {} # Evaluation files +total_pics = 0 + + +class bcolors: + HEADER = "\033[95m" + OKBLUE = "\033[94m" + OKCYAN = "\033[96m" + OKGREEN = "\033[92m" + WARNING = "\033[93m" + FAIL = "\033[91m" + ENDC = "\033[0m" + BOLD = "\033[1m" + UNDERLINE = "\033[4m" + + +def otsl_clean(rs_list): + new_rs_list = [] + stop_list = ["", "", "", ""] + for tag in rs_list: + if tag not in stop_list: + new_rs_list.append(tag) + return new_rs_list + + +def otsl_sqr_chk(rs_list, name, logdebug): + rs_list_split = [ + list(group) for k, group in groupby(rs_list, lambda x: x == "nl") if not k + ] + isSquare = True + if len(rs_list_split) > 0: + init_tag_len = len(rs_list_split[0]) + 1 + for ind, ln in enumerate(rs_list_split): + ln.append("nl") + if len(ln) != init_tag_len: + isSquare = False + if isSquare: + if logdebug: + print( + "{}*OK* Table is square! *OK*{}".format( + bcolors.OKGREEN, bcolors.ENDC + ) + ) + else: + err_name = "{}*ERR* " + name + " *ERR*{}" + print(err_name.format(bcolors.FAIL, bcolors.ENDC)) + print( + "{}*ERR* Table is not square! *ERR*{}".format( + bcolors.FAIL, bcolors.ENDC + ) + ) + return isSquare + + +def otsl_pad_to_sqr(rs_list, pad_tag): + new_list = [] + rs_list_split = [ + list(group) for k, group in groupby(rs_list, lambda x: x == "nl") if not k + ] + max_row_len = 0 + for ind, ln in enumerate(rs_list_split): + if len(ln) > max_row_len: + max_row_len = len(ln) + for ind, ln in enumerate(rs_list_split): + ln += [pad_tag] * (max_row_len - len(ln)) + ln.append("nl") + new_list.extend(ln) + return new_list + + +def otsl_tags_cells_sync_chk(rs_list, cells, name, logdebug): + countCellTags = 0 + isGood = True + for rsTag in rs_list: + if rsTag in ["fcel", "ched", "rhed", "srow", "ecel"]: + countCellTags += 1 + if countCellTags != len(cells): + err_name = "{}*!ERR* " + name + " *ERR!*{}" + print(err_name.format(bcolors.FAIL, bcolors.ENDC)) + err_msg = "{}*!ERR* Tags are not in sync with cells! *ERR!*{}" + print(err_msg.format(bcolors.FAIL, bcolors.ENDC)) + isGood = False + return isGood + + +def otsl_check_down(rs_split, x, y): + distance = 1 + elem = "ucel" + goodlist = ["fcel", "ched", "rhed", "srow", "ecel", "lcel", "nl"] + while elem not in goodlist and y < len(rs_split) - 1: + y += 1 + distance += 1 + elem = rs_split[y][x] + if elem in goodlist: + distance -= 1 + return distance + + +def otsl_check_right(rs_split, x, y): + distance = 1 + elem = "lcel" + goodlist = ["fcel", "ched", "rhed", "srow", "ecel", "ucel", "nl"] + while elem not in goodlist and x < (len(rs_split[y]) - 1): + x += 1 + distance += 1 + elem = rs_split[y][x] + if elem in goodlist: + distance -= 1 + return distance + + +def otsl_to_html(rs_list, logdebug): + if rs_list[0] not in ["fcel", "ched", "rhed", "srow", "ecel"]: + # Most likely already HTML... + return rs_list + html_table = [] + if logdebug: + print("{}*Reconstructing HTML...*{}".format(bcolors.WARNING, bcolors.ENDC)) + + if not otsl_sqr_chk(rs_list, "---", logdebug): + # PAD TABLE TO SQUARE + print("{}*Padding to square...*{}".format(bcolors.WARNING, bcolors.ENDC)) + rs_list = otsl_pad_to_sqr(rs_list, "lcel") + + # 2D structure, line by line: + rs_list_split = [ + list(group) for k, group in groupby(rs_list, lambda x: x == "nl") if not k + ] + + if logdebug: + print("") + + # Sequentially store indexes of 2D spans that were registered to avoid re-registering them + registry_2d_span = [] + + # Iterate all elements in the rs line, and look right / down to detect spans + # If span detected - run function to find size of the span + # repeat with all cells + thead_present = False + + for rs_row_ind, rs_row in enumerate(rs_list_split): + html_list = [] + + if not thead_present: + if "ched" in rs_list_split[rs_row_ind]: + html_list.append("") + thead_present = True + + if thead_present: + if "ched" not in rs_list_split[rs_row_ind]: + html_list.append("") + thead_present = False + + html_list.append("") + for rs_cell_ind, rs_cell in enumerate(rs_list_split[rs_row_ind]): + if rs_cell in ["fcel", "ched", "rhed", "srow", "ecel"]: + rdist = 0 + ddist = 0 + xrdist = 0 + xddist = 0 + span = False + # Check if it has horizontal span: + if rs_cell_ind + 1 < len(rs_list_split[rs_row_ind]): + if rs_list_split[rs_row_ind][rs_cell_ind + 1] == "lcel": + rdist = otsl_check_right(rs_list_split, rs_cell_ind, rs_row_ind) + span = True + # Check if it has vertical span: + if rs_row_ind + 1 < len(rs_list_split): + # print(">>>") + # print(rs_list_split[rs_row_ind + 1]) + # print(">>> rs_cell_ind = {}".format(rs_cell_ind)) + if rs_list_split[rs_row_ind + 1][rs_cell_ind] == "ucel": + ddist = otsl_check_down(rs_list_split, rs_cell_ind, rs_row_ind) + span = True + # Check if it has 2D span: + if rs_cell_ind + 1 < len(rs_list_split[rs_row_ind]): + if rs_list_split[rs_row_ind][rs_cell_ind + 1] == "xcel": + xrdist = otsl_check_right( + rs_list_split, rs_cell_ind, rs_row_ind + ) + xddist = otsl_check_down(rs_list_split, rs_cell_ind, rs_row_ind) + span = True + # Check if this 2D span was already registered, + # If not - register, if yes - cancel span + # print("rs_cell_ind: {}, xrdist:{}".format(rs_cell_ind, xrdist)) + # print("rs_row_ind: {}, xddist:{}".format(rs_cell_ind, xrdist)) + for x in range(rs_cell_ind, xrdist + rs_cell_ind): + for y in range(rs_row_ind, xddist + rs_row_ind): + reg2dind = str(x) + "_" + str(y) + # print(reg2dind) + if reg2dind in registry_2d_span: + # Cell of the span is already in, cancel current span + span = False + if span: + # None of the span cells were previously registered + # Register an entire span + for x in range(rs_cell_ind, xrdist + rs_cell_ind): + for y in range(rs_row_ind, xddist + rs_row_ind): + reg2dind = str(x) + "_" + str(y) + registry_2d_span.append(reg2dind) + if span: + html_list.append(" 1: + html_list.append(' colspan="' + str(rdist) + '"') + if ddist > 1: + html_list.append(' rowspan="' + str(ddist) + '"') + if xrdist > 1: + html_list.append(' rowspan="' + str(xddist) + '"') + html_list.append(' colspan="' + str(xrdist) + '"') + html_list.append(">") + html_list.append("") + else: + html_list.append("") + html_list.append("") + html_list.append("") + html_table.extend(html_list) + + if logdebug: + print("*********************** registry_2d_span ***************************") + print(registry_2d_span) + print("********************************************************************") + + return html_table + + +def html_to_otsl(table, writer, logdebug, extra_debug, include_html, use_writer): + r""" + Converts table structure from HTML to RS + + Parameters + ---------- + table : json + line from jsonl + writer : writer + Writes lines into output jsonl + """ + + table_html_structure = copy.deepcopy(table["html"]["structure"]) + out_line = table + if include_html: + out_line["html"]["html_structure"] = table_html_structure + out_line["html"]["html_restored_structure"] = {"tokens": []} + + out_line["html"]["structure"] = {"tokens": []} + # possible colspans + pos_colspans = { + ' colspan="20"': 20, + ' colspan="19"': 19, + ' colspan="18"': 18, + ' colspan="17"': 17, + ' colspan="16"': 16, + ' colspan="15"': 15, + ' colspan="14"': 14, + ' colspan="13"': 13, + ' colspan="12"': 12, + ' colspan="11"': 11, + ' colspan="10"': 10, + ' colspan="2"': 2, + ' colspan="3"': 3, + ' colspan="4"': 4, + ' colspan="5"': 5, + ' colspan="6"': 6, + ' colspan="7"': 7, + ' colspan="8"': 8, + ' colspan="9"': 9, + } + # possible rowspans + pos_rowspans = { + ' rowspan="20"': 20, + ' rowspan="19"': 19, + ' rowspan="18"': 18, + ' rowspan="17"': 17, + ' rowspan="16"': 16, + ' rowspan="15"': 15, + ' rowspan="14"': 14, + ' rowspan="13"': 13, + ' rowspan="12"': 12, + ' rowspan="11"': 11, + ' rowspan="10"': 10, + ' rowspan="2"': 2, + ' rowspan="3"': 3, + ' rowspan="4"': 4, + ' rowspan="5"': 5, + ' rowspan="6"': 6, + ' rowspan="7"': 7, + ' rowspan="8"': 8, + ' rowspan="9"': 9, + } + + t_cells = [] # 2D structure + tl_cells = [] # 1D structure + t_expands = [] # 2D structure + tl_spans = {} # MAP, POPULATE WITH ACTUAL SPANS VALUES, IN SYNC WITH tl_cells + + current_line = 0 + current_column = 0 + current_html_cell_ind = 0 + + current_line_tags = [] + current_line_expands = [] + + if logdebug: + print("") + print("*** {}: {} ***".format(table["split"], table["filename"])) + + colnum = 0 + + if extra_debug: + print("========================== Input HTML ============================") + print(table_html_structure["tokens"]) + print("==================================================================") + + if logdebug: + print("********") + print("* OTSL *") + print("********") + + for i in range(len(table_html_structure["tokens"])): + html_tag = table_html_structure["tokens"][i] + prev_html_tag = "" + next_html_tag = "" + if i > 0: + prev_html_tag = table_html_structure["tokens"][i - 1] + if i < len(table_html_structure["tokens"]) - 1: + next_html_tag = table_html_structure["tokens"][i + 1] + + if html_tag not in ["", ""]: + # Then check the next tag... + # rules of conversion + # Check up-cell in t_expands, in case row-spans have to be inserted + if html_tag in ["", ""]: + if current_line > 0: + if current_column >= len(t_expands[current_line - 1]): + # !!! + return False, {} + up_expand = t_expands[current_line - 1][current_column] + + while up_expand[1] > 0: + if up_expand[0] == 0: + # ucel + current_line_tags.append("ucel") + current_line_expands.append([0, up_expand[1] - 1]) + current_column += 1 + else: + # xcel + for ci in range(up_expand[0]): + current_line_tags.append("xcel") + current_line_expands.append( + [up_expand[0] - ci, up_expand[1] - 1] + ) + current_column += 1 + up_expand = t_expands[current_line - 1][current_column] + # ====================================================================================== + # Fix for trailing "ucel" in a row + if html_tag in [""]: + if current_line > 0: + cur_line_len = len(current_line_expands) + pre_line_len = len(t_expands[current_line - 1]) + + if cur_line_len < pre_line_len: + extra_columns = pre_line_len - cur_line_len - 1 + if extra_columns > 0: + if extra_debug: + print( + "Extra columns needed in row: {}".format( + extra_columns + ) + ) + + for clm in range(extra_columns): + up_expand = t_expands[current_line - 1][ + cur_line_len + clm + ] + if up_expand[0] == 0: + # ucel + current_line_tags.append("ucel") + current_line_expands.append([0, up_expand[1] - 1]) + else: + # xcel + current_line_tags.append("xcel") + current_line_expands.append( + [up_expand[0], up_expand[1] - 1] + ) + # ====================================================================================== + + # 1. Opening cell tags + if html_tag in ["", " 0: + cell_is_empty = False + if cell_is_empty: + out_line["html"]["cells"][current_html_cell_ind]["tokens"] = [] + current_line_tags.append("ecel") + current_line_expands.append([0, 0]) + else: + current_line_tags.append("fcel") + current_line_expands.append([0, 0]) + current_html_cell_ind += 1 + current_column += 1 + + # 2. Closing row tags + if html_tag == "": + if len(current_line_tags) > colnum: + colnum = len(current_line_tags) + # Save everything we read about the line to t_cells + current_line_tags.append("nl") + t_cells.append(copy.deepcopy(current_line_tags)) + tl_cells.extend(copy.deepcopy(current_line_tags)) + if logdebug: + print(current_line_tags) + current_line_tags = [] + + # Deal with expands + current_line_expands.append([-1, -1]) + # Output spans metadata + t_expands.append(copy.deepcopy(current_line_expands)) + current_line_expands = [] + + current_column = 0 + current_line += 1 + # 3. Colspans only + if html_tag in pos_colspans: + if prev_html_tag not in pos_rowspans: + if next_html_tag not in pos_rowspans: + colspan_len = pos_colspans[html_tag] + tl_spans[current_html_cell_ind - 1] = [colspan_len, 1] + current_line_expands[len(current_line_expands) - 1] = [ + colspan_len, + 0, + ] + for ci in range(colspan_len - 1): + current_line_tags.append("lcel") + current_line_expands.append([colspan_len - ci - 1, 0]) + current_column += 1 + + # 4. Rowspans only + if html_tag in pos_rowspans: + if prev_html_tag not in pos_colspans: + if next_html_tag not in pos_colspans: + rowspan_len = pos_rowspans[html_tag] + tl_spans[current_html_cell_ind - 1] = [1, rowspan_len] + current_line_expands[len(current_line_expands) - 1] = [ + 0, + rowspan_len - 1, + ] + + # 5. 2D spans + if html_tag in pos_rowspans: + rowspan_len = pos_rowspans[html_tag] + if prev_html_tag in pos_colspans: + colspan_len = pos_colspans[prev_html_tag] + tl_spans[current_html_cell_ind - 1] = [colspan_len, rowspan_len] + newexp = [colspan_len, rowspan_len - 1] + current_line_expands[len(current_line_expands) - 1] = newexp + for ci in range(colspan_len - 1): + current_line_tags.append("xcel") + current_line_expands.append( + [colspan_len - ci - 1, rowspan_len - 1] + ) + if next_html_tag in pos_colspans: + colspan_len = pos_colspans[next_html_tag] + tl_spans[current_html_cell_ind - 1] = [colspan_len, rowspan_len] + newexp = [colspan_len, rowspan_len - 1] + current_line_expands[len(current_line_expands) - 1] = newexp + for ci in range(colspan_len - 1): + current_line_tags.append("xcel") + current_line_expands.append( + [colspan_len - ci - 1, rowspan_len - 1] + ) + + t_name = "*** {}: {} ***".format(table["split"], table["filename"]) + # check if square + isSquare = otsl_sqr_chk(tl_cells, t_name, logdebug) + # TODO: pad if not square? + if not isSquare: + tl_cells = otsl_pad_to_sqr(tl_cells, "fcel") + # check if cells (bboxes) in sync: + if "cells" in out_line["html"]: + isGood = otsl_tags_cells_sync_chk( + tl_cells, out_line["html"]["cells"], t_name, logdebug + ) + # convert back to HTML + rHTML = [] + if isSquare: + rHTML = otsl_to_html(tl_cells, logdebug) + out_line["html"]["html_restored_structure"]["tokens"] = rHTML + + out_line["html"]["structure"]["tokens"] = tl_cells + out_line["otsl_spans"] = tl_spans + out_line["cols"] = colnum + out_line["rows"] = len(t_cells) + out_line["html_len"] = len(table_html_structure["tokens"]) + out_line["rs_len"] = len(tl_cells) + # save converted line + if use_writer: + if isSquare: + if isGood: + writer.write(out_line) + + if logdebug: + print("{}Reconstructed HTML:{}".format(bcolors.OKGREEN, bcolors.ENDC)) + print(rHTML) + # original HTML + oHTML = out_line["html"]["html_structure"] + print("{}Original HTML:{}".format(bcolors.OKBLUE, bcolors.ENDC)) + print(oHTML) + + return True, out_line diff --git a/docling_ibm_models/tableformer/settings.py b/docling_ibm_models/tableformer/settings.py new file mode 100644 index 0000000..64d0ff7 --- /dev/null +++ b/docling_ibm_models/tableformer/settings.py @@ -0,0 +1,90 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import logging +import sys + + +def get_custom_logger(logger_name, level, stream=sys.stdout): + r""" + Create a custom logger with a standard formatting + + Inputs: + - logger_name: Name of the logger. You can get the class name as self.__class__.__name__ + - level: logging level (e.g. logging.INFO, logging.DEBUG, etc.) + - stream: One of sys.stdout or sys.stderr + + Outputs: + logger + """ + logger = logging.getLogger(logger_name) + logger.setLevel(level) + + # Set the handler + if not logger.hasHandlers(): + handler = logging.StreamHandler(stream) + formatter = logging.Formatter( + "%(asctime)s %(name)-12s %(levelname)-8s %(message)s" + ) + handler.setFormatter(formatter) + logger.addHandler(handler) + + return logger + + +################################################################################### +# System constants +# + +r""" +This is a "generic" logger available to all scripts. +It is encouraged that each class has it's own custom logger with the name of the class. +You can use the "get_custom_logger" function to build a custom logger with a standard format. +""" +LOGGER = get_custom_logger("docling-pm", logging.INFO) + +# Supported dataset types +supported_datasets = ["TF_prepared"] # TF prepared dataset + +# Split names +TRAIN_SPLIT = "train" +VAL_SPLIT = "val" +TEST_SPLIT = "test" + +# Prepared data parts and filename templates +PREPARED_DATA_PARTS = { + # Array with the bboxes (x1y1x2y2) for all cells of the images across all splits. + # The bboxes are indexed with the filename. + # Notices: + # - The bboxes are NOT transformed. + # - If the image filenames are the same across splits, there will be one one entry in the file + "BBOXES": "BBOXES.json", + # Image filenames used for train and val + "IMAGES": "IMAGES.json", + # Mean, std, variance as arrays of 3 (for each color) + "STATISTICS": "STATISTICS_.json", # PRECOMPUTED + # Bboxes of the cells in the form [1, x1, x2, y1, y2] or [0, 0, 0, 0, 0] in case of no box. + "TRAIN_CELLBBOXES": "TRAIN_CELLBBOXES_.json", # NOT USED. + # Array with arrays of the length + 2 of the original cells per image. + "TRAIN_CELLLENS": "TRAIN_CELLLENS_.json", + # Indices of the cells between and at the end. + "TRAIN_CELLS": "TRAIN_CELLS_.json", + # Array with the length + 2 of the original tags per image. + "TRAIN_TAGLENS": "TRAIN_TAGLENS_.json", + # Indices of the tags between and at the end. + "TRAIN_TAGS": "TRAIN_TAGS_.json", + # Ground truth for the evaluation dataset per eval image. + "VAL": "VAL.json", + # Vocabulary: Indices of the word_map_cells and word_map_tags + "WORDMAP": "WORDMAP_.json", # PRECOMPUTED +} + +# Purposes +TRAIN_PURPOSE = "train" +VAL_PURPOSE = "val" +TEST_PURPOSE = "test" +PREDICT_PURPOSE = "predict" + +# The DDP world size when we train in CPU with DDP enabled +DDP_CPU_WORLD_SIZE = 2 diff --git a/docling_ibm_models/tableformer/test_dataset_cache.py b/docling_ibm_models/tableformer/test_dataset_cache.py new file mode 100644 index 0000000..b76ccac --- /dev/null +++ b/docling_ibm_models/tableformer/test_dataset_cache.py @@ -0,0 +1,37 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import logging + +import docling_ibm_models.tableformer.common as c +from docling_ibm_models.tableformer.data_management.tf_dataset import TFDataset + +LOG_LEVEL = logging.INFO +# LOG_LEVEL = logging.DEBUG + + +def dataset_test(config): + r""" + Parameters + ---------- + config : dictionary + The configuration settings + """ + + # model_type = config["model"]["type"] + # Create the device and the Dataset + device = "cpu" + dataset = TFDataset(config, "train") + dataset.set_device(device) + + # Loop over the data + dataset.reset() + dataset.shuffle() + for i, batch in enumerate(dataset): + print("Loading batch: {}".format(i)) + + +if __name__ == "__main__": + config = c.parse_arguments() + dataset_test(config) diff --git a/docling_ibm_models/tableformer/test_prepare_image.py b/docling_ibm_models/tableformer/test_prepare_image.py new file mode 100644 index 0000000..d9e8896 --- /dev/null +++ b/docling_ibm_models/tableformer/test_prepare_image.py @@ -0,0 +1,99 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import glob +import os + +import numpy as np +from PIL import Image + +import docling_ibm_models.tableformer.common as c +from docling_ibm_models.tableformer.data_management.data_transformer import ( + DataTransformer, +) + + +def dump_np(img_np: np.array, fn, n=6): + # Expect to receive a numpy array for an image with the shape [channels, rows, columns] + s = img_np.shape + if s[0] not in [1, 2, 3, 4] or len(s) != 3: + print("Image of invalid shape: {}".format(s)) + return + + channels = s[0] + rows = s[1] + cols = s[2] + w = n + 6 + with open(fn, "w") as fd: + for r in range(rows): + for col in range(cols): + for ch in range(channels): + x = img_np[ch][r][col] + if isinstance(x, np.float32): + f_str = "0:>{}.{}f".format(w, n) + elif isinstance(x, np.uint8): + f_str = "0:>{}".format(w) + else: + return False + + x_str = ("{" + f_str + "}").format(x) + fd.write(x_str) + if ch < channels - 1: + fd.write(" ") + fd.write("\n") + return True + + +def dump_channels(save_dir, fn_prefix, img_np: np.array): + # Dump the np array into 3 files per channel + img_np_ch0 = img_np[0, :, :] + img_np_ch1 = img_np[1, :, :] + img_np_ch2 = img_np[2, :, :] + txt_ch0_fn = os.path.join(save_dir, fn_prefix + "_ch0.txt") + txt_ch1_fn = os.path.join(save_dir, fn_prefix + "_ch1.txt") + txt_ch2_fn = os.path.join(save_dir, fn_prefix + "_ch2.txt") + np.savetxt(txt_ch0_fn, img_np_ch0) + np.savetxt(txt_ch1_fn, img_np_ch1) + np.savetxt(txt_ch2_fn, img_np_ch2) + print(f"{txt_ch0_fn}") + print(f"{txt_ch1_fn}") + print(f"{txt_ch2_fn}") + + +def prepare_image(config): + transformer = DataTransformer(config) + predict_dir = config["predict"]["predict_dir"] + use_normalization = config["dataset"]["image_normalization"]["state"] + + pattern = os.path.join(predict_dir, "*.png") + for img_fn in glob.glob(pattern): + print(f"img_fn: {img_fn}") + + with Image.open(img_fn) as img: + # Dump the initial image in txt files + img_np = np.array(img) + + # Reshape the image in order to print it + img_np_m = np.moveaxis(img_np, 2, 0) + print( + "orig. img_np.shape: {}, reshaped image: {}".format( + img_np.shape, img_np_m.shape + ) + ) + original_fn = img_fn + "_python.txt" + dump_np(img_np_m, original_fn) + + r_img_ten = transformer.rescale_in_memory(img, use_normalization) + print("npimgc: {} - {}".format(r_img_ten.type(), r_img_ten.size())) + + # Dump the processed image tensor in txt files + r_img_np = r_img_ten.numpy() + + prepared_fn = img_fn + "_python_prepared.txt" + dump_np(r_img_np, prepared_fn) + + +if __name__ == "__main__": + config = c.parse_arguments() + prepare_image(config) diff --git a/docling_ibm_models/tableformer/utils/__init__.py b/docling_ibm_models/tableformer/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/docling_ibm_models/tableformer/utils/app_profiler.py b/docling_ibm_models/tableformer/utils/app_profiler.py new file mode 100644 index 0000000..e4ba659 --- /dev/null +++ b/docling_ibm_models/tableformer/utils/app_profiler.py @@ -0,0 +1,243 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import time +from collections import deque +from statistics import mean, median + + +class SingletonClass(type): + r""" + Generic singleton metaclass + """ + + def __init__(self, name, bases, dic): + self._instance = None + super().__init__(name, bases, dic) + + def __call__(cls, *args, **kwargs): + # Create a singleton if needed + if cls._instance is None: + singleton = cls.__new__(cls) + singleton.__init__(*args, **kwargs) + cls._instance = singleton + return cls._instance + + +class Profiler: + r""" + Application specific profiler + Decompose the application into "sections". Each section is a label. + The total time a section consumes is split into "intervals" + Use the `begin`, `end` methods to mark the begining and end of an interval for + a certain section + """ + + def __init__(self): + self._section_dts = {} # section name -> sum(section intervals) + self._section_calls = {} # section name -> number of invocations + self._section_kB = {} # section name -> max kB of used heap + + # section name -> beginning of the last interval + self._last_begin = {} + + def begin(self, section_name, enable=True): + r""" + Mark the beginning of an interval + + Parameters + ---------- + section_name : string + Name of the section + enable : bool + The actual interval entry takes place only if enable is true + + Return + ------ + True if the interval has actuall begun + """ + if not enable: + return False + self._last_begin[section_name] = time.time() + return True + + def end(self, section_name, enable=True): + r""" + Mark the end of an interval for a certain section + + Parameters + ---------- + section_name : string + Name of the section + enable : bool + The actual interval entry takes place only if enable is true + + Return + ------ + True if the section name is valid and an interval for this section has already begun + False otherwise + """ + if not enable: + return False + if section_name not in self._last_begin: + return False + + dt = time.time() - self._last_begin[section_name] + if section_name not in self._section_dts: + self._section_dts[section_name] = dt + self._section_calls[section_name] = 1 + else: + self._section_dts[section_name] += dt + self._section_calls[section_name] += 1 + + return True + + def get_data(self, section_names=None): + r""" + Return a dict with profiling data for the specified sections. + + Parameter + --------- + section_names : list of string + List with the section names to get their accumulative dt + If it is None, all sections are returned + + Return + ------ + dict of dicts + Outer key: section name + Inner keys: "dt": Accumulative time for that section, "cells": Number of calls + """ + # Filter the section names to apply + filtered_names = list( + filter(lambda x: x in section_names, self._section_dts.keys()) + if section_names is not None + else self._section_dts.keys() + ) + data = {} + for section_name in filtered_names: + data[section_name] = { + "dt": self._section_dts[section_name], + "calls": self._section_calls[section_name], + "kB": self._section_kB[section_name], + } + return data + + +class AppProfiler(Profiler, metaclass=SingletonClass): + r""" + AppProfiler is a singleton of the Profiler for application wide usage + """ + + def __init__(self): + super(AppProfiler, self).__init__() + + +class AggProfiler(metaclass=SingletonClass): + r""" + Generic wrapper of Profiler that enables aggregation of profiling statistics around Cycles + + - When a new cycle begins a new Profiler is created to keep the profiling data per section + - Keep the last n cycles in a sliding window manner + - At every time we can get profiling data about the last cycle and statistics over the last n + cycles + """ + + def __init__(self, window_size=20): + self._window_size = window_size + # deque with up to the last "window_size" Profilers. The newest at index 0 + self._cycles = deque() + + def start_agg(self, enable=True): + r""" + Returns + ------- + 0: not enabled + 1: a new scope has started + """ + if not enable: + return 0 + + # Add a new profiler + self._cycles.appendleft(Profiler()) + # In case the deque has grown too much, remove the oldest Profiler + if len(self._cycles) > self._window_size: + self._cycles.pop() + return 1 + + def begin(self, section_name, enable=True): + if not enable: + return False + if len(self._cycles) == 0: + print("AggProfiler begin | Start Aggregator not initialized.") + return False + profiler = self._cycles[0] + return profiler.begin(section_name) + + def end(self, section_name, enable=True): + if not enable: + return False + if len(self._cycles) == 0: + print("AggProfiler end | Start Aggregator not initialized.") + return False + profiler = self._cycles[0] + return profiler.end(section_name) + + def get_data(self): + r""" + Get profiling data for: + - The last cycle + - Aggragated statistics (avg, median) per section and per metric across all cycles + - The dt numbers for the mean/median is the average time for each section ACROSS the cycle + - There is NO need to compute average by yourself. + + Returns + ------- + dict with the structure: + - window: int with the size of the time sliding window + - last: dict with the metrics for the last cycle (as provided by the Profiler) + - mean: dict with the mean metrics per section across the cycle + - section_name + - metric_name: mean of the metric values + - median: dict with the median metrics per section across the cycle + - section_name + - metric_name: median of the metric values + """ + last_data = self._cycles[0].get_data() + data = { + "window": len(self._cycles), + "last": last_data, + "mean": {}, + "median": {}, + } + + # Section -> metric -> [values] + section_metric_values = {} + + # Collect the metrics + for i, p in enumerate(self._cycles): + p_data = p.get_data() + for section_name, m_dict in p_data.items(): + for m_name, m_val in m_dict.items(): + if section_name not in section_metric_values: + section_metric_values[section_name] = {} + s_metrics = section_metric_values[section_name] + if m_name not in s_metrics: + s_metrics[m_name] = [] + s_metrics[m_name].append(m_val) + + # Aggregate the metrics + for section_name, m_dict in section_metric_values.items(): + for m_name, m_values in m_dict.items(): + if section_name not in data["mean"]: + data["mean"][section_name] = {} + if section_name not in data["median"]: + data["median"][section_name] = {} + + mean_v = mean(m_values) + median_v = median(m_values) + data["mean"][section_name][m_name] = mean_v + data["median"][section_name][m_name] = median_v + + return data diff --git a/docling_ibm_models/tableformer/utils/torch_utils.py b/docling_ibm_models/tableformer/utils/torch_utils.py new file mode 100644 index 0000000..09bcde2 --- /dev/null +++ b/docling_ibm_models/tableformer/utils/torch_utils.py @@ -0,0 +1,216 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import torch + + +def model_info(model, verbose=False): + # Plots a line-by-line description of a PyTorch model + n_p = sum(x.numel() for x in model.parameters()) # number parameters + n_g = sum( + x.numel() for x in model.parameters() if x.requires_grad + ) # number gradients + if verbose: + print( + "%5s %40s %9s %12s %20s %10s %10s" + % ("layer", "name", "gradient", "parameters", "shape", "mu", "sigma") + ) + for i, (name, p) in enumerate(model.named_parameters()): + name = name.replace("module_list.", "") + print( + "%5g %40s %9s %12g %20s %10.3g %10.3g" + % ( + i, + name, + p.requires_grad, + p.numel(), + list(p.shape), + p.mean(), + p.std(), + ) + ) + + try: # FLOPS + from thop import profile + + macs, _ = profile(model, inputs=(torch.zeros(1, 3, 480, 640),), verbose=False) + fs = ", %.1f GFLOPS" % (macs / 1e9 * 2) + except Exception: + fs = "" + + print( + "Model Summary: %g layers, %g parameters, %g gradients%s" + % (len(list(model.parameters())), n_p, n_g, fs) + ) + + +# def init_seeds(seed=0): +# torch.manual_seed(seed) +# +# # Reduce randomness (may be slower on Tesla GPUs) +# # https://pytorch.org/docs/stable/notes/randomness.html +# if seed == 0: +# cudnn.deterministic = False +# cudnn.benchmark = True +# +# +# def select_device(device='', apex=False, batch_size=None): +# # device = 'cpu' or '0' or '0,1,2,3' +# cpu_request = device.lower() == 'cpu' +# if device and not cpu_request: # if device requested other than 'cpu' +# os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable +# # check availablity +# assert torch.cuda.is_available(), 'CUDA unavailable, invalid device %s requested' % device +# +# cuda = False if cpu_request else torch.cuda.is_available() +# if cuda: +# c = 1024 ** 2 # bytes to MB +# ng = torch.cuda.device_count() +# if ng > 1 and batch_size: # check that batch_size is compatible with device_count +# assert batch_size % ng == 0, 'batch-size %g not multiple of GPU count %g' % \ +# (batch_size, ng) +# x = [torch.cuda.get_device_properties(i) for i in range(ng)] +# # apex for mixed precision https://github.com/NVIDIA/apex +# s = 'Using CUDA ' + ('Apex ' if apex else '') +# for i in range(0, ng): +# if i == 1: +# s = ' ' * len(s) +# print("%sdevice%g _CudaDeviceProperties(name='%s', total_memory=%dMB)" % +# (s, i, x[i].name, x[i].total_memory / c)) +# else: +# print('Using CPU') +# +# print('') # skip a line +# return torch.device('cuda:0' if cuda else 'cpu') +# +# +# def time_synchronized(): +# torch.cuda.synchronize() if torch.cuda.is_available() else None +# return time.time() +# +# +# def initialize_weights(model): +# for m in model.modules(): +# t = type(m) +# if t is nn.Conv2d: +# pass # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') +# elif t is nn.BatchNorm2d: +# m.eps = 1e-4 +# m.momentum = 0.03 +# elif t in [nn.LeakyReLU, nn.ReLU, nn.ReLU6]: +# m.inplace = True +# +# +# def find_modules(model, mclass=nn.Conv2d): +# # finds layer indices matching module class 'mclass' +# return [i for i, m in enumerate(model.module_list) if isinstance(m, mclass)] +# +# +# def fuse_conv_and_bn(conv, bn): +# # https://tehnokv.com/posts/fusing-batchnorm-and-conv/ +# with torch.no_grad(): +# # init +# fusedconv = torch.nn.Conv2d(conv.in_channels, +# conv.out_channels, +# kernel_size=conv.kernel_size, +# stride=conv.stride, +# padding=conv.padding, +# bias=True) +# +# # prepare filters +# w_conv = conv.weight.clone().view(conv.out_channels, -1) +# w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var))) +# fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.size())) +# +# # prepare spatial bias +# if conv.bias is not None: +# b_conv = conv.bias +# else: +# b_conv = torch.zeros(conv.weight.size(0)) +# b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps)) +# fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn) +# +# return fusedconv +# +# +# def load_classifier(name='resnet101', n=2): +# # Loads a pretrained model reshaped to n-class output +# import pretrainedmodels # https://github.com/Cadene/pretrained-models.pytorch#torchvision +# model = pretrainedmodels.__dict__[name](num_classes=1000, pretrained='imagenet') +# +# # Display model properties +# for x in ['model.input_size', 'model.input_space', 'model.input_range', 'model.mean', +# 'model.std']: +# print(x + ' =', eval(x)) +# +# # Reshape output to n classes +# filters = model.last_linear.weight.shape[1] +# model.last_linear.bias = torch.nn.Parameter(torch.zeros(n)) +# model.last_linear.weight = torch.nn.Parameter(torch.zeros(n, filters)) +# model.last_linear.out_features = n +# return model +# +# +# def scale_img(img, ratio=1.0, same_shape=True): # img(16,3,256,416), r=ratio +# # scales img(bs,3,y,x) by ratio +# h, w = img.shape[2:] +# s = (int(h * ratio), int(w * ratio)) # new size +# img = F.interpolate(img, size=s, mode='bilinear', align_corners=False) # resize +# if not same_shape: # pad/crop img +# gs = 64 # (pixels) grid size +# h, w = [math.ceil(x * ratio / gs) * gs for x in (h, w)] +# return F.pad(img, [0, w - s[1], 0, h - s[0]], value=0.447) # value = imagenet mean +# +# +# class ModelEMA: +# """ Model Exponential Moving Average from https://github.com/rwightman/pytorch-image-models +# Keep a moving average of everything in the model state_dict (parameters and buffers). +# This is intended to allow functionality like +# https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage +# A smoothed version of the weights is necessary for some training schemes to perform well. +# E.g. Google's hyper-params for training MNASNet, MobileNet-V3, EfficientNet, etc that use +# RMSprop with a short 2.4-3 epoch decay period and slow LR decay rate of .96-.99 requires EMA +# smoothing of weights to match results. Pay attention to the decay constant you are using +# relative to your update count per epoch. +# To keep EMA from using GPU resources, set device='cpu'. This will save a bit of memory but +# disable validation of the EMA weights. Validation will have to be done manually in a separate +# process, or after the training stops converging. +# This class is sensitive where it is initialized in the sequence of model init, +# GPU assignment and distributed training wrappers. +# I've tested with the sequence in my own train.py for torch.DataParallel, apex.DDP, and +# single-GPU. +# """ +# +# def __init__(self, model, decay=0.9999, device=''): +# # make a copy of the model for accumulating moving average of weights +# self.ema = deepcopy(model) +# self.ema.eval() +# self.updates = 0 # number of EMA updates +# # decay exponential ramp (to help early epochs) +# self.decay = lambda x: decay * (1 - math.exp(-x / 2000)) +# self.device = device # perform ema on different device from model if set +# if device: +# self.ema.to(device=device) +# for p in self.ema.parameters(): +# p.requires_grad_(False) +# +# def update(self, model): +# self.updates += 1 +# d = self.decay(self.updates) +# with torch.no_grad(): +# if type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel): +# msd, esd = model.module.state_dict(), self.ema.module.state_dict() +# else: +# msd, esd = model.state_dict(), self.ema.state_dict() +# +# for k, v in esd.items(): +# if v.dtype.is_floating_point: +# v *= d +# v += (1. - d) * msd[k].detach() +# +# def update_attr(self, model): +# # Assign attributes (which may change during training) +# for k in model.__dict__.keys(): +# if not k.startswith('_'): +# setattr(self.ema, k, getattr(model, k)) diff --git a/docling_ibm_models/tableformer/utils/utils.py b/docling_ibm_models/tableformer/utils/utils.py new file mode 100644 index 0000000..82fd44a --- /dev/null +++ b/docling_ibm_models/tableformer/utils/utils.py @@ -0,0 +1,376 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from PIL import Image +from torchvision.models.resnet import BasicBlock, conv1x1 +from torchvision.ops.boxes import box_area + + +def remove_padding(seq): + r""" + Remove the trailing zeros from the provided input + + Parameters + ---------- + list: List of integers + Predicted sequence + + Returns + ------- + list: List of integers + The part of the input before the zero padding + + """ + pad_len = 0 + for x in reversed(seq): + if x != 0: + break + pad_len += 1 + if pad_len == 0: + return seq, 0 + + un_padded = seq[:-pad_len] + return un_padded, pad_len + + +def probabilities_to_predictions(probabilities): + r""" + Convert probabilities to predictions + + Parameters + ---------- + probabilities : Tensor[batch_size, vocab_size, seq_len] + All log probabilities coming out at the last stage of the decoder + + Returns + ------- + predictions : tensor [batch_size, output_sequence_length] + The prediceted trags + + """ + # max_idx: [batch_size, seq_len] + max_idx = torch.argmax(probabilities, dim=1) + return max_idx + + +def print_target_predict(target, predictions, filenames=None, batch_idx=0): + r""" + For the Tags, print the target and predicted tensors for the specified batch index + + We expect to have the batch size as the first dimension. + Only the specified batch is extractred and the remaining dimenions are flattened. + The results are printed as 2 lists with the target on top and the predictions below underlined + + Parameters + --------- + target : tensor [batch_size, output_sequence_length] + The ground truth tags + + predictions : tensor [batch_size, output_sequence_length] + The prediceted trags + + filenames : list of string + The actual filename that provides the data + + batch_idx : int + Which index in the batch dimension will be printed + """ + target_flat = target[batch_idx].flatten() + predictions_flat = predictions[batch_idx].flatten() + target_label = "target" + predict_label = "predict" + if filenames is not None: + target_label = filenames[batch_idx] + label_len = max(len(target_label), len(predict_label)) + print("{}: {}".format(target_label.ljust(label_len, " "), target_flat.tolist())) + print( + "{}: {}".format(predict_label.ljust(label_len, " "), predictions_flat.tolist()) + ) + + +def load_image(full_fn): + r""" + Load an image from the disk as a numpy array + + Parameters + ---------- + full_fn : string + The full path filename of the image + + Results + ------- + img : numpy array: (channels, width, height) + The loaded image as a numpy array + """ + with Image.open(full_fn) as f: + img = np.asarray(f) # (width, height, channels) + img = img.transpose(2, 0, 1) # (channels, width, height) + return img + + +def resnet_block(stride=1): + layers = [] + downsample = nn.Sequential( + conv1x1(256, 512, stride), + nn.BatchNorm2d(512), + ) + layers.append(BasicBlock(256, 512, stride, downsample)) + layers.append(BasicBlock(512, 512, 1)) + return nn.Sequential(*layers) + + +def repackage_hidden(h): + r""" + Wraps hidden states in new Tensors, to detach them from their history. + """ + if isinstance(h, torch.Tensor): + return h.detach() + else: + return tuple(repackage_hidden(v) for v in h) + + +def accuracy(scores, targets, k): + """ + Computes top-k accuracy, from predicted and true labels. + + :param scores: scores from the model + :param targets: true labels + :param k: k in top-k accuracy + :return: top-k accuracy + """ + + batch_size = targets.size(0) + _, ind = scores.topk(k, 1, True, True) + correct = ind.eq(targets.view(-1, 1).expand_as(ind)) + correct_total = correct.view(-1).float().sum() # 0D tensor + return correct_total.item() * (100.0 / batch_size) + + +def clip_gradient(optimizer, grad_clip): + """ + Clips gradients computed during backpropagation to avoid explosion of gradients. + + :param optimizer: optimizer with the gradients to be clipped + :param grad_clip: clip value + """ + for group in optimizer.param_groups: + for param in group["params"]: + if param.grad is not None: + param.grad.data.clamp_(-grad_clip, grad_clip) + + +class AverageMeter(object): + """ + Keeps track of most recent, average, sum, and count of a metric. + """ + + def __init__(self): + self.reset() + + def reset(self): + self.val = 0 + self.avg = 0 + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + self.val = val + self.sum += val * n + self.count += n + self.avg = self.sum / self.count + + +@torch.no_grad() +def bip_accuracy(output, target, topk=(1,)): + """Computes the precision@k for the specified values of k""" + if target.numel() == 0: + return [torch.zeros([], device=output.device)] + maxk = max(topk) + batch_size = target.size(0) + + _, pred = output.topk(maxk, 1, True, True) + pred = pred.t() + correct = pred.eq(target.view(1, -1).expand_as(pred)) + + res = [] + for k in topk: + correct_k = correct[:k].view(-1).float().sum(0) + res.append(correct_k.mul_(100.0 / batch_size)) + return res + + +def box_cxcywh_to_xyxy(x): + x_c, y_c, w, h = x.unbind(-1) + b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)] + return torch.stack(b, dim=-1) + + +def box_xyxy_to_cxcywh(x): + x0, y0, x1, y1 = x.unbind(-1) + b = [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0), (y1 - y0)] + return torch.stack(b, dim=-1) + + +# modified from torchvision to also return the union +def box_iou(boxes1, boxes2): + area1 = box_area(boxes1) + area2 = box_area(boxes2) + + lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2] + rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2] + + wh = (rb - lt).clamp(min=0) # [N,M,2] + inter = wh[:, :, 0] * wh[:, :, 1] # [N,M] + + union = area1[:, None] + area2 - inter + + iou = inter / union + return iou, union + + +def generalized_box_iou(boxes1, boxes2): + """ + Generalized IoU from https://giou.stanford.edu/ + + The boxes should be in [x0, y0, x1, y1] format + + Returns a [N, M] pairwise matrix, where N = len(boxes1) + and M = len(boxes2) + """ + # degenerate boxes gives inf / nan results + # so do an early check + assert (boxes1[:, 2:] >= boxes1[:, :2]).all() + assert (boxes2[:, 2:] >= boxes2[:, :2]).all() + iou, union = box_iou(boxes1, boxes2) + + lt = torch.min(boxes1[:, None, :2], boxes2[:, :2]) + rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:]) + + wh = (rb - lt).clamp(min=0) # [N,M,2] + area = wh[:, :, 0] * wh[:, :, 1] + + return iou - (area - union) / area + + +class MLP(nn.Module): + """Very simple multi-layer perceptron (also called FFN)""" + + def __init__(self, input_dim, hidden_dim, output_dim, num_layers): + super().__init__() + self.num_layers = num_layers + h = [hidden_dim] * (num_layers - 1) + self.layers = nn.ModuleList( + nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]) + ) + + def forward(self, x): + for i, layer in enumerate(self.layers): + x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) + return x + + +def generate_square_subsequent_mask(sz: int, device: str = "cpu") -> torch.Tensor: + """Generate the attention mask for causal decoding""" + mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1) + mask = ( + mask.float() + .masked_fill(mask == 0, float("-inf")) + .masked_fill(mask == 1, float(0.0)) + ).to(device=device) + return mask + + +class EarlyStopping: + """Early stops the training if validation loss doesn't improve after a given patience. + Source from: https://github.com/Bjarten/early-stopping-pytorch + """ + + def __init__(self, patience=2, verbose=False, delta=0, trace_func=print): + """ + Args: + patience (int): How long to wait after last time validation loss improved. + Default: 7 + verbose (bool): If True, prints a message for each validation loss improvement. + Default: False + delta (float): Minimum change in the monitored quantity to qualify as an improvement. + Default: 0 + path (str): Path for the checkpoint to be saved to. + Default: 'checkpoint.pt' + trace_func (function): trace print function. + Default: print + """ + self._patience = patience + self._verbose = verbose + self._counter = 0 + self._best_score = None + self._early_stop = False + self._val_loss_min = np.Inf + self._delta = delta + self._trace_func = trace_func + + def __call__(self, val_loss): + score = -val_loss + save_checkpoint = True + if self._best_score is None: + self._best_score = score + save_checkpoint = True + if self._verbose: + verb = f"Validation loss decreased ({self._val_loss_min:.6f} --> {val_loss:.6f})." + self._trace_func(verb) + self._val_loss_min = val_loss + elif score < self._best_score + self._delta: + self._counter += 1 + self._trace_func( + f"EarlyStopping counter: {self._counter} out of {self._patience}" + ) + if self._counter >= self._patience: + self._early_stop = True + save_checkpoint = False + else: + self._best_score = score + save_checkpoint = True + self._counter = 0 + if self._verbose: + verb = f"Validation loss decreased ({self._val_loss_min:.6f} --> {val_loss:.6f})." + self._trace_func(verb) + self._val_loss_min = val_loss + return save_checkpoint + + +def print_dict(m: dict): + r""" + Print dict elements in separate lines sorted by keys + """ + if len(m) == 0: + return + + # Check if the key is a stringified integer + first_key = next(iter(m)) + is_numeric = isinstance(first_key, str) and first_key.isnumeric() + if is_numeric: + keys = sorted([int(k) for k in m.keys()]) + else: + keys = sorted([k for k in m.keys()]) + + for k in keys: + if is_numeric: + v = m[str(k)] + else: + v = m[k] + print("{}: {}".format(k, v)) + + +def print_list(lst: list): + r""" + Print list elements in separate lines + """ + for i, elm in enumerate(lst): + if isinstance(elm, list): + print("{}: ({}) - {}".format(i, len(elm), elm)) + else: + print("{}: {}".format(i, elm)) diff --git a/docling_ibm_models/tableformer/utils/variance.py b/docling_ibm_models/tableformer/utils/variance.py new file mode 100644 index 0000000..3cd153e --- /dev/null +++ b/docling_ibm_models/tableformer/utils/variance.py @@ -0,0 +1,175 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import logging + +import numpy as np + +import docling_ibm_models.tableformer.settings as s + +LOG_LEVEL = logging.INFO + + +class MyWelford: + r""" + Running computation of the sample mean and sample variance using Welford's algorithm + """ + + def __init__(self): + self._i = 0 # Running index + self._m = 0 # Running mean + self._s = 0 # (n - 1) * variance + + def reset(self): + r""" + Reset the object + """ + self._i = 0 + self._m = 0 + self._s = 0 + + def add(self, xi): + r""" + Invoke add each time a new sample arrives + + Inputs: + xi: The next sample of data + """ + self._i += 1 + old_m = self._m + self._m = self._m + (xi - self._m) / self._i + self._s = self._s + (xi - self._m) * (xi - old_m) + + def results(self): + r""" + Get the computed mean, variance and standard deviation up to now + + Outputs: + m: Sample mean + v: Sample variance + std: Sample standard deviation + """ + if self._i <= 1: + return None, None, None + + # v = self._s / (self._i - 1) # Sample variance + v = self._s / (self._i) # Population variance + std = np.sqrt(v) + return self._m, v, std + + +class MyWelfordImg(MyWelford): + r""" + Welford algorithm to calculate running mean and sample variance for images + """ + + def __init__(self): + super(MyWelfordImg, self).__init__() + + def add(self, img): + r""" + Input: + img: An image numpy array (channel, width, height). The only requirement is to have the + channels as the first dimension and have 3 dimensions in total + """ + channels = img.shape[0] + flat_dim = img.shape[1] * img.shape[2] + img_r = img.reshape(channels, flat_dim) + + for i in range(flat_dim): + super(MyWelfordImg, self).add(img_r[:, i]) + + +class ChanVarianceImg: + r""" + Chan's algorithm to compute a running variance with support of sub-samples + In this implementation each sub-sample is an images + + Math for the original paper: + https://github.ibm.com/nli/variance_formulae + """ + + def __init__(self): + r""" """ + self._first = True + # Size of the calculated dataset + self._n = 0 + # Sum of the samples for the 3 image channels + self._t = 0 + # Sum of the square differences of the deviations of the samples from the mean + self._s = 0 + + def add(self, img): + r""" + Add the provided image to the computation of the dataset statistics + + Input: + img: An image numpy array (channel, width, height). The only requirement is to have the + channels as the first dimension and have 3 dimensions in total + """ + ch = img.shape[0] + n = img.shape[1] * img.shape[2] + img = img.reshape(ch, n) + img_t = img.sum(axis=1) + img_t_v = img_t.reshape(ch, 1) + diff = (img - (img_t_v / n)) ** 2 + img_s = diff.sum(axis=1) + + if not self._first: + c = (self._n / (n * (self._n + n))) * ( + ((n / self._n) * self._t - img_t) ** 2 + ) + self._s += img_s + c + self._t += img_t + else: + self._s = img_s + self._t = img_t + self._first = False + self._n += n + + def results(self): + r""" + Get the computed statistics + + Output: + mean: Mean for the complete dataset + var: Population variance for the complete dataset + std: Population standard deviation for the complete dataset + """ + mean = list(self._t / self._n) + var = list(self._s / self._n) # Population variance + std = list(np.sqrt(var)) + + return mean, var, std + + def reset(self): + r""" + Reset the object to start over again + """ + self._n = 0 + self._t = 0 + self._s = 0 + self._first = True + + +if __name__ == "__main__": + logger = s.get_custom_logger("variance", LOG_LEVEL) + + n = 50000 + channels = 3 + width = 448 + height = 448 + + my = ChanVarianceImg() + # Generate random images + for i in range(n): + logger.info(i) + img = 255 * np.random.rand(channels, width, height) + my.add(img) + + # Calculate the statistics + m, v, std = my.results() + assert m.shape == (3,), "Wrong mean dimension" + assert v.shape == (3,), "Wrong variance dimension" + assert std.shape == (3,), "Wrong std dimension" diff --git a/docs/tablemodel_overview_color.png b/docs/tablemodel_overview_color.png new file mode 100644 index 0000000000000000000000000000000000000000..343b42b343e2456c67c219823af9d5e358c227ba GIT binary patch literal 242920 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 -Fq#y(okCF;SJ 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 D6hV&Sz|AScz%zNc9n|2 z|Gnyz-NH!iqFObFFE>FGZSkF~0Ozo*sdQ^Nv&b1~-(}nL&8J?amR#};^7*df1Rw8% z_u&!|;o@eGEG>%gD*Oi3?mVLihJfW-#vxDk%YP3XkKr5cM8@v z+fU;+{axZ?vIVP%peTzHwH=dL0|huAFac^^VNz4{KF%Y-Lw?O_Acm+|c`L!`j0b+x z9vD(_P8Dq?p~e_*pF|sFAoWmr*p90MZJxTC+iJ>}=*_d=yi)1PZOXJ7=)MM`$H!GV z9Mb6@VLsvobf%n{%ggc_&wu6h;B1B(+rvVVptksKUI4#a_8;*`UUDv0UPQq>Vf?}} z%2ZX4f9)n~NidKmr_TJDuuX6G2`+0F{~{RnpB87pKbVb8CT5#IeZpQ$K{!#nUb=Jk zF-=M02Pz%g=pHC}-U4Oe-yz}VMd_Pd@qw-Twpx#jxYo#!8Wma;r&kyB=U}?~TG$5H z=w8|5NOz-1bl$H1WpRI^Mk1kZW{cfqO(@ zSH72WeOjP3Sfsg084vGmmdG+Q3Z}dv+Z&&lB@u#h)7|hz;^mM#hBo+983Vobcl6es zLxlv?O#=Z25cr*t8^ro5Ef-FZsO}Kj%tH|vA)$d<{yFf8P zbRKnnx*;p;p)q&V=)|!4rHexRbT7J2;M1?0?2q|IA7^QV;|#oWcty_Jv-)Z#62pp=Pvi11bZCtB@~Vk2%`>Hf6Za>{UOZ{cyH!~ z_U`?KYWzMbPj@56`YFo&!4d2)sjrZPI(#2JUQ6j*kIsZO`c=YCi2kKhRit0{ z{iG6?NbOnze-)r?3Sc*}Y}$fljVZB51`oQ&&w*Ad#i|c6X}d%M2HOA3StW{S)f#k? zWiE?ho1aBCPX|eHtZP-xo4glOAz7grX>AXI+=6l7cyHy)aCoDCN62dLOCztTSsoJ(865Fcfm1 zNkdv2eK4O3z_u`q`yY{)1LdroAMdA0rGRsCVOO==f7pRe2@+Kg%#lV*c7|X&>d)y6 zZo1JaABA0Z=6H{%0P!=2o}zlc=w3PR=zaGh$-vccSq=XZb;7OlAcvT+iCeZ*`j?H= zykeSyCwq6{=a(DG#;=@`VzHdQP}ZO={3=PyyU#*x;aaa>&cT^W$@@rdV0GLEc3P?5 zPXG$ZQeE$n%r)EWqht$LF3VnquEo6nnSgb!SW^AXJNn~sQIL4Cr<vHB0M@LwC22V z{1WM_GWnfmOV8O1VIeD6vp-@`tL@q+xVqS{Ms3F|HTYi5=~F1Vf6PzytpX%<6UjH5 zv@TVi`CunxLs9htX^!x;?*2a=C$b%t0VirKJ6!zY>I7?QQvJ9PA^#C%TPk71@E+3W zk{M%DT~wi$-FM)RB!X+JSS2|R#p?2DquFj&w8{_N1Z3TCRv&G*MRR^AJ0s9pqAJ+& zdI9s4j`Xq@J@>gYXirHDm@@mJoa25ftWR*7extiDmCtUWHM!;OgWl`-Fg3eAu?%c0 zzMn!}yFK|vk1kpRqp0{5H!?#wylcThGQ+;Nfy==bFvsUj6Y5o3ib&FSl~n0-IeT0m zc_oU;qC0| z)~Ig?#&Voaa*$kX6RAe@FUg4t+2BX*ZYEgBSBv{;5Y<`Mp;N2Q_H4 z_y37be*hkjq|!fHezm(QF-Lxdnwg*Z^XI`?eBCdmZ6TH#RiHST7B`&XO_{@0iP#cj zC(~nP418t(b8kIS%)^a5GN(cGBW@*Nq}OH%QGX5t|4vXRUh&$mo!baQ48H~G()q=; z-(3R!hFBzeXx~FnSTeiTBp+S2y*J&T^P*r0DeybKgjA$V$rsfht&L#ctfbegf_>w- z#DPW;QmK32=NtKl(oVX>HrCt0C^9zA5@~uWP>Zdv1ywO+!{fCjUp%1>l}pcrMId3k z1?q`Fwn%UGqoAhhYfY@DEc5B&FRgEQ(xOdU=A_sctcaVOgJbzPZL%2(54j#NZ7U36 zr+2v6(c>Av>B7ES1imzF=0utXn-DA-y5&WFurgub3_HQ)B18v>9iD; z;0t7%kLh#KS~`xsve~luqvW2-M~+iMEvth@)zG{c+zQSj*$1L&s)?GPWO#04cC;k^ z)RjzAkoyF+zo1wi&C|@uon{!7!M1{#F;D4~eb;z}zcYQ^3CNSx{P$7uMT`eW7X>r^ zMs0t8lWT;w!Xda6qxl0E*!nr|%z!e5q5hUe=^*8%WmJ#V!U*5E6R454vOS)$ecjc; zxIv(N#I`!#TR$|9^8ITQCe6nEZ=%ry_3@40ZzlIr{rmz)rE3ZZM*f`a^|Zk8#peg) zyo>6Rvu117ybG*r?E$BgxXMH~`Rn2^{Jk^#8t3Ryhl}snNVrDw(<_@+{psFLRvVfp9*XIxjy^^iW-*ET=b+521%k1c-#0`i4HU{Y`_ zoOSSTgb(-P6w~qEYVstYsIs~hXSVYYTHmnEo69GN zw)8t<%Cuueu>6iZt`9lH4c!?WmYr~=q-w@{Q`pXb=ikE6KWkUDW2}fRinxBzV)d$= z!93OEt32=gK5RYaFE#HeIc4?CxQL2D#ynFaF|?W!;k-W0x6lNG;_14wV~qeBpzCtW zQrh{EMjfr+uE%L;=m0r!OJA0!7jXTGLM&V;-Vv^RX+RA@Qh?`fuD1JO6Q9IAOYo3; zCuTb(C~R^&f7@T|n%`Rx-Iyc@8NIaZ9gS7qP1deOV45}Wf?tV^xaR4RS-{WR;z#9o zUtKfnqJQz~(z)o5xHp|8z2}@qU7o+nrb-TzYZs4fe#T87?3B(v11)phfyl|9W1#h_qYAOEP~U?BkRI!fd$KJH7gx}C}wZw+M8I($YFxDEWQdG`z=@?M5s=jwQ_ zF@qHFcEbZ?BX?QV3vYkHr)J)tVq#bN>xxfM>z-;hwnpbJEdvf$!H(}J5C|<^mSGV` z)A#&h-lVB4%G|WyA8`KUyW3J8yXy;TCYx>~RsCM2?Pl;Nu?CPOe3;A>;3lk9i;4S# z`gHwo>XX_j_6hY#nm%Q`^-wj|C(-}dnwjK^q5k>c{byROhKe2GM%82tv`o!%>QSs@ zmX_w0td!MsS?LL=60=M(ZuNjlZ|O2F~d%{`ih9)#gmn!cISx1n) z4Q&zmCin=2Tco-&kC+VI$oaQ$|Ibk6Jt27^gUa+S^)OS%*Jg%-Im%Ie3##Led=*`M z5B(&YiUf};rzMZxqvy9hufP?H81|QS3i*L32upKl2bSUd!54>LSe(!I)Jqu&{5jTW zy<<$zIX`n=5_<}6Z)$`nvk$!L^!E-IN%Jy$w~l3v6Eky#kS!aPJJoNo1)h#zW{GRR z;Ih1(IR^^N&8$Rr#vgkeq4srqm9d`<0CFk{p^!x% zA>_icj-D#-1v0lWlK>DbFfAv<_^0kFD%_zdJ_KGwg$hZa@~H&p1W2H~v~7QZ4KU9i zGZuavEOWwM`?KE}Cf-DZSQyOb;Bri)U2OFaAo<5r+>GXlGxfxk75PA?za=>2M_4Rp zfIH${T2IIFw<$przwwUXad7gxVEKiRj~al=ygrv^KkT>eKes-qw#Sz7fh?oe2^xDA zQa%tQ@gT)+)^2-QDMtB6$PJYx$j94!T~$bR;1!`A*EM7#mZ_O6^v3l2LYse?g+;R6 z-68X&Uff%K$okCQeMn)3Lc{&ncZhEZv#3pyV}voh$t=zNHWlNaX4^t3Zx0AraKc6f z*Y$r@ZM4ED4H#RyrM@>yf4>O-p)z=1Q%b*IcWvrW!Ma9Jo8FpA0WCjO;xzxM&%M7X z8Gk}YO^rQ;~y<7IT+1C4bl8jtNqTTs(Bd`}6AwUMQTh10X$HwwvPC$xsA*F5qt8Sf`MAP1HB}}QC*Rsj-9&j2exU#p5tKKbGBlpNuvTrANJOjS^N2ePf zcYKy=k!W_&=wSR6CJL+3CC4=0cHIgyS!Mt76VYT7nJC0+ixJz zVq7YrA=*z<55q;fVfTjy(g2%%bS5WESv2DXtRL|s?b$;WFjdpY%$HJ$dHgX zV$g~!GH+hv#=Xvp(`dp|-=IJ*&vOq9{`~(OEpH5< zso%pOo?JS5)A#4^sHV%$)|>x|R^b%~l06c6i;zv1> z*#&B%6St|LbQ`qOVEgOw)k3+2cIz|j>EuOn{}L7#`U4^YV_Fmg1`xCgQfjM)7YVf^ zsa^B3&wk#Z38(|(jxWJ6C!JpSwh_==1@Nw)^2Sz+z*vFf64T}n;Do9#HLFQm{b8)? zufvQD}s;S~~GSsz-z|OP%FO zX-KmWPXP&nLhwLxCm12ZB^b^q$vJt9krHjkdAs39AfH7~qFEyU6LX}s{YU2SlineZ zwfgUp{j(sQS%|KatHzBo`Iwioehf1|V~ z%D8*^ow4ElNGk6mZ`+HyBS%eoiJA6TC#p;ux7!ER|E_s15lE!_?d(E^zlDm4*UfQi z%{^!{>+!Q(#WOHm4*yk%85mV||7hyL%VhM^fUVJGz|W0!nqu_WgGt7t5xs|(`M~XX z5R#WK1+6Kov?`V?tR>NL=cGI#FooQwIr8$x_FU|VDexW4%NwQYfe-!-(r8(+UpHm5 z_CAvB4D_+&YG?_I;xFMLgO_MusV~mHrmE<0#WR>HjJzW7CSBk`t3(bG;cV zcU+YMAG7ot9Q22S?@d~?YH7t-%710Y-A~k`_WlK~rJGMROq=3gQ7-Nne={?j!|2@B zHl+2DeNPpa3g!x{7~aS>mOvk!lg$B!p0c*>Ok}cOfB}C4ndy4jl3#oFCg0X^q*>Zo z)7w2>!o+*Sfo{w3zi#s1cl(bZ7mdwH{K$IYkCx3lQOY=>am+733e8IB;u2Hg>UR3X zjX%_gYU^OGN=`>?$}}Z*pW-8dTuW# zKde7oz;S@qFhyn!Bly8L=Mn09lb=m0)N@L zfRvekS3nd#%z^Xur`i98=l%vS{`VUR1*i?*qGg-@b#nF52&m|lq`RHqv@B6wVNo5( zrvVpQoyUH=IU&d)0pwkSQN@wVmo=DhDFnLT@_!l*cWlF|*9$i$xhj$@NXSQr2YPZ< z<*wJ)dypy}0(BiTBx;6nOCni~(4Pp)=oCo=B>iYxv-(ztKnOZFUjtUtd$1tu13@HG zR1dOoKAl51I6r!rk`1Z3OTeD!zGQQwc7xaV4ULor%WEotR86hca*x1Nq=dfFf?Rj9 zjK^w-br7b9gB3QDWwm;v^N@1tja^%p0!u@Jq}Zk`Z_Tz;k?ezzG>+6RVEVR^!68*+ zUi8f!J8vwJRgo@tPw+^5yGq$jEmO9QY5E1!u*U`VT?nkS7QoT0WlAY5F+9SeulyZk z{_i)PvJ!b;yV@1A|14+IHL#HL+L1gW9{Of!;OWczo&i~NY#;3VUQfn25J;olonx1q za|_x{b!epom5Xu+(hKn3RdquFB=?@rZSOH3zzpkh!7Y!Yj5~DhBp zG%2+F#71}?pNfw{lkc|nb|)o_nCY&z&+$$Gjpt*T5%tMwp=38Uisi%AP8rc%_dS?k ze{CI^=f$eAJ5p9)2-l;y`1Y6zYxFym856T&l#*{yEWWCW{bJM^>wMY=X8J{wh@ms} zb%I2sAjCC^;4Q9|?s zI-h;jzowYS{8YBc>XXHT<+R?2^)v1+{?89`bm<9X=4xqvwEJ3k9>#g*WJ*{X6(RX4 z&6CIBUMCDD1p=gZ=3r7*S_@te!1&3J7g{?K3v5O-Ym&$!_k*-;=GIB4M`3f84{7Ld zIyPgod=2Y)}{2@r}^=KLK4+?oyBQ^lleCSA{qr$l{6p4YfzSr| zTP_;|=t*(_>R-j8V>s8}W;#VTI2NOEpi|=nNbTi0?Vfob-OX&+z z-H9&{SL}}Vc3SF;jjb|@TP($R4t}!5AyteQiD>`Z%R7PvahBPUzu!w=7_og*nCvy0 zfc28cmDf)Vu^f+v$URkFHcmEjp(VU1^b);#%5q*BxkdTjYJZQ1eHeXVpd-oj`{9It6=B2T zg#4}gqcQxZM{p)Yb=oYjJXLF**1vs7txXXOV3Az__m=xmQ!Z~Is-OQVp%py_?-*Ny zWuT zIzP=Zf{Bj$f|IjKu1ajRBnqR%e|^bI(<-kq3h}5a{`n*F611D*^&0YsZ>=d&&1zRY z$4ksg6`s59*iyBUhNCg7rg9>zTkaq>KYjatVat*J!qq&mBgicQF{#kzqQ5g*+56tw zi9#6^dBqDV&!H+S(-3Mg!C#$^RG>~nuS%oC-5=>8YG>fz1%k=qIHm zs{;doWUYOI27pwxg}m+E4FgmOqXT7M^!EIfIV_ zy?ENoW;J|?1ce#YWVEejRC}yD?V;q02PU2{$oP68C z{GDphEE5)G-Q}wL3l1{1i#5V{X~Ni~H>4!6o17uK+av{au`xGPO@{mS`?FLITsNqY z1IW;3Qa0n+PeCG8(GP1 z_YzI+#eaFxN@KTXIc(`I3K0%uta^>>r~I@JK_gO``}N`0*T&g%D)EyKa%?d-M9}Y@ z8=;T-NE)yACh;D;(OcKbrVQ`G6eTdTad?R)Lb!4|bXm2w#hm74hRLqZhd2K@vTWWG z!0k!qBBqziav8n&g#|5HsH`BBEs9+|({GRm>0ejOg`lGna?C9+(w%#}+}or&iaj#0 z@y@lE4tBsNfhl_F2;K8x^=t)Fo}Z*Q?i;>UO)GXbP(-{i$j8(CX!bgeUAr?+^ds1p zWP~qAq4`K&=&i_Bj5|2es#l`-=D3jzy2F+E4<3RW3){envjeC*yYj~?_O&CvWR#-|z4}zdF|?H69{+AV!|E7BQuZ5TJWUosl@~Lt zfRUY?f5!!n=UvJ%d+Qm+En6+(>~3Ff?@O7xU|5jYX850H{{NpeAY-V}KJ}Z@PigLt z@Osny-k01oxlKQ|>#joHBrERamP+0gqp;9JRg&Oni>~Iryz~ZaljqG?)pVbmt|m42 zbJt^!JN+vm?O=MtQC7w#Uj}^ZL-kTu97pB-+PxKOe8&wD#M}#eiDxXfMkSAe8YPLt zI<^*|hSDg0J3%*IJ_8S8Ozz;cXP^|_HK$Q8!Pi$<)f%7JeSjbZ0Usu1q(+KGt_e7bcX5HuiGZy?FCK%%{yv)G9+m0&#`_oA4N+9U^ zBa28;N^q5}_r-%tZ;bkOhaK&Ifj>{;@ z7ZYCrY&nW}M@a==S3DW*Egze>OOpgRfK7X)&l&CJb2vmr`3SL>dV8?K?|o-CY4RIb z0b(9$Jzb;S?^Pwm_g~M&@1GFf(|$l>#Z~5%q*nb`BKrJ70%rHw_Dh}A@4fI+>K+#-c}x9lQ~=Aql`kKq5xLyDV-nez<>zp$Cjm2bWi0N4gnY35d%Z7N{^K z|0tXUD(sgO{+O%N=Qs&EjTGprYGjwBQDB-_zPv>G@rnhtAVOl!^j?jlWzH_LU$qfO zT;_i=qSdVKK`?O$wR7xlF4tnz|M@8|PP3=}0#d}cPcS0tZzE6>yD+aK6+bYO(V*$Ej8)d0Q zMbRGJGW`6(8cL|(-555_WUd=bQz0r>yD$HJLEd4tvaCVpP7`Z9VDxagFHLuK95|CU z24>qcb)Bz>n^kJ7TzB8fny}SVY|S=2$S$cAo+-v11tJbZjuDGWGQo42e2wg2&FY!= z!scfuzlf-)uESLt82&$t$lr@gZ)w8!m0j{$(QMmua24g?(=I_}^#g2V6ySkA#WMlk z3(D0jUb9X;HZi(hUoz5OStP7(@D z7w0J!t?~(oA*X}6zMpP_rBNANdS4#%IRki2Wz`(_EabGk}l*q`aw=Q;{&wg|f4VL9;C&$O~5i@t> zjoy!54_hYsI7@VA;B2fTl$_~K?XxIw!eiuR{#36KA9vp&K61`sJ#lfIXq)c5K7laI zo%zoCNK~GM>bXGo$P`gJ_t5og+t21CZNXt7mUXC>;Y1e)|GjR}y==dXvnTvz_kE+L84H7ykuwr za*v+;5BK!GzQ4n$#A70fOFyC7sZsuN1_g{lwfz#Ka^g+f8y8fP5aE>}V`F;b^&VjJ zH_&EV$zJNPc9Y|VK}GkQhk5!}*9|IdW1-@a52L)D{7kYD)~Rsh@YY?#E5>`%9!5o6 z6{=HgsIU8fAI7N5-h+6OD?u!2N&=%TIN!y+3mVSY1E?0)&`00Jl|h_XLtCcoqX-lI zA(uHZ*OZFgnkvF(!J-_c7hs}C9nfTCAMykfufscE8-4UM7Or>515dWmXWOqgZq$*) z6TjDHK~ZAb_G>wQ1*9!`)c~Jgz^RUeNspTs?GrcU3o2=lz+Zz!rK`v{Xn%>Tw3{WZ zAPjceVK4YX*i(cxrZKsW(23-~k{I3}YkE{ws*$bG8MF_lUD;o^U6KB;1GRJYVoLM0 zHbLGb0I4;!m!AWO>8PH(bg^B0{+8{O+APlEh9il@5H^bn7XRkLK(=Cu&7?qObRIxR zj0pa=pA=6~QPf7C`0VU<#&XzEN`7HxzTQN>4|4~5A#}>SP~EVTQ}J1o{~s+1W5g6z zauP37wGq)f76LTNzDvCxKjbqF#JY~Jf5EM@nLDvalizrWGoyo_M*=ahXCOMozYqy!M3w zD>Frku(L{?;reqJQ-}re(b1nm!d?i}hdMbgSzI$a`1r=iyD;*;!_=_tL37xSjvV~c z7f1j1J|{w=gbv|b?Ed*%9q!)C!^Qg5HBk`265}S9OuT`WiP1 z-kVqo*)X}RJEg5yoZeNc*HPW;9}Nmg2SBRV_34M{RDl`yjV;B1axQ9n20&7?(9#JU z7QA=CMPUgzKO|KQl2z9rrb9N01tjc2(3#^k6_MP4m0d6+i<`zvx-ZB>*UvRUChArO zBVCQ#ta(&nGywOAwIY?G#<*ckg< zO6K20nN^=7TjSa>BA4m~Rn~+~lk*%PqZ3=D9DaPPQ>zdnY&QJ`Nk_jxwOP<@*yPNq zdvOJbaJk9SfD%~hED8PBPV_&iBTED&%;F+0k(@osM||I(S0bF$^d=|Q(3XbgJ&3X* z116cJGvo<5bcc^ai2P z2y<)lzd!ncYI_esHjMNNVEwQIBuGcXxPRho1U>e~bgk~~AG1K=Q5ii43|gTlkw2w# z55q5u;B6xP7)KZhxtGvDmb^KEWA}_cc z9onVMDYm@xVY;jc#cyV3igQ!#G+pWe%uMm>#?wOb1|LkhRTBz(%lp39y0w_Rh>T)b ze{T{sV^Y<=lhPOoRokaouVYWz@Ex3sm+qYU@Hk$RyoQj5O$==$UYWRTT!cvekK!q+ z*+oPkpjUo(ZjH+l$wi`VOiAHW zi?G6di3%3*RXFqv9@+(4rSoK$rt3H1AVq=3I>-Lsm6t>=fdmHgqnzLy^b8Ec&XZ7D z7szXUA09nMovs(dk2_jzTIx|nAT38 zlUJhH8tpubme3#;^gOA8+1d5H+Q_-xzC?bGruH8a$a{-*3k6QX6{Y5DFuu?ng=@mz z7EBr)A5WHJZ*7bs0jg;<;t$=20O%q6Epx)rf48hzShOMiV4%FInZ|wK2D48^XqB^p zU_u>!+3}cKwKoNuxgRPo$fO}c_288H1DYU~s_WEpe_fv60Zjru6cT@o*H8NmU=q*@ zQDXXSsiTv#BJnpqyRxxe_y;=|8c{c`*rmR-2iH-xZ}kS zHnyLz_m8Enu10UvmMvat*RO=tF5fdlX~buAut=@0?m=Gcgb^nhWefTsHkI)33&TxVmq_&i5DKWB)L{8CUMuaHu0={8w^AMfwt7@8<%{up* zRwTtg#}Iy(z#MIk`v@H8@~*aK5VNR|q+`!2Yb0^She$G)o{spn zzf!CQojQTM79tS+_4=9LpyK}I;6oe~47&gX6@tlMKxah8(lcCi*T9X8S85nKHUd(* zsG*{}1*Nis6az2>9b&q=w2 zkA(j7P6CN>y?tADA5;afr_@oZ*VKUUlIzkX?bEl_)VpdR3D*){ls=>Wm+Jt%BzIN) z_t%=HISqPd{@?JqV%KE zhbN#N(6+u%Qt$oSIZrn)+F49BmM_*Dpmk?}*tsali7G`+ShF;e^d*IxFTMlYVjrlX z+$6^1r#r>XS`hs6_unk<_f44&*$rb-oIgB<13frx3m5f0xD}k2`nVcB@OL>7v=EK< z68a^OPk7Jny1bS9PhCcl;vs`!g@oLb!!6~U{<+5$wP7ZZNU1gTto`{p2WET^Es3yE z$%s3#Rr3G!CfQKakRufZJ@Dhz+t5f6%)NlVvvk=^ef+H1gEwQ9Qf;w{)bZDRpQJ}F zH2>GB`_~oH%z+#p<@Q|A)W6>+Am?Rm%%uIDb@f-mj&#wA#SV?z*gIDw}X3Qd=0BQTKd-bMUiY5*FStQprFhJwUU0~7$H4Yc>xvxN_ zs9$nvO6`-r;11WKlvTCS2xJPd3kwUEI!wvHpNMR0Z(rudwuzfBn&2ZKus_?-2HHI= z)-uGV^7{(0mW*~~67Ir7@5@!;`J3Y8RHrr>?-A}d!gA=_0B7z$wpv%~a+4nS|4N2l zv4oSB$%F@&t`60^t($inH<>>g0c?4l&j51)Qr9buu}ZrA)#-(hD-SRHe}tC!K3->h z5Z#7VRV04=fwvKrD@4bK?EKfI|8G!=HHPGi@W73Yp56@QiHbnc=r9W6--h@YB}ZQf za|osRy|g{yDGLFG5B^|x)OrB~B;YmP6dH>F3DU6sfPc+8i@r(YlL=e)2P@B|e}qoY z^Ab|ATyRvFD7T4IwZ>+rs<^toTVn&f;BhJEg+SsxSdktDBi=_~0J)SSnW6EnuYXZg&hJFrJh^nJGI}| z+`#%e*7rsZKemEFehrWYY~NIWb-Z{dijR_(`i!`J;V3L-%?ET*`I1#PPp!wsD^OFC z1g`AaT93ZVQxysM90`6~S$J-;BbRzJLYx_zr&7R%payI2m>Yiyr#)+?V9ZO~5+~f~ zho*rb68-<0*#C!$zkr%W)}FWJD>DlSJKscIt{JRl6Kxy)Xt~Z=Gl(zzZ1HZeazDqIKP1fD6|8m370`N9EG>ZY%n~q4;9G@!D@q<#?fkNW^a+5K4XSRB`R( zP$%WAg`Q`ufRU6+_tk-*pG5z;TmPy6vMA~|(QKKMk%4aQ6VoJ2EW%HvxCk)6LH)J6 z9F4CxT=0^pnubv7V=Vva%`*8I!#A>MztS<&BAr@@J#YU%^Q!HP!g+_bU`iFA+= zYC^2tF_^2>Ds=?1sjQo6@?DIsz-Xunjh5ZN0dFrW8D`$AbWP=RE~I$ARfcnNxGW6Q za-=fDYz%N9iU+N$jT*tGs=OLFZwCn)H7}&e)N~}dP{z%;_Uc&W!gJSzI0b?nG5#yi|ies5^Y z>Iggly0nk9PFvhy7!$^S8G|+M>IJHF$0NpbZk%iOq;B^!#J7-xrRRAxA~owj-L42T zMLi-HWbSPF1^I6)8e?2-7^K;D`T+Mk<=-Ds zbc}{y-Z!0J2cHZ6A~D(U7%mh8zN>mQ`HOwg?Xv4xQm^4YWRh}438AjSN}8pwB^m0V z4SMJfD?UoiS_#pzwC2iHSDVZjG*ca4p-@ea@B@w*yf5Qh&q9+`6s{V>!8Q?F{y3W8mV0OC0rR5{{bXToKF~@#OhjRI5O$mBeANTiX&gL#Vrg}#Zzh>= zjr;(^4{r%y*Ou%eP|tdrX{Lnke}5|gh@pLn4?zs+|KYXNwD;2I&8#DcjZ!IpI5=>N zsMNmtDIgIAVKtq`ctj`>04;Oco>?)rlTLdropDTAg>_jkdFU)iJ2%Y12D8nxFJHuakX4C0?xBNZKij}&S z5W@uE)Bdac?&&v~%I4QO!rr>&F36S5R!l?j1|KJ<#Hswt)<{ zZy)16k8=V3QO;eFctt2|pu2kqkRSe%?At^uKz_Xfa`Nu`dtEVF>yi4+jr{R-1s(Ud z8=#$5gNbHgaGRS&8PFfz z!FHBxC#;| zZa7F?JZi>GHwg_CyWxW;v<4Y$*tiP3klP|c+!7Y;DMWB%ph7u?#;?_T@COt2oi;(_qgc;Sm}a=Eb6?&q;k#4ty!Pe z!28VEvN~}IAKM)LqTFFyf|U!l8Oys{iP2$Pcc~k$I$`U(&N_GmB!eC|TTa*bKYZ%c z@Tu=?UambZTTA2fc%*`Z$Az%6<(Lp|701iI8NQq2uy5i&^XP;WOQSgB6HBBMsgItSveRAewba+$QbKPT|qrCBwY-l(P--dpr+O!dXlg-Iy=1(FD$&*B<47 zlxS8IEhXC|fS$UHPh_{hg1pP-ZZQ^nfJ~Y+aXscMTDcf#T?m#23*w-1s+^jsgIl_S zA&|w!;B4eMMzsmt`#R?L&Y#+F4h&g<~Q@|Q+_Qv@4#;PX&mkB)0Q zDuWs&EI+4WBS+Gb)p`Q}^X~#`^nzZ#ZdiXBfW}|>TB}Y+{-g_=dF!?FP!fa(gVN(F zMoMWznjNHu^5sHw@@5kGL&YXjg)M)-DA08Btd4w9LIez_PTku%1PgoVQ1z?{9&mn} z4gtJx#U@|#ZfY!Wz4W6(u)23chvkLB5#}NE7rrS2+Zb|U%w9@3g-t2C*JQu+Fiu{^m%I3n6hEr~`gWPs z2Z-5EOXj;h?V;G^oZj}olSbDIeh%!f| z2>=qBI)6q6ackHjI;I19H53fWu?1XwT%vcMUXx@^k=7nvX*yWrBgYafmM}rrgv0iv zk-1xU%_ZY4VBt0d^B1~|6*b*+ho%sFRgcS{pJW@$UXw0abcp?!yxi3EMj;Cf|&ew zwn*<^8&f7(##emy-^Eld(L=5AYO!fX@CRQ70%r$l9JWWaJuF zmv(&Ixqpx?Bnn^YtOk8F$V()5s9xS#!&{nwamZ$cIJ}z!a1}ZU*HMCGrB6+s2!wYk z-qO$~p)tQbT7fu_A>7mxa>uSH*^xiT8Xri@$HYxW$76b#HpVSfX6`Xzl(5D10>M$q z0lrP=_ph0-x-qfdeVCD!S3R$R8jmBpipE?^WJMh$0n)!jOPHqBZ3wyVz;@w8Q|75h z)vy0HC$PRFzR9pWbL0u$T$3|Qmy~4!VvyWueY~1KhARz4^DL&>eNuS#@XikgnikcQmz;P zC54~DcNI(^eC4$bZPJf^EDjH0Zb^xoomnGtHo?PiJoc$6CiS$I=;a1g*X> z2KTg@NKfije#oS#_DW;I#Ce(s-M;nwT*3~1iE-}DG|wb4g19Yxcb(?fOkd8a+p+-b zCp8A*bW4CgR1FJmT(cV$t>?>9jn#fxT7;Jr+vY6cwVgZ2w;xg>_TK>JpVO(Q0&8EA zYN5hk=u|Vi^@vvOqCg5{bI~NFKY>>C8vt}I`OdPN+nWk{;R{5Dve-p^Id>fU zn-oZ-87>(~Y&sHarZGGS@zYfX>}MW&1ZNnZ{IaD2Jn4JL9K{(gS%z{k`2sLUAV4hz zYljN-L#V*OYmSY+4;N8NOVoZK=#YGkZ(%6nWr42)#ad*k$N#pT$aVzCo_Vt!DdS3A zm$Y{p8?Om`O!_6<^QQGQHRrgJTfE)kB^T@S(N}>txXsnG4<9~bPWLe0)ik|xA;R>Q zDEY2OF3}~E#c`eO{&e4_i9Ci)15GN1sThe_VeFJlSyRJdx7y@W|fCL7=4 z<}tE=`PaXg(0{2Cptz$Z5sM6obyFtB%-Gu^kQvQ?p#QO2uQ>lnPM7=BHr;iurH}7k zbPg=FuHTW*Yjq^hSauvH>QCrjwMZ1T?*8Ogqf4@EZ=agBZqZa#{nnA(ZN2Mk zzmpW5Eh`q5*QeGuF?5riJ!AIjt5g4;kpBHc-FciXHiT_}DcE-fMz zEQBRNEf_5XrZ*GZbHX=bG)ZZ8WNQMuigkJ~DLZp#Zfvbvu(#wtG- z^vkwAB;{qBeMe?_8J&@7^y+Mk*%Wm3eAx%N_Bozgvp-;0%8~|vf6t*KnHbevCEbs> zyyfqSJOqiA4R#@FJny0t1%iRNwG1~26uNr z^bqripDUoHU65kP*|5Fs7*r3~6&xU?B5}{b{A3hF`?qUB= zlr8aiowI&V@oOGs?xEP1CenNcRQ9OL!|h~j@Gwf@iTAL?l<^zKaBNJn-GB8wYUO;u zOHIKgO#J;nC+Yw6qv$4DKOX8?ln5wFEbX};UTyfrMm~t!jOD^H;u8WI&D?wm0?)q7 zVS|ilzAu%6{1IdbM%&q=AyV$RX1R%GlJ8w2HjoQ!Xd;$i63Hkw~gqx{BUq9k(ugbJ71R8-u-(N16W0l?h#sHEsv`4%+bPOd zJX$SM^!(WA1RDsZc@G1tfwqEaJeGd|o%R9t6@CLKNBfN|Zh2b+7NE^~KD^U?Pf;-t zo8E&*>G(ns-0~j_X)0FGvr!;QpGQjh?7P0V0zMaump;{jF(DIJ!6A261NAhKo`Ay-lUgx<3J0prJFab9blxxMm|yh}R8fDw zPP2v*J9jGO(-AIP)qNmVwA18+kgEwEM)@!kd7M(nq-RNo;i%_~2hfSQIG-ghe^RqTl`Ov{lnoOypIAbzSDH3u&P{I_Hj3nH z%&K^9K6_&xFhj_SeRi+sbUfM+ zNCye#E)hrAy(9_!_2R*FfFY}gg#)y30nNZ)PY^w7c<9G`f1TmEptg~6dFPpxmE=poR-%y&{_eB zT^4AzY8cB!57ystkc;EJ#}z2djv7{kJ+evj=vy~{tgLZZhn>a+zhPSraa$*FFQr}J zVdeljCl=QEbiw1ch+P$nwOah|L%@2E`i+n%dSe$Rk-?@O5Jo58X}UHEX6#UrFSEM5 zxMxMIx^D)ckh37+>Z>=sENm6bPNDAn6ifhjK6#hdVt{c2p_iaZ!v$cLAWKIaRsK*J|^8JZ?*TRe2LqE#cdUAiudhch)Cj4gm7FE^g@qT!$ss>cDC?y!pg@)&}h|Mnc z^(uV1jWLu&v*D4mgNaIfg`tquPP&_;8&s3EQua`p@)^<%BZlS4iE(+yMQ1ekAo(eYu+5<+g0n2sodx5WpfUn0|!VfU$<$w4$sZUkYeQWsO5q&J)Je?ZQO3JlN$ zEvDl{qg4Pj(A#&KnrH{&B->Q zZ#T!2MEG_Je-!^B41#RA@c3_MfN9o_yKLHoBezfcGf4NMRRn{uJjD;QX?x%URTb}o z=Oz}f)9n{V(Cw3perv19e1rNMBC`alp{p!;5%lcS28*gYYg&Lq2quGo*fJ6C?q+%m`+ zgr%b-?RB3%bYs0zaTi+4kzku9-H+7q_IOE*)BoWURI$tP2FJFuZcdSqhjsb$#OIrHN z+T6EJPrMFo1}SNPl1p6{G-I3JuQKdEk1zzSqKoPlW(B(!t;a{!5c_n@nB1~rOJqcN_*YR49Ge}te4Jl959 zr<5z`hzX4F3ukDs0`^#q_v*Jd?ua+o{qzwT-f@D8IaFYdxf>+FZ*}&2jas>aJn{T3?Vq2}Kw z%DE#kcIkibR4A;Mv4wT>7^}MqlLsXS4&L7GXNv8IHa-Ry~2f zcvc}EKRLXsxq*xWj+cU-W=BGdPd;NeaH2P@m4r~i+mZ~N%Rme|D=0B%mY~Vb6ZQ#( z4gujKFbw`zLUe1=VJEQs>qs@MCRV&SHID3>@3f~6&r-OUbEf|~mo*uo_`FWEf+-Pv zGKZS1zsAiZE0^{Dtn=0!!m*E4mscx)A4%Ir{ck<;*T9+k>`B0fH_fwgqnKcsh~W5Vp-)Xd0SB3Y>MZ|8GU@)4TptHoR_?!?&(ZMa{5!jw?orP{@#s5Q)T?e_gaacx%g4`5|ljksmG2(~8r$Kf*gt48t>Vf<= zR&GE>n7X~HZHWJe8oNeQgx~|b=y|Bne1p%fVOovOdQBq&oRLEIBc)1Mg@s;$zFx}! zxV`R#$ajb5>K7&IWgFZiG~+Qeq;41(v;XC337I8}?Rn0)Q6 zqyzbT@I9?mW7k>_%})=Jzaicb>TP;%~nI{{g|G&zuuUTdJjx^Yb}3lTa` zw=j0z0wsjAXJD=aD7#gq!+wG-3bp@htw1pi=`N2XE}=m9L(8R&Nsk}AQ|IYa@YwOR z9iZEFkYwI*ba!*Jap`O z*4^L;$#+kYex!Zz#hnhZY3J}SysqAPE2H|VBkdRLy1#A!CvI5ntW@203}k#4n=YAx z20h>%2E6gCLqRqVY;7+D330zc8a0+WlqVnk3PP?KIo7xxEnb$aUnG${n0TPfw}_!J zN-I!&|Bbxo!$dMcy0>?OeAM&LtI+&;9UTNt-ImyEVZKuJls!;?hUs z-vuNwCWFUt(eV8%?2rP~>76C(?%TzvW=b||b@d2UrGTgVz^datu^SzsWdco(3)Y9` z4e|oMdaAy71)(gXF#*G>H~RqtTbLKvDGw2+6Da65h|9a#0m|9fHxi)71$Kt!isnDA!@}CMq_qtOv@px`TYTEoT`HL5^q>@ zoF25v!oUCM{ILvHeP#^nn0FwgF-8i%4V;=I~=-T7zxAm=*8jsG^H!a+z= z!LcCe3=TS7O2;KC)c$5n?u;8D$(|~Xg?81s7bAopL7Q_6yt}4i0b3VLL=JBe{lhQ; z;(tFJW`!dhABYm{gGq*~6Wo$1&O_S@Wh4*rtedE-T^3$JUV=n9?s;(pLc*%)kCvqqE7(`t z6!#N%{GJKA;rl#G8+`&jXG%@>1}5qT!T~Mr+ zpfgVFtR$qokE}Ipd}0K zfjhBrWXnH)q=m3V1NX*<<~g>KoAv~%xp`p;0?4vh-Wt}ps=%+w(5`zd@oY^X^g`MF z&jMK71TuYK+gyKkET~|}Sh^N@AW;D9V+yeu&!wV*S=<76$%Ak_K-vSy5`iQzIyLT_ z_|E|Z`3PE?5CuBv#43=&DuhaM`#g2zLV83Xb=8cgabn-xc9oMe8+t@WN2>NLWh>A1KI&EQbj4{lP#tzN6g5rh5J8L(C&U-0 zO>fX73(nMG$0cjvj3Ls}0ILj~Pei*kPyB@B?-#HL`vcsTg@|-Vn+8Z+rnx|#0&9|- z$&Y$wR>_;cVGVBZuO_=e=#JKR%y|C}fr|;ouzKJzPURq|a(Ey=_XP6v-!ROi=}KHr z^o~`+

gyH#j-g!<-vq`C7@(_lzc?LwAWQ&*c^IYW3GY3}J!PxK+-@Am^8~n>)Ge zJscJmrgfWdv+;~!|5Jt$zLv$luYUyZU=Jl4hjtG-=z%tatMp9M{lCY(b9X;4kf}Bk zRh@Z&Ly(#^eVdG%{6Er&L$&GPPh~zQspz5?O}+?oX2#QSXEERzFnzAyGLMq2`V*4* z3YikINetRC*j#APoL3?$zD>1;pBBXQO{VK*){D(ygBYwI2Q0N&rB03QfFyv=;O5&P z{D+VQuJ36ZFeATTdpEW~5O-VL zamOOl7SHa>ipvZktQ9FhCb8v}(v!UZXh1pOxThHImg#XrUDnfS zb6Rfx!CUKoZeHEoD3HDAXUQtpq8Oi7f!;q8>@5DD$um{2fs~(bcZX9RNOK+{#O=2{z=h}CF6}9 zojWx{G4A!LlaK!beo@8I+8tEWXD8gWUtL^&#^$R&uy@GO#oSNCq5YLuN?>3!wFm1<+5jx-6~O z@!tDZrBL}9*N_K*C$oMcGaQ?i&%n2L13>Ks9swx|GA#5;1l`=O%+z&*absB~naGXF zr8`)T&(b$!;%IThNtxVUEkQn$Pa(vkyy#fJNC!8i- z(%;wuzwLpXP7o9+M}dcAp!H%X>WC5L^t379GO<&`(XYEppj%Wu9g)x#%crM}mjM{D z3d9l2gIXvGD6URu439=A8Y>A5s-gPolplcl0|hu2Vcs_L% z0IQJphBDOJOaL;LgV1NI^3~&onpLlDs2Mey+@cZviZQz4HUuDv0fZ412bzI=a|@2# z`QBX%P~u|u{HXaC%=4;%wnvm8Uu8&tLj@zl&!sRpNt5vF9Gm5MVwx5<3W9Vz1>4~E zny<8NlWP)z8$xTg8@jDrF2(ITn~M%{&tOda2#2Xq0OFr+lgP4NzY0k(dXa9KPv3tm zXVPSACKvkB!+}}vYF;J!eCj%aot?{Qi#xjhR z;?QnyHu4?|x>2ZKM=Lx^m44K=UP~PL{=|9xSb)RG23WhnHre5dmvio_wUgiWSbik_ zQ***a+xex!PPM_?xRwfGe&|@d`Q#_ACwoD*!vKn%`E&ZqyO|!ABbJC%Sw7|Oy}91M z@qF1+<>FOkaK)S9J9z+#DYrX8k*9v*#y|NQ%g`b0Q)oPEXgB)q1uT_7O-F>uz)h>k zni?qb5dOqdiYS?CNz*Gi!)={u1Jmp`xK#K) zNhdd8ZTXL8!_LQuFfdiKZ4+BHrJbQ1i!yXAqLb#(CJtGj?s&w zoahwO{`1PlY=~E4oiyN^F&wQ%3D_nI&^+dtv~M?-Je||?;gJs~`=#TV-<|Qv(ODk~ zXcDA+k}ucqz}i`b$!O{m$^k z&TXsX)jAsA-n*Gg6EoiWB5v9JgG)&3G_C4%L-^_i29rEUO%ZEHQ0^xX#G{SO=b)ND z9A}wRXP^?e_4Z8+pPp*H^o00&&(mG{jZ?-#->j`@hkgob|a*}3^99* zr&TQr~64-CBW9`|fMiLmlqsnBl|v=8fo7QNzcJT(3xqlGtfiIgxD))v_X$(X-#m9Mhll>vqT= z&=MD9FtX;0?m(R>_Njd8u=>nlGYDaS2D?o$HD zppqi*XGJt2{dh!oJI)bhZ*kg-Sv+TPc3RSwy!P0gW|#AKs!ZROuY-L^DrzM%dLuTt zJ@);zA9QDq$n%UBap@ec1j*&J5su3m;ahvMK~{&`Vap;e4Y@t*;D?Wq*HRrx-oHUG zeKjQd{w^cirZ%^L=)`c>+CXghhpcU@TPYOEE)B{6AEc<)nYU-8J>NPj1T_)my%fGV zBlRZZU`fr$2ljspvpyxtN0MUkVQi!t;Wej=44jwn@vpk$=3E;-n1MDTOoveU&8v%d z^U=47i`3bmDqY~f^`#As=n?2Wwf-_b+=#1d>kH?&IUKO%pEZhMH2TAA6~QY`psFLV zPegFv@IMKriBHKtj}ho`Z@h8oDt>}P=kjNkVbSY9H*5uC-%FI)Khv)ML* z@5{{*v}-X>$9+Y(`z>MmSCt6IJy2#oDXcyi*F^c&NfN#`!dkQc2%hk@pQ)D*HMJ z)a~2IPBQAZ+RqNjcoTW;FXdbm4k!=c{|gEOp|rr-Egpm2ViiXR4D;dp6$^&}FGKdS zsb#mLK>a{ZWXlJe6PdRixBMrnL`OUJ_>UWG;v5c*IwVBfQryu_3KR5~&K!XWHUA9v zOKf6Kkp&(vcR72i*D^0Qc;t?_uW6xT2R8fAg4!J&mW<7CQ%{l7+ZimUJbtZwFd121 z#q#>gv6;M3yNz(z=@tVI-0M<0@wHMs9q|b6iJo}j)~?X>mAM4my(jSUe?Zm$03PQ- zflvZ57o*`gE^eWKtCupX9~=9Xc&j7Y+urQ8he5+q*dE9_`|jyoCe2HG_Ft=Y+jmOU)6MGZ&%y?!ePHd$d1Y68fZ;1QebhGDZNz(~;7M66zP*2{arhKNs(s3eX zz;yD`*oA>*!nJoWaCeZ)XM=-zm&)+=%ZxGGzW(wJw6BcO+L)Df6meD3S{UwWa#Wzp zG?h3Z!x{_wsL^T6$k@n0!$A2J1BqC(b|FGvJZ1*N00p)Hgue=_9ws_E%~^1s=FAH| zJE0qE!!B}%x52NFbNPk&DcqcId)kExws{kmjlGt*xW2TpN;6RlEs_lrlaDUrno6Kn zE(>enP>~{$F@hlTDmvKDfUu$EW;~WzY#4G^0)yRj8ZsHXVM>i_v{)-6_~Dt?TaHU@ zZ`@#_i{WV-cHypg0&qfRC`Z;+!UHVNuDJbx)?e@H4Bi;BnicTn`(d&WV|O09n=`@gc=CHhRoxVx!=ORPVgI7L21uT(R6xVw}2!Beg?zb=H%d^7O2;aNZ@lj!R zhdx%I_`?1p%R>_?(61?Q#ZUpCIq#=_)PNi^XjV$7BBX>Qo|<)fm0~6**lv6*R9(d4Z9g7?tJn=LO@+5m_o|FS~Gvg1AIh_R_U<> zlbJV#$HL_?ry~3k=Hx-6kDn~IrAi-wphZnGSHaZ!^xkBkjia01pquc>x!al3vZQgk z%#+C`@Jn0dO5s6Ct#w)6&m~G@Z)*Z(q4HEnOF8XuurS{ZTr|64D006=Ycgez;pL0X z32M!3cl2XAbN#ArY4r?*%LK+KCc!R##mdLmxOn8e#Eks3?Qvwn!ux%=1_vaV z+Zlw>V*;kK{ywRr%}#p_&kraq?lU}hrSLV*u^Aix%OvH1_kuEjqK<(RNsdPyd19w6 ztl=hf^Zb}grknI``%^i*8BH+jJNgoh{4qK~m;^hgQAsdmufCwl-Nkb+%&IK>P&#B{ zM#TjFANN{Z&jdZb2hC2A0xRL5|4k$Cb~vV(z6naI!3e5lQUr+j+psbx8cFVt=INXt zUY46^$ERRM6$c4DGCzxVH}E$LI_bl0z3Jzh+|$T7Muv zO%UUx=1nzFPB^O!x7>V(dz$ki`QVa_krMHG-v@a=yz?S~n#Cj~OArkjQ%2AIMYhVn zkd#>D=ss&-(CkdT;F5$-y|M4^l))3y^p8~86mGaJ8dx!*GS17+^iulRvpLBpzkVOc zi|GFT%+^0;H&#BJu0#g9j>aq`{piug)38(wF7=xfA=f+(iq}h%#KY}-cq4CEAGA$9 z`FTK4de+RD7mxPp8eU%URv-F;uA^k&CPjj}>-2_5G6$Qp3-j4txABWUYv-7>q28>1otnd}ic)h(m!DdG3H?YFcFZ+up(=sGu0m69( zKQ4VE`Py`ZgUq;5ud49Il~mkSS|VxR%V{@`b>cgx|#{qililc~;A{+VpgTZQ-`(?a4 zDU&7}1v;(&U}M=#fD}j>jyc>vE0&59E4v0EAW)NRqsxF&v}q_O>K@HLf^WJdN!BuW zoJJ?F7O3ml_>yFF$2tPvB<$&G^!U_^T9=V`yc;9N`DOJZ2V=G~ckwN_^c-=x2M z7PsPwp;wI*a>6|>p1>Sd z$gbYy_$l6eO;n$doPpI-uKRwt#*1TSpKWf|sJ2}kb-(wVbcp?DVFl1+=!~HjB9G;~ zm(=z~uZ5oZgx$?H4{743)ltIum;x~OHLf~kUQlc*ImP?g$VdUyrmLK!O5fjthh==} zfL8GdxVXz3XcHDxI;FU)7dH$fj zStb!H_2gYM5EQB23g0CW24y&IEvVn_u2~RBt7|;~VVCYfwx=hER+cBxH!pvk*;pxG zx%Q-Zx*`9()l7XnILlnY0Rp)gX_RP*GwKjMH#^XFHgcdLn}=?99_IIgbtNO}DH}FI zrRzA%Rf24uL9C~!BUT0$zW+V-k@X4Q$zdhE@71Bd@NhII2NL$gSk0Fsln)yb`H8A?&8Wg1Ar5v6cJ!yT5|mkX$;zc@~`WD zx5w|0*9~>eK>Cb>>PTPDgIBVMH1bqgWP&j*?-HA#kW!iiB_`SNnSA`tC%5wc?;(!_ zTqX*`i8f$O5K>4;iO!0-aK$y*5z#+`(WpPCRu(yOAO3&?CaEKFr6zJDSp3kD$x{ZT z4$D42UF*LRDPwt{@!8_fetjlf;G%>7nLk#Kkn*FFF_xa21^AT~`( z@gl{hX|2zdr|rpMO7oNlGjJX+L04AK_?C-_w$~$c{v8k9`2g8ox{5Sg$ZWWUxX?s4 z<=`qiKs=LKz(aQckP$CR(t)tAD+zbFAK0zCN~oulz1j4LWoAdJ_ng2x{#Z;`yttLp z6aipGzY1NrkLeLeFz#Shd6KUAHasvpU%@6M`o05sTcPQ}`JO)#FY*UA*cviqV{D!n zNCHOS4PDuTI|SpiGxpYCe#56VVXb@r?Tu-0WAQL%!%^uyg8wHAj!5Wbwkok!y#Wf` zC76sp@hyAMm75yojGX(25Vf`&tW_DRTe~4*e>PFt66nx@ z6N;W}r_8X=ey&@UVo{;QJ@-&Em4t$?5j09o`?g`B+L2dK9r4^I?-k2G1Yk>nA7Ylq zkN*_H_xz1i-77EXPw`3vn8uGa^O#3K1Wfx?p;Q{U4iY~#-|iBawjF@nk6NQJ0X18x zo;E{=^eY>EewBxKu`GjGSH`g+@8~E{P;uW$|L7J?c1`1#Z=-gWo28heX7B3B%deHh z%9jW7|=3wh`heCvCh+hVDa|wIPFMsv|9Fgz`p7| zq!cth@o8)Sqv&PVE1ju97ttaM$+ZpUc7>~>XJ-sMFVeha zd+SpC^L}6N++lKQa~r!j!oG%=s?wZPp>>Vf!uO9FpFoScn^|FLy&s&}^QbnnXMR;8 zc3j{H03BS9EMkPn)u=lA2`SJwJNED#FV|{P6ME#!*81&beEx1)cWu<->`DcU$gl@-yb=NO7s81;Jr^Sewzh(bm+q{M@|!f& zsfLiG;q)2GJH9}^$Tu3p+zZp_SbDzVwx(lVd3DQT^h;ac{1*Ji8Fic!8^gWd_#sE{ ze&Xk}8SA*_4Mi3b-liQ>_m2z_8gLy9{AmR-?u8Z5kXaS&0)tr{&{|H7cKwkpG@#D$ ze1inT`@Sgnuqqm?!+8e9sblmr-q^gC-yrnUO95?gb1IchvP zzWc0labVHWT(s5IG)RalZ}2KXaz7g-c%$CsJltBh`OChSAELsBB;nBe4LHQiw{BA0 zw^yj&@{%f9#NVPbd1pJ)M-!YbfcSWa;o;=-ucyyF2fVNgy9SzO!RI5GZ^L|@#)`F4fs#d+iJ3o#!8S3bOket>1tVmRg^OTKel z9Af)TD^S%8+c6i7-Gws?mPU3LIkCPmJ!Gk{d=gHw9B>PiYnuCc9*&}pZep7{{c_gr z>KkWbXt{rIqWXhRbKIi|b*sRgH9tdJ)9Wv+m(wka0HIHIOEYONP>r(5*UQ6HMBSGpj8fuUrF!6M zxr=jdT=lNK`aTeM)A4esu--= zSJ$mHx-K0rx~s=F9TkNa`@)Q%v(&+MQ;~J&-4!z)nGNvV^8oFj?Z!qf)=C#FPj@Cl zbkZ?sAg|+7L;MPam6QgiVOrG6QX7Za`ucHSECRR})9D0(AO5G0xm#`zkh`ce%=;eB zcqaaKXgVb(lg69OxwU)RdY+aR=?i;1jWm-b(h}twg|0t4-C!XnF$%GT^Afkg98j6l z;&Dy{V3CZ#V5@|cnugPE)g$d7qRDznFgph_|J!5k{2;K@+ZE@wCF1CAnDq{;Hy)Nz z*d{^0%@I29zCtop(?IXGvIePWM#VKoqduR>w%uyh$UXiX#W)#pJHBxK%f+fqjvMk> z@fKlFnt(%6>O`n{=1Vg~a1$Wy`2CKg4`X-llX{gs%KH$BLueyR{PgxtDq)wxP7B-H z>nAn?xzrm0uWnWmN(8Zhjt4lPd?q>hv>U1WIKyPa?~GHIUCzPe*TsqBVV1cV+)o{V zkblvHRq-&%&1eRN31O(-xV>iM`TEZKr5D9H8AB|S2?@wyyXXd)$uTa&w0ArMV-_@b zKAS8_(0U!qGA)Fe2=!$U&L)24#y;Dy7(+4nm@YW`qTyZb1)lZK0{a8>-1gXz!7Tg^ zv|~_PAZJ9%%D|5rIpVgcWkWIrafivmzyKst-mwA#FN_9@0y6cQZ}6jDv*e>UuA(d& zz$~B^zpQ4mHL(Op$PgPc*o&5dR;5sg&iw8gu}!$J)00DoAHNq~7o4sr(9L7V?l7<( zV;d4})sx+WI+9dde@A>wNGW47vP@1oSr;O+jf?qN4b{BOWOkj4Y$D~-jJ;d#4A1RU z{7!w-JvE&7x%JPyVcA7wt~Na>qr`?%pk~fj+P|nVVkA0w>%0uvmjv433-B!+LZ!)2 z723Pk$?Hn#PDeeoJ+o+BNu^#_|l7!N7)80H#H936&a}G6>#618MWQ*h1kiU0Y0KaYl zi4c|*s2fh@P^Odw&!AmBgosLLRE0g;5qM?=k4%sQIP-Y~O zomI-pjIs`*5RpVA|L42wbB)jE^Znd@|J%*yy171AS69wC@7L=&9*_GY>k1D(vDK*S zxycoo=^EdUy`sj|G%r3gU@H81))&5J(d^Bv&hK0jRQ$q9raslw=iiFtFxS89nTwzS zFHsatl&z`vD;uU5=rojc)c+zCH zDrO%1okM)q?W%NQF(e!!VY&<#abpp!pn2EgWPxpI0*uqUC)4lwD2ixx4_HS&AM!X{ z_Ix9UU-??an&B_~TgNUP)ctlHt3_h<(l2@j&fe4T;}^PObUH|PU*lQo_+gIk5yK$J z188sE}|sBDYr7Lpe{>KFW0durg9oFqCwGr05=f-J^D;VSPFz zY(1=%AzZf!xTvL)HCPrGvhPx&g$Zwf#*^;cS&>+AMHG~`PT+TAwIE-7lUKPL%DZ-? zt~*!Gi%-81mlPTF32;>?!8g>O0OPjzs6njxTgub5)$ZfZCT&e3nM?KEsXiLJw^vlI zC2pPy4gwdrU-aI7;8dFDe{eK0mkA?1S8v-jMrkh` zRQs{58_~HkL4kDWzF*;uZ_~+qR(JEY>4`fDO$&ACHJlkxV5U#1Fy9g28pq0$YSWfL zhSC7xY@?(1+vXlCPkXU?-Q4YM1z$g3U*E;+UH0zVcRq$R6$Otx*I~)aDbf`|<@!qu z=`+3Gk2Dngg~O56(DVc`2+Uhn%XRZnL{@L87!_h^Cj98_J@1m-mY_9n5i(vo_0p1` z>HAk&c8V`Fd;bNvJfM;FU%ywVds|;An4gY@RGQHLmF1)Jpojy~hK>^X;48T71z=r# zBI-u;7DBZFAmAc<%cCBq59Yruf4C+qAbl;d-SFX&t&Xf#J}45y!?E4@ zXBOU<&eG7&PA&~jsTNiYoKET!Y9S)*1mU_60mm-k#tdA~m!Xw9HC7`|M~q2XeolZv zs~M7o6(=H%V&DEtP@T<6=T!cFp z-6D($Q`Q$Yuljc~Eff~;GIF-PwfX*Eye^s(1a*4|rY>UK< zuxP7%5lSenzj$@Ufw6FW`Fz#P=g9?Kd41tsTTSMwjcPR~TYZu%ntAVj`@=g)!g%h# z=53nvQqGY-{dFYe$%kR(r#1_1+WeJ7YRaTaPpzqKUxI*bWlD#sR0g<5{7}5mRNu6< zWr(^<{KQ%cXjrPJj>|^KLleoKuTZV~paAe1+N|KrxD7kel`}=UHPNr_TMqX>b?7?= zQ;4`6EYqs(R|AlSeE^9XW79#R=sisQa%kuPi?$s51^liH3^ASn=5ax}H0P>E_8pQ* zivti}GG#RaZl{y4_@sivDGiOzakiJtXU&zSGy50%l&i(*y1q;`%Di=052}GhZMO*% z@Mp2?j^#IOiT_gy0xc!jvJcIiqm2FYEc@MOYIE4ow08Iu+5pYYv7LoOi+%*<(4Q>` zw9_;w6NOYi!VZBCFy^=*J#aM{QT?Q1l`l*T+pfNoGR!q%1&fHz5VE$H?Y5tBQ$G%1RT));9p zU#qF9rD;=#H-c&EScrP}CMd>_O#su;M8D{K=Xik@mE9#!Ch)pXH@&Ro7f!q$J#Y(4 z=C}LIclCThPcagO$~@6;iWrN{SdKa$1caxqfKDV{9wK%tW8rEV-#D^XNgA1t^}YV3J;cu zc70p{39e}tkOzidxWs;EVLjhRue|^5tR2gu=VpU%o5sKosbYOOPz< zx*~OTFwVmKCSRNU!)+qPZ(H)eo+Cj{TRa0@&eWpPe^Lql=;7e6s+us6z8BayZt?GL zU|6T#p*0y0BGA@}NNRHokYX_|`s8s^`MIR(61j+GSI%jv>P2*FA%o&4Wm!=>T}BsQ ztMHiC3GeL0k3N1AW4{`M*sN|jtDi)RB8@1PN6Linw8hWU^-r(d|0tUhq3!?Uy0L4} zwa3>JK`nVx@#`z@C(w!dgac2HnP0LfS&MU7jpO0evA$G+U=Q*$cO)Np=$Atc@WM@@ zMP_p8lDT>2;2F{-JoXL{sS0|V2#o~zdNPT|*cP3@<>~nWnJ)Ow6LxgVhI)tIKeoBC8!UST97ew+HSUk+LGM^_EZd2b z?(Nd#tQu6e=K_`<+>V!Dq}Kxgl3TVBYF2RQ&5HkWNfF|QcoMYjW`bfXGpo#i%Iln& zL`L1kec(&QyP64uc3aBQbXJt?_86GBwaQu`csk$<#Q3FWk^k%5n*DhJ%&~1jQHaRC z9OQO}Ya-KuE5{pc*R@c)va9la|8;n2^C0*r9(SqeKV;*W9TaYU_vzThv!axF!Czx* zAj)S|-*0*3^zujvH)vYUQQ5S2bgUXX*H0x;(Q~SWt`NT@_?QF^D{X-0p1WChCm62N zf-T4iN3-SX)(tIP|`3?sqJ1aBtb zXEUm6+&u>9bHhQPkW2&C&Mdq_o+@FO_93dYzADgk90lcey};WocsJgUN;JB^Uw!P~ z(d~WT!A77V);k+eTCr7K+Fj_6yrirg4WZcf)W=T_aSbcv)zZ8VFsi2z_ zw9#$}{&7yo*x*gyF7ipn#Gs7L{HKL&oZ{4u@H#hG63FnxG}nlaOxD91EK6ooz8n6g zX_(PQV9h;~NHlq;F&XfZuOT&@rtt1|*H(kVJ~FJ}Jg;$pXfJ%IIz=co1HJT0!|H|y z_xIpz_U#Dw;ah)5qVRLaDVqJh{%d8547yY`IM`0X>N!S=OZY0A&%pTMU!u1GZcf+)*b=94ak8qJwIn{ck{!v2p( zn(;zeSJ~d>QJS%2e-$8F*h;;Fo$eig#vrsH0iZmWf+|!Co&cA$HrI3HIHHj3Q$_WE z;Bzq_QTbO>Eh{D_`@ejiboP2nC9=IO8{I~GiW`$6QBVj$6KG*8`S;3~$lQK?y{RE` zQH08E`rCs$D37Z&6Fik^wWrU{f>0pn7TVVE8k@!kh$;MWgNkS9dt>)^qK-F?x|V(X zRr@auT(c}Qq%-u6#omm&uBB^JeEr9hKe14_n}=A$@bRJN%<2ddnaBO_5q2H%Bh1&E zOw+>i9iQZ7IjdSfoG9j#B+o$ggVSZF)we3X#>W4U$NsL5kJpR{#pw)@J1oFvK78aD z&-3wX*{b3M_lKdUKNq4n5Sj@)YXOz3jfbKYG=oW4j3h6=y4MhvHScfO`g^cY$92e$ z`DZg$NdGVz#YI4RYy)eq5U~$0?{b*puZl+6onUp5Vj`~7o9fqr^2Ji66eBa1;5;RQ zZG9Rqwxq^d+17NXEB04|!bRadc3OVNJ(d~nOT%sQ3P6m7gO4MVl&9ysUdqQ3A-`L$ z--;(@rB$6d4oBRFd#=`MY<-(eKR+>Sk15eD9v3%K@{o0|WEwS(sav7sDZdM@EJHt6o zxJ#_1x6dZa_N6W%$Ov;|`X>M-c_XTrxFhn0ck(7THzX0*B?37KL{2%wyTN;1NQNg0CZ%o`OFS)yRTs^KzU1ytBn9||E zMC;bbSH)E^&UeJ>(_ly3LmEA1GuP+LL+^9d9djgk+u~neB8siCr;v3!AsHuml^-V+-)+A7!SUz9vIbC_jP?b^SjxEl z{K(1lzDxbkWYU<}q*Ro!z{_|N4JaK=WX3i^9l?VvWMzUV_GKBUP)Yf{>^6%iHf^dX zS#V(J1Vm*`FP;nV&pcE`@?Bj#Jo?0Mb#II?A+D~C$iSWb!%GvDfZR@94q#a<6Fj+d z2t}UxIR8cdV#uP8r40UjlOVpFFX z$%?$IgG%+goZY&b)`VF3m+O!ZuKQY+!iv0WaYfm1+p=qy{naIF))lWTq;v~U#x9fP zC@uRwxys8U;%9#=F}AFGCu{K&Wx@=Y{695_LAX{8tyuo#7&;x3rv%2UgpJ!sf z;EJweu=2l}Rj&VPLLi}l@UC1_$ke=#v9`^Rq|~b$4Og;?;!TXyrb%_TBL2>KB&f>v zMZ6HW5l+5UvN#QEX_4A`Q91br^;R_F=@=BN=KY<|B9~ew^%aZX#J(QHO-dO=#Ky!J z3NAAqKTmgtj;snvH2E|X%X-I&Ww_bSa|#qg_xN~L_N+kMH)4gW?<~X%)Nu`_(;1B%%Tp!TC#lor6SSq-|i5)Q|C~4hk?rexzQUOgrbMF6BeEE zhm|_xwck*xE`rmh5J)(ZU@?C>A~?nIDxwkPaG+j;<`*u!)=tD+N8nEj0lajIENa-M z!o6E0C}hT1L8U!UJVt=hxCaz|!<8M96#*|3w{tZ(VmGQ?)gdss#iwogi-(11UpY+u z7L3HB7Rf_bp)>e88_g~>8z<+Q6**;l_V*Q=aEK*keLwLF51f*c1eRL(`^}Vkh5iUg zYH4(qj+jwG(Oem*-8yg3T^^RVu-dk{I09;-ic2gV77eC_QZEju6zjfAvuFzAV#0&u zBA7_wcI7_GSMAg#Y4&kwNw#lqwp|K{DPGCeYE(lH8+5v2yVnvSfMUXDDB(zqna6Qw z%6Rg2ijb+IZBAB^P6>$zH%5Kxe=nP?`7qycO6W6rU8|fCK>|EJjW#!hY-vK}lFoEk zU^O6N>|~==)q`Z2M(ev{eF=DX@h85JWH4%ZRnJ@Vz6Fc(#b*kwH8#q(1E$WsST*t6 zjeeev5nT@AO-z_~SN?U1i}feM2AmY@^WkvwWFg>ldwuZO zQnvm|z1D??|NPekyDa~iwxfh5vYB^@i;A-b@8{p@I=T zd)r@beLp(t^N6L$Emiklb1z<;-%JaBRWXRI2(|V;_vU%(?W>2y_1M4MvtE~nQP-K16Y}C#9GlcB=HY{;>o@3rZ z@u@#`PQrKG6n`i>iyJMm9!e$SBKq#?T@NqPeqn9Kc_xgJ4MSB~E0OnRLWlN5IqhUj zM}lBT0fk^p@6xvSh1`+RE}n0^Za=MGN;#moA0;M6{InRc`;dbAdFGHzC3wk8hGOO9 zJ?p&Izzw7Sfd9q`M$~6Wd2kL;NM>esbdg>B%A5ZVZ3*Cz2X=o2|Gich9>&6uWToqfFQxhXei%PRAh z(-5>05jB{npF+jyW^U{#wEs~-aD<|XaEl(^A7gKNZL;v-(F8HX>wav{r`DfcB8f-` z&Bs|WD~92(u!u6FTu$_vJUzDTAFnX6V`XRGU|2Tf0kuQf-WSRfUaSv~oE*mgw%x?6 z%J{`Zn0?|IyT*1*I5BCxH|2?WwfV{mN8+D{U-sm*?pqoVwl|IwZcli)hK5#eOHABo zV3G42pW=T@Yh!ms_lwp`y0Z41U$d5V&qC3~bz?Y$WkIP|+!iqfZi#X9QO?j2%G*_2 zw1k>Xwq&x7%j=piAqIO^t8k&2ycr;a|0(5xZE|74e2~=oR+~1L&M{;#hrDvX6VXAIYQF^KElPq9VJi zz9nn18L@nmz`4KZ$$4zslzVMjBDQ-9s}sMtF#Rm!Q7}HFIU@|D7g8^lL{vre0G0-gQRNA=ExP&q^BoY?3^Rp2h0!Ezdu4E zJ=qy%J;(w#ZAztU#;3#zwnh2ra`n)-JJpyuo7&@qbBcumZA3EF<}b3o6Rk4IKE|TR zqZzzfV^M-f{ftVy(ZNlii^e~c>CD0vM+9XkEIqRHIaFbR37q4T z{xviAg(RB?KN%TnPDel>^ecno2%X!y{4dwD>54lfi6+`!lQ4u>AdQNq-BF10taDTS z7Rx+@na-Lb!BOlkmMcm-ic&Rv^fjrwi{GQTeu5*|@wZMdmXq?y##2<1YBNL;%G{+aa9YumY-c211AE>FK&p9Vuq;XA|c8g&@su9TP5 ze$$m8zSgKFPSEAeD$iOp{Z`j9+D0#NNp_00Qf0StZ*h&rSsjj&%4wD3mj{=ubDmOP zkT-Yi`hyS_9*ZqadGulT?%-Ga+I3pq>@Ah1&($eBQuWnVB3^17fG7$#yLam9{*4&A zZJVY$6y;qMHzGi?Gvh>(cn_vmLyZN;H!Rx}ZAfULSc@T+SYi?rCcMg_ELGIJ{lLnS zy)AMyF7&JW(&W7*QD-Xul(lT`b#5~&HZ;s$RB(5VejDeqv>N%;Qg8hMP|oJ|I$0q}lk zI%ufY?@GItb{YpZX>Z0vKSav88B(lv7^4Oeu48>+QTTmmYct58PZi}A?{LZj<2I~{#Vko2u~h*n+t>Np4NVog%_l9Z=K>bzMKU&3wZvk0<1O_ggnYKD>Lags@?U@im@D%>I-!l z|Lz?Q>k~0@?pbn6WzV0O-Mk|DdR62S;L>X@p?V`P_|}L zF5?C`m;`2zzvZNi>|kLN2(PkWYS^Dqaq)kQ+Ga8f8{w}z9rdn4+r3!R2uJr~FLtC0 zB1eptoE1w}mV?nxSxWrY*~Fp5F6TZJrjT94aZL;Fj;vUMpo{Dw zXmp1vX6UNpU{xY-1{XOf(Lq3UdT@u7FwFC7hkF0`IfX zO`raVV2m91D7>JqF>ED%eCTyx5bMG%@B1we=e-@9?&g^6Z)dRYw$GRf(#w_|%;c~YjTWeZs0Q0yMIuKd$CqS_ z^L78A|NP>^ICwqKcg)J{(GEtjjZ1dznlQO!MXZXb4HX%j%d5|lR#zZX&k3Pv64Sky zA5oYuJ|Y}?dgp47u$w8X#zH#*yxe$1@^m(b=bK)V1Ku$$!8Tb%ELVo03gdG7*0&RL^Ks1_FI`-UH%5 zA%bCQvmnt47SC)Hdmi!zGBLBC8na7WeX=U!r4lYbl%5A-Hp^3uVhu9eZqJa z+7wH<8V;q$43YWDLtOliY3g$a`Rs7#*ONRkt1ptmnH1c?~ul7@L*T{ zM+`N08fGQcK-nmdT(-D9gd{HqaZrRzZ*6D~$~yEinSgO$Dc$s%>WNk2)2Qd&&KK-rOG>2v`lU0hFlO-vC}PQU5zcqPH4lEISGuW z+M)M=OkT*3Jr|-K63wiJp;oO6r@N-DLNb_lt(ZbaI!2ju08#lR4^dL(4!#5<$K~Qa zeP&x$R#;x2TRIRQ9={YuVy?~piK*)ryV;ycnhHc4zjTYq<2V;lM;~q;zX6lzWdb_m zac3KP%7OlT|643X_LwNHGfM5L4T-MA-QNM3BM9%XNxm>FUt~}l)ALa_Fl#XJ_it%h2gq|7dQzJ?O2u33BeCTf-`UO`gxMhalL-prk?p44r zI)n=AkFHXg6yRu$SYaK?28GL6xj3%lk}bOHtZ;=mhMCiad&@@8g&pQ2N8*lL_X=ik zP9XrX9+_c`F;zm#-pjAtX}oV`t|XW1gKPv^SqXQpMO1sBC$66RCrBB)PEA@l@UBE$ zDqu}0MdZo`o*5Iwfh|);&LaNQo+S z2kBD^h){X2YF_uj(j7Z`wB#a?s|H?lpQg99in;J~X9M&QE-J>t3WpuebFb%eDVCH` zYI7W5Ylz)2ZmLPdx5ojgU?msfVpAMYjJY}+5=Mm405Whe21NE6tm^GW(b3exHKgQ zuahM0P65B2FJb|6kITONS4GrK@y_o^V2P(lq3UprIAyFpk`m&b&h6vW|eS;x|<<-}Hyzq|rk1a&^O78($Tuq?lk(@QW)nRsqw! z+4%BO#5*@jOy~)DKE9U>xXSP{KEBtmCE=}Ip8Uc`aCyEiWUsa~=lBKblSg0osaquc z-V(MF650fm>I{jz_%QvW+4qsEcsB=uJKCB{RI-z!Y#0ddtG%qfu5*4GfG!zPx~6yP zPlpN=694$(VFL!$?#@N^G}7CrS^fR#^D1m`J#g+trHNXd2cvO8BQFf)(h)zGIot4Ph`}S6WXihqk{W>-b#a}PpF1PxXFnBLZ z8f3h<$;jBmLc}!+%Pd(2U7&fS_dK1aG!tQ2v8b8?4O+n+1US0&#J=a4y?I+9nFcHd zM`;dPN9n{4-}rFi+@CA}Qq zNU(OGW)JC#Fvvj{0yKBI1snYB#>d|i7g!Gp&R2?japfRAbNj-BOc^rBd9m(!Lb+7kwf2z2rhv`B!N7K96zz?z&ZA0$@;0|J3;vrss~wLdb8J{e z(=rdaa4U%#|Kf_&1-;&7XrWz}>^9lh6Q%H^b)lIr@&s;VaTD5_dVP44H-m}%&CSuM zI8PVnI;p4DswpW-WNW%=4Rku$rHN;io-M@IAN#8toZu_o$ z*yXx}Y8}jO!rnKBer9~}gy2W* zSgDG6h|O6}L$uQP1rZij6;}7~Pb98zc|TKNS=dN!H{PbABA6XH?D!1Ic%kh#>+86a z^A=-OE00|ZkbMACT=X*Os${`%XIcC8gF*ZEXGT&R7Jb7*l%P)aRgXE%amDQ4BT6%V zZ}y}B^*bc}jtPz84ugWOgn|M7YLY53Kkw%(?rE2Y9PeOskH)4H+N6|T4XUrYmd$gT zK@@6yvh02+4*&53{_}fu3P@NlHa)_LhN%m5#+=tE&Qc|_u8RcAo3Y&8PhacKbMcDV zLgeDyr=P`p7zT!iW}}j@IP{&^Xr_ipZ$!QBmIuSm$1D8+etMX#`v%~z5Ym^W<8kfa zS4cg~@Hs{~BJvjp6qBN8@4v_ePWVZ)vn!x}JKKWFH#x$a3H{AxLl zqUVpF=J%blM#{0e2|NH|!F#|d86a)iT`v0y+^_dX$e&xRU)Y0n3zJMiX3KlloqE6y(iN)5?cbK|*7oPCNK&Ka{FD5GD4 z2KCX~EfpN6CX#=8TnVl#($?!W6OMqrw)%p<+VgjN4N@9QLfolxa4MqS^Hj9*zRV@2 z4TFP9nkrqt;Ib~qDVzKDI#^zENUl!;-eoj*NOfC8Fix#KRCyrn@L|e4f_1_ zi3cY8daxgK>Hhp{yeYuz4w9zus1~U39CVskrWn`4%n}*%Sl)dkI|xn6FI|3jjS~ zyZ{+UDFC9=g^%qAh_?A!2gIO52XOb@T&5pCS8i_f2($$kJ)Sl+?kG+-2btABTi!e$ zLRqUth)!rlw0_CS$*M9U#|PM94Oa*oZ~Pt=zk4TAXv6RXz4L3XA?!C42@?f-=-V9H z97eRo7S#{2EO9fE@Z?IEBS--Oijz3pe`AjS{q=-Tbw0w_IhHa`ei1a7ca%dKu1?gR z0X8~6t{fBq&Aquw7l3?GZd}KGGB*)nda-?0!w!Q1#Om{=v4R88ZA_k0QC|kX2=Ro< z{za)$7)3G16Nr* zTVs}E6BL|1h!z{e(B2O>ZZ|xUBYRNMwpmJSXUEI)2%-KOoS6EJTHo6A14qjz!+@!9@D z0A~OaDv5QH<&;#%`z0#O4FG??JCRjkWCaw9F5#Rky3KcbqiVkISjACLWX6zc&44z~ zycrS-Z7kxa`XKEN7g*>4q*S^NK(ll@Ho z44RZedjb3ZYVPjgz44zB*ZFw2mVd z9GnUG$jV!h4dOD71~}$=BG9xvQc~yAmukNmn~nS{_y zMo8P?^bGzssFg5WsFSW^T5f)S`WDc*bwEB<_FWbK4w9^p7(uJNSuELMM7aoakFo|Q zJD9)?!LGW%s@&grY_0XsyHJ6nR3a+7pSZW=RG)E(hl-OC>Td>>sE`DfMBiJY+7I!|tuW!ov;S+FMZ?=h4s~ZF+dUC<| z`-g{W)mfIAFasov@Cgws%A zY@oQkXovjrTv&QFE_nPyd7_CuP9+ixL2Lz{%OirkP9t{SiX=l_V&;#ra?x|MOc6R5 zYy-_Gc7*)n2$G8#eHIrGCOcvQ@94XY4U5ABA`#sfGLRLT$vsj0HlSXrYh+~PYc*Vw zu}bF3>@U8w6A(&XW_NVD67D;4<59;~Np1X`HFoTEXW+ENg5G5$>9@t+l%jS+6$DNK zEf>}glm>{xiGCiB+EE#>s&4ZfxTgxy*Spbi``iR7G@&>bIFNJ(7Q2QYJJXQL69PE* z32hXYZd5ha7o~^kEPRzo*sl4rA^^f%iBl&n&-k`|as4T(sk4_!818oY0TYDi&|Hy! z`vN6jL-cGolkoZVjmA=_kR?H>dHS|!&hT*}_^&j$q%!6;Jy2}w;xGaKyOKR3&O-ZV-`EK&t zx+gy}D;#=};P4;4vDTI>#??K@}O5&=1kPz-xDU1<0%MW``2HIdj*bLu%= zQvTTwOH7$ev75^j41p?q4EajmNWzU)6Jz%=QMN+@lkz^+#uwp~%8yl(5Tw;F!0|*5 z(9&}G1Vg_lw0EQWbiOw0B_yQb+I~Yt1z$=2@kt_Z``n(pu?Z#l+hW?`xb(^1kAp`| zd+p7;zHGp9ufHmD;_pBG|EL}rsMnRB)oZd^pZM=z3NALMzMPS_A2bPL6AnG$M3Q9O z#$TCQCjxt~O`neJ*_lGgnP={Ky?`QYPC97|&A)HBaSS7p>gcBP2;#fm>(j-F&|;F* z%;UbTnje5nu<-i9FW;{As*&vb1kRuO5({v*v|f^v>I~k7gbQ?MZn0y(+E@5>-QcuX zegE<$lvA$!WRXnX;8aHvZPVYO2seRPeAGg-_lT^#pKabK{M^GUP^?j}XTwd*F@d@W zv3_xjJD9e*SYZYQz`w~d_S)~uFICYl&>LePJE9rLMk z^ZhbC_37{v10=TiYdg6ZlYQU=DExGa??^4FoIb~q@%ineEUN~uy2wPpva#o9fLp^% zaJnxNxuu;XZlC1O8w4*Y@*+cl6tz-<^eD z$W0LXDkFJ@4) z`sZZm9}WKB&3@p&AoEXE2QMLKj_%V*kT`v5NEt_}XuUd@+*VT8n= zUpjpje`Ma*H&Rn2j~o?Q(vPb8=>M^#`t#lV_oLtd=>ZSo0}lV|SFXpj!fE}$AWxZ% zb+cQz@)g`4BNE!qWHKc?WZ8`{y!I`+4zYL-P9+?B33b^87nPyMi!fm3=pV25Dw>iA ztJ_#>{8Cy|^=TrGUikA+=V9CH@A#qS+2O{)`2UuEV$HA~_ZMnOQ~d}Oe$JV)Fm5bt zh20C$HZGniT1gxe);>{5bp2x=h?S`}9cs3qAbJhr6&^6!(~)*0ud!A^q2Jixux;4L z`Y-{eWp`>j_17B!x78SeiF!%r&{kRgBAeRNzgv4o1tIv4k$Hx_zl=@CED53XzQU^h{qPMu>NG1?1IbxQN-Ov$*wI3e;KF0Ga(B$ zrl}V27{7N_m?$=@yjWukBiw^7P;MQ4lxU|4HsjSesNNl~vdejPn!icnya6Ah7vsLQ z;b>XhiuYE|WwsNE+v!<$?6@yBJd}4>H?$oh?_5+{EGM9{9_} zQGeFQbR2$g5KKw44aSx3i9eg1MEKo>weG_mgW&!oIUkf~c?6XWC4U~g1E-ec>I zZaqyI=H2dJ_i{bH6{^yBqMaX7hW<648*`esma8SvoxB7w6thDSY4?yL#;oX+{0~4S z>cB+#1I+D>O7yb8<<^;pQOc*_(kk?g4jP8RKw6A9IK;c{>B769)9Fs)R9941=}d#( zt_kU}0exZ3Le-`Ut*br!Pe%_e;q>J4>okF<;A1(Z6r;s?E38WBg)jP!XX58{;?-u8Bw7*Dg z+M7i?*uTMbnEkTvx)+E=-J@HZ-nd1RFc%r*NxRskBv6tzH}CJe_{#ZYD;7-n)kZWH zGlbopXx++Agl??)*gVZxa7Dy@c#c1l^0EK^ul(;C6#fizx$ya<>>Ylf>zIZLl)q3= zpjwAe%Q!y!So_?`d(#@IGR{o%IJ^~re3cri4%Br;t1av8nO6CC(`{U(OCID`^Fs+bj+UpUP;JS1Wq+1N;F`Fts4tv33~F*BQ!GF_WIr&Bts zV*cN?jt3St)FiLu7r2LZfF(0-BPJ8Vd#K1zk?sO`0F(R2$E0b8H!#XheoCaIOu4k? zPhHZz;j-T(3P7RZm@v-hXx@Y^V=|N%=RIqoQhf!j>jP-!yFE%F=5u-T))yMZ!s|e= z7!3gRV+rcc4s(puS5t)*1Wx{dHw5;FX$sEJ8()UundkPJReHM>6@$Jdl-9#p8!Zu7 z2Ej#yvVjRiJ{N?k*n4R8*&PIOfaDoYw1UZx4^oAF8O|7OE=%ck^X13AV3=iyNzyn4sGRbT4IkDA5JX%H$&w=KCT?s5LITlit&^5;}_n( zxX2Ksi!GYDu`U2q%xURVr&}k;*>`??TeHKjb)5Zj{-Y5OUWq`~_bm{I9t3L1`_x@& zw>k=09EXQ)0nqzwZ+lcy5~ky+jzLtbpBK`rI6t2GX*IuE-`DjNY=p} z1`#SpeyZ`uE}8`FC}y^_QQ&mL;#(5YvH(vqqvZmj_6I2xDsTJ}MAtoCU1qOtrT6Jw zd+_OYE>Fygq8_0qOJluNyirl1%2@$` z7)}et1EXUTO{tNAO9!*b-HmV#)gqz9vXNYjWoAw($6Py#qR#6I$#Dug=LsW*F#=A; zIjC-YixP#EefbxlR1EDx1=C0E1~%1qK#hHNrZE@Bdz1y3MFcsWPb&-SS~z|O-MX$+ zHaqCK3@YFa-4cPTeMcsz0!sYz2twHz+T1h&BQ;P_T^_k{ZfpX_#XtM6u6ef(RN@;@3C9*jF`=bOazz-H&a zYMFKRFmR6PJnc5^=f&`k^B0(UvYCyMFp^gLydLcr6&~j;=^6?9vs0W?1zKa&=a%k8f(j*CcKXVcur*Z-=4ID83xmPe97p~dmmySRb3 zP%dOPlJPS1ci;rUgoWY(5t9Ld;o1;o=krwd0<=U{E+fVFCslzqAcAWM#}Oq4g7hO5 zexlcq3tR~1s1#%Yx5B88lE$&#@Hc4;uAd;l!J51jQ3cE0YY1Xl0cDf9ZmXG1u~@Uj zO&v~K1u*Z@JgJ}HGd>GpTe?8roL%EAhly`^D~yv&&iiay=jZ364sPMSDF^w6N;-_D zSYQmsNXlP*`L(U6=?W&keUx@gQNF=@DgXU37?m=W?~nuB*L~>IgGMllK9i zLk(HBknCg=gM(oh#|%g8qij1%MZ**s*d4dZP(gMxwAaif#j z+2NYVM;McY>bDB!=rT|uebrL+k2O{jxLCd-Mnamuz{ zJpHe?uQh}atORMWxL_v1(v=P;AB&_E#xP&*$vBg)_H!LDT*8B$!j(<=8k86@HF3jd zZdN8F;e)^@D)o`IUHZ=X_%2xM)mL&|)hG~Y788k$2s{;Ou+JdxABEB1Q>t)sS@#f_ zLv*88?l|U3fR%whMh!}K5y$>)qdBS=Lky1VMA6ec2$dDmYIp|=v!}lhO#Cl(d>hg| zsu1FSZ1R@VWVHXFb$f-esAraaNgHkCH({?tL+VXf$Jg4E8Y=KD%e}=YRo;>nVcl(A z*HK7OZ#u&7D;o_atn*gFoG168_WOJ{6dMG@1Yi5{Pz+uB0K!LIZG^4(-QXLs((wGA z?VsJb9t{21ytyTRFnDglS6EnKZd$6BC4B~xTub8M0pb=|0ptTRbC+vIkgjOEEeUg5 z+XT7h=4p~Dfr>301s80kW3duThe5A*8)k4T%T=O}78zF17GcPPGk2%ePdLADhGcs| z`Fi(@O@+4MzZ;EK6_lqv@977fEkwg!!@$6P{1A(ep=YiSVpYv3BEXJAqCcOjaW^ z%p1(+jyvXy`Aq=IL7M`lrmmjO^bLt6*J2CcdCQ5UUF+atr8agC1R_!^hMw8k_95*% zj?j-GlQjHFCSti85Bc>oU~uj%NE=fi-u&e318BzyZ2X4UIIxad{+4!tdfP|&K$V)1jmMfSQ>lcnQaXbC;ueY2ubNo2KExK6XJSB>EBOG z2KPb$ga)Ng2=+fB$~Shj;g#8x>s{&Z?~z1GfEX%58Mn?Zivaz<3IdoxWRhCmig6a( z{%0tozj|om{b@rlPYUDiW+?OtZ%a8QI_Xnx6q7oyCVi!>;DpZLvBLNENOGYg6;?Kc z6QKph&#&zlLVr30U6)e^6wnjy1xCiZodW=xa;71ysS^XKqm~ z9?_7f;5g1Xc?BOa3|!3uH`^VNV>cGa{uG#C^ZD;ZS|KeTK5#glHt&QXEWgu%dLTFP zLXt)shl0{Y$p3}?NV&yXX#my?HP1i$24&U)?9@_Z+%F=zIyCnJxz1~V>>d8K2gZX1 zN-V%}ig{{HB2%u>txd=JZ( z%Ugf>g8J{*7|VgkrSkoV;Pot}q>B8>Nuk*wC!33nDT=(0`PlqzNLR>8Orr#Say^Mc zpC3kwrfVYo5%w}!EddmjLPgT%))fw&idS4Po2{W zSga3-t6h*4Vte&Z?yy{J^zGv|()jk);txOS?}MdH^^lsOWf`(P8UktAGlh_!J03ok zkfb!F97PZJdJ}h&l(X@c0_*e9M=@!FXN6{YJ8!q3-nY32?e9(BuEoclZwU_A`uc!% zv&z)##IwHNR#Q?bLfUEabQX&g)cI%Q?0I+`7NX)kzRLX|VD&SW^${drm+emg(MfU@8LYOwDLJ+3VbVGM20nrEekOcnAmGk?O z)Lut%P(aI=1UDS?U>1`Qz^68gNTUA!v;XJ!VV$S&5Bo-z!uon+lXplJW4=~%OgenP zi>&3Th%vebMs?EoZGS#3qMlIgak1(s@u{C*u6y{lM0n@#eeCBgoJCEUBNCkBjs6?? zG_>u4F*e5u>ioE-@KB7{x%$H=th66S+7*+UR;-V^zLQ}3GjNU;Fnxu($kZgVzzM+< zAKC)?lF*}jWzy!N-LZ$iP{ER+RfZ5ok!M94Tb|NvYh9t<0qqJeXiYt42&mqW&Z;0R zaTl7<=;*EhpTcycIz>?t6ehca9!iUKy2>uv^Vjw#4%2@ejQ{l_grTtb+P{NogE?)a#F9)DEcsegA|6EsRzu#QDE#iPiS$e>mCY_z`dbsc?)R>r$_g`iFd&`~^Ie zT(FijKH!fh0`V4)wH5~tkA~}W0H69UwAF@v3A2ua23@G@llAh6Jso%&#=$FIon??C z&kIY7t>S_@)9y6ERIRSZl7F6!|22{PdrtrRAJyr?*uw9$T!{=g{eHkhl>V3|zo(8a zN)#a2N#QgEMm$J3q#BbvMC&eKy;t5IM@*m*QBmEX$h-_Ms?IkOvok1-P)tY#=#qgY zdk>W=pw;MPH&SdwC{qX0+k56O0Nk_yZw1nQ z47svRpguujBP~s4ZHtiqQ+&9c7cI*< z&>Z9kH){f_Y~mZpZ5Nu3FQ`4%fRN|OIuGto{&wMqZ=h(1!mNLYcAoqQVu{shnlyT` zi8sS=^QSp+P zuZ{ESbwn>WpUzhNf?g&d#(jJ(?>5bHv&CxuVRe{y2B^XWJubsplZNdV$&J5x4O#Bs z*GZpg$@aJHQxkM?6<&%KpljDB1!N;hm^I9P(#r(cG+>-Q{)w+M4fwA~$bxw^1b9Bg z{daL3k$cqdqd0J|g4OXx&t9@5RW~a)xA`XV5DIV3-8OPAV^*ATWVKM|qxbZi&8D8XvEv&D^TP699hSUz?% z@qQ+53-0Ewzzn#&$o};*|BpKfB%Q|Zo)|<;NCux8mo$TDIQlS5mM?eDcvXdO&^bzy zb`j~ESMNUN($@REDX^mrT!>eX(tdLNsR}xzyd_@jOp(6laK`B$FU>Cf7^1k95Qc?? zT8isikz@TYT3>Zr(M1KSA}oyCFnT8&>QaHh#Kju?bM>UdEXg1)mbj^6^l;d`-Da2t zhaGaeBM@CoM<8?VIN1wd7!Xz&il(^mVt>Ej@u;w2pT4b@7u#QkS~M(NK;s+b?;Jx zdt#Bd_s`xd)x**xFQc$`b-nH>V%R4O4ifDK_SYcei6&}oy7>aV(zi2gWatr0pi{;l4}-`a6mo|vz|*4?Ofvf_Ho85g$hG!kq6a+R zNOWGSj|U7@6C3wia=u?O*@8O5ggrY)TtuX|Lbl#D3M<|fGSQn4BX4b&tS5>vZgms5 z8-49fjrce4WB6`8_E?*gGs%FVfYV-hGe@@#1Cf7yoHey$-LlF*w4kl*DDlBhV3f}Q z8P;AwKV~_h%WO3uCR**a2_|0Z8?Ee4t zWq?e{IVB3C{W7>fSG%vnM5fgZ+V*!(8z9nLH7+1V6Ifnu&)(clfG)bEqi^jNP@Qf= z*Z5n%3d3}2QcY^iVOwVB4*-8tH_0&kg+!mxL;-x@>|r>o-fwKe2UIe62X|60#)lfz z{wWC364tN_u);}&UajOS6d|u+*v$)Yt*;|z4N9IwtQ)}1H6q^n5IR$reJGhE1HU=- zL`T1w2U1*mP?>V&0>90TzkdGML}afw7t#yALox(f>Vl(mzFF+^|33TwqnznH1@x?O zQj5pW5#nw1eaPw62B35vpqx{;JtLc#z9BqT(- zQMyZ{5mb~0;nFE7A%aLFAtfax{W~u+qcflHfBn~*SKqiw-fkCR^?1Zq9W1&mk8G2kYwdU-%iiRPl2JCqKAby*X?9ZF>^2fFj zJ*|EC3lH66Bo&$R{9LO0xAMP%)c>z=hCH=2g~ZP*=W2|*A{YwsQ>V7P>IyZtn(2kN z#Ue@{$++}jy<>WS6}e5^JjaUne$M?y)O4!22rVt`r`sXscS_nhaUWN@1U{5c7c*+c z^B$golwu6?WDNlKBo#McyYnG5uE`|n?_geR|0R-m9c6Q*eUeHefjh2@cZ0Ot9KJb zoQodfTHyhY1<1({tcB(VXceE?U#2u(6O=^U2H_N6VJCgx)+p{*x;3~Jo@d1AsCCV5 zTE2blF=GXSO9l?;Xx9riK*Lynu$IGY?+Cnvyr)#Bt2dN zq{KG95ZbLJ>|WzGJ<03UhZX1_l9}%3taotL$_&GV^x@1QQs6R zcffTMA@orola9|~FZ13Nj#QG1N6jJotbz3|f2kG z9pGWVe6RybKz2fZrV=mIFQ^(crM`iZL=noi8Q4Fo(fF8D!E&r>aDEjAO%zM(801mf9qAX|G#h~ zuZF#PgBtS$8;AJ_it?@toaA?!an9YOgGY8&Z5Ybi{6TKS*nqmCB~;!-TUS(hgf(o2XBIE-1d6^GwjFvD|g z`-aG!7ZeNak>YTrHDHaTx3dH=!(VC}#ZDv9<6&*&J4&G|5BuJ=80@KakFCd2z$-V=Yd|&`S+!QKNrF>vSJBuEIat%bRG(g zLy2piAAUU;c;t}~6FVp#RejsXW=BAIZy9-v1b(>mOcwl>vA+KJN`9S#f>|6V^PXNE{-0QPe98jE0w9@$_EHfT|1*$6!zxFI z4iO>6n)R(G8pm!eqO9N&t+G`VfLtnK0&k!=wE~o9QkS+py&7p0m8GVs5c{$w^Rk{= zuU}T7s9ptY3l~+KySQca6_V80KGx{g2ub%WXkSVx9#n0{IEk@Rvcjm689So0b-<=y z7P=TltJ}lTXZ-87cK|N?ft?K;SRNRND}d=C!o0zkvpK%ff1e#q1WIPKoHIUtGvdwS z>mwrP7k;UV)8@oacHfQDx)v#JY4h*Ab1qfFQo-qaM@_f+R(SM-)bX?AeIB*C?1pE9 z{tZ3<71e1xP!fHCq{|P;8B|@c;y*!(Qi8RVB7z_DmSIqz2~Efolj9vU2)+baxc9At z>tN|##B`q6O=|Nkzs|FK70+4SyV|eum9Bhrxzw8V(!#i|fcEDa^VG~<*0=&ZPs9}0 z!j64blZflyTLE{!Uo5B6u9-_8U0_Qk;(6$14#fV?TQnFBWRQ&Gfln_q%t+{u*l$5> zp$Ff*2*fPf1w6*pRd%45xEjX0J-{;k8<~ZVRHBLq{fNYGOz@XxRq`cf6}@8Zs+3e_ zWY^8{KQ^fn8^SxwmpWej&x68nSJ1n)RelioalnRZSuBlIOU=5AB7jyoqBvu$N+s=t}i;r*V=nw7GnOFg|nW72*r3Z61y zt#8+m=au0i7UBIo*rrbHxo-=zME{Wr2c=M|3>CK)A=iY_xX6^xx>Pas_r^cVM==C0 z$RRlkKu=i;!fYw_w^Lh7!*3128g?4Q1ZqAS)!}~``26+OynoR~u-o6$yS%NqW^XsF z`}yVy6UeQC%GQ4mnI*7Nkjj(SFz27Guz#Pygeex`Q!+NK8$1s_&TS?jB_V9j+}L#z zh?9E0(AoGTU$y-N66I*TP<4!)k7|50(949ZeKt9MeoiTmnY2G>GpHsPYP`M4DhR_` zjLgH$YnqgV!>{Y*kiP|dG8k|+!k(aO>$UH z_NHsRA9{(ya}e#KVSekv_lbXAmp_)kJJL5#{%%C15QK`E7YSD8bZcTK1?U zkrlT`6&DjGM{mr$o*Eo}U$X zdCfi{AWPyq|Dvw(ZkI>tVY1W$LlZc4Vb4dMPa*2rw;_F0(na@)tE79S-GzlaqQe>5^af*aedkcPOB=NPSI2b75W%28>}@d@Ya+VueDUQ{rf#s(GiGK*VlJM*^PzuqOf-h5RqN0* zKWxq`0&6h1ntdx)B9NHT&5G{RrSO|>|GGZ%X4nx8R0Pl6oeS{pnE_B+Eh}B7mj7u@ zg1Er14vJ?Ji1~2y$m*xj2z^zFt9m;6?nqP^W0Wiip4eZCUtpU_9k-khSnsD~7r)`8 zGm+WiiWQe(Vgz?$O@0FDFTfO*F-iouo(8HKnew#I*{J*U00-mi(iy){=z-oIj@Gyj z&#AzEqELq%KY#yswe`P*t6)=jf`DxXVtSns?u{aYjWn=-4My>!Fqj&8U;mF(@Hl8K z;vB0;kCy1mJr80wLlbY~DJN?3yia1KZEIA{(*HeCN0EW*S*S`={;BVU5yEFYIm|Ze z-<1PHLP~1xmC9pL6Q`{XOW)1;$8*D00t1UXfCt%)wK-TKj2>KSjc&H7u6Q&qHa}Wf z#_V6n32Ev&HnNVZ(Vu`kK=JXzVVI?Nz&Ij?elUROhTeCM1?YTm^b>#!deMmF^Xu*i z_NR%8?T^1yF!?hn(+aZH+#^Z$xSXoG$KEVvbG*_7TgV&XipYjhX3IoDh%H>S1{N72 z4*UtW%1R)$UfTN5j~HSn3q?=XuooFiW*&j`5vM6#Xku3vu{610g=5QRhydLmpI?y< zya$HzZx(2U`(W>d2{3bD;%5P}UoK`$8TwYNzau{!WkDFmh;SoYEelv`Jv4ZU&%vk= zslrpbDJH;uxvJSK{RU}P)J%Kx7l4+c=QUL`M}A^j+JlT+TGsgD6BVq$MZ z>{rOZ#PXqxrOzM_pyGuJWFb&Ibcifv){f!VMMFrYp30X1qL4z_Uh(@az#qs6Q3`Py z8rpMal1gF943T)9Vvz;K0|jb{26U*E&EGOP-wIUX}`dt;^=a(HWtIf4l&)L9tsA=2yH4+&i{!-@e%n zF|W5FOKP)$&vdy09E~A1U5CAJoPbkYdkb56RNxVPd3bp7sdXLnlKbYpPg3UmYL?^ zCn-wDg<_Q-*!a{UEKo?2qud$z9Dbbsr9p4*A_z{TTpX)9$7kY*#Z|THgK*i9IF6uc zh=I~34xPe{yK?{&Jf7>3q#@=2!D7;O8PuD-g)ggJ`%YhSqXAaE7Jlkn4?HcgzPvKI zz(cip7w&3BQqH83gzO$7ZoxSXW4jn_L+9(rm=O{G{@=%mdZd=EY>Pc=F_B64GVa;@ zueut;f8ca)KS_X>{MN+mNdJ8;83=8#Cs3#T#T~I&N2o3tR@x`!+3)-`5d`AN%{+Zw za_176_C2WJJ6bMz{`h2@a|333XJMNGoq?O>+C=?{HqaV?ZGyO&#%A-iSLh*6n6i2E z7QOR2V*yppOdXob;8tO#$j>o%Mi!rFLy&1R!jwO*q(k=j%ID!o?0>EG^kl?301?SF zjQwMQwe`kYf)A%&)DZ567M42Nsd+ktiu_>Z(@TH54N&)$35`PHM~0sZ$H=fe~oh(R;KqVV-&MX0P%2*3|uKn@Sr@t#(Y+0IxE{F1RqneSgJjxk#ImwR` z8om?1DDA4lmJMk3&f}Y`Y=EYnw}2scvZlkg^9xoI zI=A0xag;rM6E^F;rw&Z2SeAC%OUUAYeN~JjPue_WN~cuMER#+|L=**H@r-m&BN)Z> zzwWCxikl*OH9ShQBd^m{Fx=%rb~ghhS9;>Hqhp`x;e1_f?pURRBwe&@JE9CRM2e$cPhN%x1w{e8a9O(#0^;D3ZzGGwCuzc<72AJHro23H zMrv&h=}NmI0+#Hj>qi&kQrVsJ6r*~MuoeuGy5Bv`bzc4R4j|79A{s1r%t ze&TqE_|ag|^(>q1>x9_%5T!=dgOI6j`YlLsxr7A-${2`Z9Z=xwKf%bWgGEAGlj@mb zE8xDN77N(XXub0=hM@Y2sj)1Bp^T;@y`HM5VdoYnQE?yGU#Oe3b5m!9|{ z0w9~@?FRwT+`3-JLic(_43cEAqka3>+a7@8J)DfBKBJ!qJPHHguZM94mCa1IMKeMb z+Prhc_Abz=o3ClXjN;v{1=-X4bp1ekngQ<^9vC{8)t{QjRK8pd8W5Tn!9!jCA9 zwrD-8H{|3QAQk<9o#ukxjaUYS#*t-mw%<4q_GwI^XQx{Bnhbxxbew&A2)!yJRL**W z5>{ug8U~h-KyT)3>fe%ZG0tQ__T0a_d?k)PbRUMkSuUFkSH4UktfwO)6b?=#kgnM< z&-$exzQ>eaKuel|z~XZROTfzFK_Ar)a6|0flP!oAyS(Ho?8hn(+|7@#ALTg@lrzmB z(j9TvSxoBd{ZGG1pJhmwKSzX(jh)3(jT4Y@Uz(Iu=B*bC-SwL?gxE5YL}xB5pFAmJ zsY7^@qPGy^$qT+Le)Ha)^|7PcJ=M6S1m$aOg5AY~ogb5hw`+KXd4<bppnv0htERj4$dKWr;#Irq#uj|5c#@;#NO)>4eCjhzb$_70VdFE3 zC@KNc9|Q3?JzvGvkcG0V29H_YCcfEIMF|`hZ$cbWcAXx)yEG=k=3i}zW|Gda)k~bw zXqL@_}$M`&;N)!`T2kHqpxv2IQa>s{wK61I~mp<%~!o)v5 z(vYbJbcsxb?2&Zo(+J4s24cw~NbAL&7r5(!?Qyb~Z69+2s?z;rQReuR*hwZRp8)^* z#Q^+Y80%kC5WRHfQ;~_%J+%*jC78YN4L&-d^?)k)|7*Nwy!E_wcR?r-KIHf*rvWgELdt%{=<23Yog;IUnY)n zO`~AOxGiO6KO+8<&!10hmo6=P`t!h6@0ZKRAK~9Wo5lM%Goi|DM@o$R^6xJK_WT-0 zp+(Drp%T%6IjDqtv(za}37Bd%|q+pJMP5Y|0HG%iFZK<@|aJfD6;7$v> zpo`7B+DRg1arXtZ<-y@e=QP!B;|}_E(_s+4wg+hES1t<$hKKW;Y%Pyk=*!p^Qe3lq zjyU|;IDa`ln@l+@sOcjSt@2a=)fxA?t9;N2r@X?0{f_#2ydXkax~2Z+bhyXySO0x` zZ=#X}-4zcHj7opJu=D+qFvy8!;nPzI%y;o8o!@;=YIYb!^t87CP5hpr#X0`zmuB|C z>7>LvTkI4=QnwX7QN9L%=WXDUo}oWKns+!=G<9tHOv0pu^6N&$e&>f(np|8Xoq+A_ zJ%t|;E@n+r+gT&WS#x+!Sa5QCskWL~&y$jQ-NTSbgNkxpfwtQM>bReP#Iyly(JA4L zh~a>e781=eOEGi@STAik!~6_sx8)%yKbEUYupZkHRFg}ZNlHDz(OBiWTrLNLIi@X< zHF(o!X4NQ@uKp7hj_>jav(4_DH-qHdO~L&G3%lLclr*;17dkhIEgoOvOxK+vJ`oqr z<{E3vrK6>?tUFt#pR!xcSYyXlyYBGpuiyedCc+l=hMRB7QfVph_iM+Ww7fl5zwxip zC^sp28z_|%r?Aa?DjgP?z)>?7{Eid=(PBj7PEiIGL>Q5nyYVVbl5;)k#&7-Fo+{;0* z_5tPGNW>n?X)qKJcOJU{rfJ0-1G##pyI!lQnvkWW^%k?~43g(7oI% z3$nk@5P8)?OSj6&mLYh7=XcOVzUUsIfP+mXr6RE}weD4eE=qCA$8A4Ow#!T9S`&LJ zoN0@S5fh7{nNqx;TWNBXblROPJl`#GI(xihRwNn1=071^1nV+hr_=CF*UaCq9e;os zvR;pC4zaX_WOND{s^~t5NYS2!W8}fdYzjSb8b79m+VuuFk6JacbJhIH*jVUSa>CFk zGFG6cgy~4OEhWOxq$#)ni{W86^Z*(U)-mu+VXQ6Sw9G%M*=Y{o-d-A>O&A79V;&eJ z$WY@aY&(>PAwx*(HSjD-;prj>;5Y(9oNV1n?93CG%|~-@Y41kA?J@jaYnXdUV1pX zGf+v9DwT`%Wc9yptTS?B*DWoUvj6ACUh$S_P}2{R-+L#OL~8T}7d`-#6h`C(u<%1A zHbCwh1ESH}^5QB&`V^o~BGL$*dLC&19d4=e3;nQLV9ON&`-5-2VWvMRH3;}`JK$lW zqnCkpXnS%d8NF0G9Fj&%%Mq4#=o7Pqxb5`i>q%d;-jUL(SqqFYs%dz*r$rAHAi6Zm@1+d8rS7?*fz8@kx(qw_5RHk{kWo{HKso@R zBUOZ@hCt){UX{t2aj&jFG4ojM6C%ru^lCek~uC5j&mqol7Au=Q6>X#3zD(ei#oXrs%q!2Ojxoq)dRz4CPeu;ZSTl%784Pg#ij@OK$eJ5oB5FI`u zSKReO0mf8g2b}?81r-uJ15Rcp(EaeZZdp#f0Y>uL4@J-H)$V zJ{va`02hegN5?bl%~*!oVo4y)2K30vUmUPwDfetI&U~Qp8Y~u%JsJGEefQkr%s9P2 zqxP~BD@a`QZ|(7zU;A}I(sI$g26eqP(elH+L*HOC;M*cAr<;k+k*kjw&kqBr|M8uC zBpnl#=<*ko>3=iTKerbxIq`8m`sd0@>Uqhzw$XRKS_zDVxgpy^X$8tVgDvU zb77~TviNaXq2Y^xRSR995{%?Sl^Cqk(D$P_$Amd6=IEy46oNJob>7y>I2X|L{9%0F zok@vMvKc)O_s4=iOdo;rA`Z^W007i^^E*Iv3qA7?Y(7OlW4ZqVs|DqXU+{2zMOjpL zG?YRNY-5_DX=jUCWtz-Q_2>X#W!-f8MyDv`vK6>NhpWO$ZeaM|hv@ilG-M|>YWJpB z!ymP#Ut;P=c)91R701!-9Hq7nw`xeX=zA+wNfp_@%6~5k?ECAi{uH90h5mCM@EpoPuA)=A|W&c)A&F&MiRzCpt-2 zvJY#lPo7rR7l7uH&2iKr{${@6=xmYsl{N5&xMCe&(upf*JJDoCa_^<%!j{^Qe7oa) zn4-wC&+9+i1#hv1r0F43w&@Qu=LWt=NEz~LwU^2=e6)ZztNHq4=u9E0ju;^!3|i!C z>;T>^4A2gTZkhdQ%Kv<}5n?z=H|$P|?vK8+n|^)4j;W1!Kd zAPR}^(*7OzMi|qyFD?J<8~X2&NIYYlP<q?w?fV6!z3{x zw38v6R4@2_E6B^stCQGJbV7efDeA(fD;jYB%(=@kmM;>I>fFJQj`(fFK&}ILs2DmG z8h{T9#m1{=h@Q61S@Ty&hYv?hH z>~}dXAb%%L2_~8X=k*6u`i`J+HT4;LNDhB5Pk_x?wJLQ1jB!K|2XZ1i2-C8^bO5II z>de>5eL)oE@w1JY2l#jN?AL$QfJsj|I2X-;JcB%mS(8`i2%w3Fes7;t#~VCJcs$>G zy-WPaO_&v2mK)yZf8P>Yt@yLAM$V2b zpG?D<<6pI|w;8e8Ju|-fhoip_?fAaZ_>xGJJnp}xZL(_ka2vT@kFYP_d~;V{+V(&M zM3y0xg1smj1tMw|LRnDt>4V0a9k8BQ7z57oWz>)hB9e)5C+hRs_Buzo_A^pTJQC|)a4N^8;+{-m3{{?QfEBhIbX#RtPk zF8F3*AOmw!`|x0vNo7NH0A1XN>wI@=+}gCnfn&id+9yezBwV>Y$3byzC88m=QhqSe zRpEYma8!Sr_-V((%V!2W=vK!2WG}~XF>=-Z%E2D??|v)8e0+s?xG_)hQi?eBBrUE_ zx6y-fPJ3N-f8L*y&A#qc@7eOjo%VEmH63$l9;#+2lXNXJsD+kKuD+%IZ+)4Gw7yn zyx4)Lc4~>Lp%xiPLPccJ+i?V!?U2`v59Kj@$Xf+4je zDZ{1=%f>!D9r%DYzi+~rAZfK+bq9B2un$^*babnpjxz%z1oox8h)Ii1l=)tB8b zQPN~x42`%rP@-gav2&p;*f~g_u8Q-`cG`aR27ZTAL(L6!7Lr-DarlHgLs%sILf=5Lc~Xy5s^7QcaN}G;z(78K1!sZ&Y)XF&<7* zLzwU;i0~Sp@t+{D;dBRDA>&1?5w+cCi|qN3g3p)f=*tk%B#Ss}5HhR@tyHal^nEB( zRrR&@EC1IOw-0ra;T= z@(dJ}sAhE8zN`P`A6dlLcWFgYkVzdAvrj*Er3=Dsii(@rk%$PKss)uhhT`wLJT z#4qlZ2R4TcIDQ#J#&3S#r>xF0c`-=<#;Om#*nd{$R~RlWoDu_7p)&pShuoNwpC}Gn zF6EB8ggG#>;V||M3Nh(Fep7qeEf|>5&^KU!VH;GLn}w~hNX`jql*z0 zM)kJe7<}H5}&A;xkBMvu97&{Ii(!BZLO_X4>v%Y`|_=Y2h~ ze)NmERYGW8c4OsCozJJDsaO}giN$Y{*V6}o#zwelpN-8JC09ss5xqtFV(`iNrTo9c zmG@(LiKprFHZRSi|0kQ?CV@d`?LP29H6XT>SO?`DPY(!VB%+y=Ghs2uE6PcwrpSQZ z1|0ns`SQbFB`!n){V@Zj0%+L-?4+6|FYkqMfJTt?k$GtxZTpfHQFJ@Q4h6rGZJ3tf zmpFZ0m)BISwHg`)QyQ)1ip9Kw#lS7BF{v?7Vs*gO^kwx>#6n9Jif9Eesk4>9D@lG& zDaAx>J;h_;%eNkm=cfPGQHMp)p1dHM-X&a#{c`;FzJbfuGBfDG++`f*q>iJJ4s!u) zhrd^Vp^^$p5Sy%WpokROrawsY{~OQ9Jd2rkr#!sLOL#+~`e<0NP zKrdYB&!4~ami`aof1b9k(~WW?$KrMfpHkv+r?9G&2G_3_boacMZ1;c&)AUMnyD}pD zLIA&lbC^>xc%;3;-ke|p`dwX`btXu3Hv<%4zH1rh7^FfZTR|m|MORRQbyI`;c6!e6 zqTNfeN3>kSm-T7$DVA2XPjhAnbjNbt88ao)k4SOf(%qR1=JM+{sN9a>QN9zS?;O0x zerdVM56dL$M)d2fj?wL>m2cvXi_<0%Z(trY3AE#SEcCP%|(ISornZf*DA)ew~TSCa^PL|0$hj7cWRkDzCJ6_g}G zRcOw+OB7-nSsp zI$UTZr|GHaSM}*3jn!??fR8T>jv*!Zy`%10!I_aDj{Ue$<7Veu%Q3ma1Z^NMIM+5= z5pw+aGvQ1$be8YJWLDj39JX7|JfpBC?27ywts^wRLao`Nr~uo&z;`b6{hDh~y$RxO zAiH_n^c0Pa~l;z%5GJllZ%jnAsem)8IrX}>z4ZzPid0fJa#YKR3| z$;V4Ww~&fXxNXxh=@aOfnUK~#yAq~sOy^v_&Dv{+|>xBC`3Fds?p!<&p z;gbRwm3)44vf?(p!Cp3RSb3oYX1vqDYNmAr*^Q*j)(`WrO2nyMP43N=M`I$8J3_0# zRHI=>|8I0?gt_jnK++b3fOW6f=+IYC^EW)og!GSFtBoG}?)VYjgp?3}M5wo^^?*oyLYqVc+?2=d7LCpnzcE!Rv|St~kv}uJY?h$M@r;;%TmY#(&-72z&%R zp|WJKI?l;|@V@{?tOc@*N_x`68BpFcVB2IgG2+qALY}?x!T~!b6BW*&lLsBY-O~F3 zT&x~M3I^k>5c@fJo6&-)v=5OzD*Cn`&QW9DV_3v1#Ur>!q<;9bgX@(U@Q@)HUAo~o z84njb(Q4*d1poPBn_1zqbWK7<(S1*_VRv?$Be8StZCo{z`Gng!Q@j?AyPT;Naxrw% zPjeQ~7mj1Z6@c!53{ad?c1_;af_m?UBE}j)%btx)dfNTFEeG32+HT!~qLlYoI*=X0 z&+snXKc&7}`**YjDg3yBw@kXNt!*!ecc++MaNQA0Wt(+8SKAK+EBb4TKHWYFByAI3 z^n7`{eYuf>u&hjxz;k+Fd!`3q>xbjbX@o`7AL()8$7pe`E=O4gKK|)$OSU_?qLb;#uA=jKHO$51fsOpe)arO1Tj4l-I;a%4e+zF6sn*F*lQ24$EL%vVPgH z3Qcq)dWcu!o5R~{hT5;-7Q7{qzzbp_{iZ5_%&yD9Fs(ti$#f7I^#X2jOj#EcA0l!5 z@s$>)1ksSU+JSFGxzuldaGU^d(gV`X^*jgnP^%RqBV24(9#El~{D6e6tH9l%?_7BU z^PmJ*4R5kK!42=z)DhsVdFnFRrZXPdH1)+=A|u)<$v$Dq6Kn$RKhh`-Bl)=3{RgHu zzKu%i#avAHjbdj4`l83TD1ni!=M< z^;}=_fzX)Xhasih+f6O*p-*TR^_|ML)hJx_LDPlE`#MF&fq;VTuzQ~&IBBcFU~-UK zHg*}Bx1h)8Fyp1~t^*Q*P(_r>l{m{~sNFZzX+@1(!k|D;EcvO`8XQ1=w~Jver23U!0U*l$5$sK1;0&z6&ps*oe5mUriZ-xsqxi z!!Er`pjCZIz1S6RxE-h_By7@7s;-qD@$=3zOc^lm zvg#MrE(2&r!Vr`V@8Y_ib1&X6+dMSvg*kC9ct|8KkgIw_L-PpS{ilILGhpx0XBM0! zRKlx(w_8E?9+{2L#x-vNtMvsa*xfp>f)BKmmlWt#ccm!E z^=-UIJoc7kGj}@q$DjB4i(ni;5fn0|45{BzU3(0=1P;WFmZ(C5mNN=?UhRbDq}5NW zz}eynJj*yv)L-cDOBv6wB{LFCDFl`SfxeAw+mzuQ%00nyP1dHs)zL;SsfW#>mLZ97 z^XH_iw-Hx{$yvsT1RR=Qh&&{S5Lu&JERuH!%(?CTOLL9DL197YF+}9HUDB4(Wc6vh zGKcA>d@su%gnbRLN9(OYpLpSu3P@{5-tuI+5K43=3lGG6cuzX3HtQfGAM13^E`^|X zO6*%dRqfGbwpuf(6hvFnefVU#eD+yY5*c1{9aOvD?tOHi^$uqEfirt$(?SsK9lLJH2k|2;JO zE4I*_L)pAcxmg2!k14rk>qVS5UwiT;}Kr43X8+~aOi4dD}; zBnGgYqeu7z_*YTdNEHfe(C(u#64k7O9Ae+f>G@rS!^W${i3(WTvb&l&n)Xqy-QJh zoh-PMPxGBcJwxVAu*`ePy)6K}-1B_-+A<$DTfGNnu~^5P4BQPA4V|iaW+p!6E3i+# z{HS^}uIlJ;uUVHPYYE5ES-%fJL?BWKT;###hS}tY7PL1|rFoVQ%bdX}P3Ao5 zQ&$#mi4y2JWQ{Kd59*V#>(BsH!E3d-$;`>A0z=n$OETYQ0?ooFY}tJdU~<&~1a*<( zoV~XPOEU@IHZcv+U+gVamkPQ%_1D4PZz$G2n7a6|_FVWQJx2ey(CC*IVyZ8GjjwbZ z&88f%=Jn0U5?*watS&ZPApKo|O5i~2@Tt}!r5^Jbd;AwbEaAee2Kg7^gG@ZAKY{Y( zPb8|3!0l9aOxfsC8HUU)(M;pDPCx$zbR3ppPfI4jhQs$sgtIQ01i9Hee*4@ZhL^<2rommYQNuzl*EABnBQ`xOS?QqWe-?2k`)DSne*ts&Rl2NMGT-gBOd zYu4e3N9(RJ>vrJdj~A?CI`d%seO`#F*Z3(&L#qK&ZR~a1)avP>z}6YYyNtMff){9; z8^JGYe~M3s)bu3;qzL?-p{;i+-6Cxr^8(fR$EH-WJE4uvQR5o*KI3;j5k3iYQ7+dxOWx)7kFf(=0Bwt3Pi`{j0RQ z5Cfee@7%L~>pxKLap|Lmqwn|)g6!wxbg!SJvI{2->$MYo+kXuVO#yG+G5IBN-bPPpU5#Qsy ziLSv`ugk!3a!0+~ zh?Ee#%o|MmRu;2&3A(NywmauH9fXXBuSQZY&Kw zK)OeEymdO5r#biubq}nyy6XDneUVJHXO0}~-Wdy_+c`>g2G7SJejlzE8-+O7v5K9a`j2sm zUOx$-O(@icMe}%b_slo=62|a7L)+d~p9AW;X;Y^3GrTK4iE0!Q zAW8&e@aFp5(%Jqz$j})=Z^C2%uh|{NBspn=N4Mjrytkp^Wx}(jv8iax{gEfNBp$mVuWARkJtcJf`O)ZM zvFm{dkcm==vMLN5GdIt{dK|Pt{WqxWxv@&*7kg)7Ah>!7GcSJ*C?ksYgb^4q`;yhe zt#XiRKcMk8n1!U?O}yS?h%GD-*GsS~T|0tWw4<^%K)odl-n9?LD-$!_ksmf*M42XP zl707ch$-I8?003^!?tRaOswbA=lV7|OG;Wf_+%l=<4dF9_;C4fr^8b{?Ke3Mx$y@+ z<1=_SzTN)(ij*LWI!~9doz|z3s5e(4rVLiY(25FlRYX#^5cbhN2h!BbJ7v=nRY4I)UgAd~fQ7?hSKzHOzUg=%RHq!>efZ`2j+uKnQOT)cIUC`b7kf}G#zRBc@ngM&Rn3V& z1HTmC)ByeKHD7}uweBZztL7`>WOOk`T72C**4(WQk&m_?>p8}utD6=_skb1ur z#i3d_amGCGu_VUpPUz{|VHFx3($9g`sRzBfdY4)~TzM}TO)`)oPbtQMO8SZzbyM3- zZ8iF;Q}-5m^hS<53>f&(e7Z9s)E-=S(hT?Wkzl$XO{3@P!`ADoUrY3!)=wn7PcyN4uAeKH#lka%;c3U=07t8K zg8b{H1CywYB~R1LU^x>((}jgMITCEQu;#rm!WvOWwzo>c?v)NE8Rgits3>)80}C;+ zl?fwW6jW@Y6os9E=^_zyUOosP2N4Wobt)&V3~ z?9(^OPSl^zCuVH0KObzII7McC`jU>EVA&ptg1h$?&VqeVzksPqs@Q0ijpzqmGIH&% z50R&4ZzbvN;L~Dl;Lq+>&t`2M)$2U{oPs#1ARGSZYaVm@cT9+GkI*CPv2hC#>`pf> zP?IJ65IW^Q0hPgR`7DDp2~5-XwC>NuPlVZIIRBQyQBM;t)R{Z4#OoS}?>Qaqxs*fW|VO`xS?o~7s>>cqannb*YijGbkkSHd)aa@{T3#fl810BxC(x0~+Z{Ilc_+!wP z;CSd^b8HU1V35IO=F;37S_WU5?4w5{SE7EswPLX7@-trFxb&~WjRlj)0k6OM4|4T) z?Kag@CmkG;6EtnRj_rk+c-TfAo3 zDC*$k%`PC?cdAUu@~}9nm2J8fAY$bP)`(j#i8yG}UVyh^j|as@@ZmQZInQ}VhRJL- z4UFP0z;!6fTF-Ez>nQVyp33q{S!pYlm7l|>t+|dz#zth8nih&81xG;I%*e6<_8W3C zt#x=!0WtOGc#`TQBW83`T#_=>zI+C^E8bB1Cpj|QTInSu^^6DAz<}%`ep)0lz=jgu z!RNW#cHxIFyZ^8C%9WaR{g$shDAw|@>F1>E@5>CDYo=}o%|%(J~w$5eGBC5q*9=b(RjzOV)`wr%i90a)-}@6%PKMN%DSnH?B01DFBvV zavCa}CL2DA8T(o|>$C1~a{u~xho*G2*fcz$^JmxMP1t~eXHuQxZxa{%W&8PN0apbT zm`0FyVP2c7-4-*M-EooA32Ei+lW$uKa1U`03pmGbHoPLyk^>0W#rR3HTmo*{v$cC!#XRQnGv-}I#-Tf@BSep{t+V^M zz9@6@zquqL{~@$xsqSF*RibqiLOla4_T)A*^)LFz49Y?c$%sM&&9!DT{t7Lp<`dA5 zOFwF@?eeA@*V)$jdWcu>WoxaP5jI$rWF>>0DeZuJ!AT9`q}4h`{OK)}m-Jc6Y(laL zmPNcFuK=gM=*H>Dmdf_5C32-NmV(LG>2}=~nre%zRrsBE%GIyL%8F%l!QczFG*3L| z1uGT$7#Z|5o<0fD_QY1p8l%<}^Z`6!9wh`<@Un-X_j&Zf;-quHPn%^|xYC_hzTjF4 zh_6X~^tbW11II<2>~}eAF?FHQ+7GW6JSl(QY4!GA*OH2@&cjXK9v7@75_bQ@Z=f&> zy}O1`U3^Vi#UyFIUIY#G;A@*(a{6-aHC^vS_9R0>gy&$Q;-?n} zAP9OsJ|B&|K(Ht!F9&qfYRzi}NCtcz8mPj1usp)go42o{MhVx(XVX6EWoJ#ptJUwj zaYE<^M$RJwgNJ>-PJMe9gD{0-3O^Oxlctx-dW2F?U={}^P;oa6q5F@*mg(Ka{IUhW}y2?SNR=RCMHR&dYPCizkAtQ*(!2cPSiEi6$-uqC%g zGpI&j@td39yCPm+j6Fgr-IZ}%Yxi)`P=(#Pa@wy~`gFx&x=~X8co(8_%+OM%u(0T6 z^5j?Jb4&+QU)EZK4ztDMM$)W2Pf!(SICqsTs?NLS*=Z{+2PeY6dGY9?nr;qO1AoqA z@cOT)>m4FX^F38#@KQOM$jk41e@c$O0=7*!1_8hAkGet?m~(i?5Yglg)`YLb=iDJz zR=hGUN&L1nE~mU(K{u=7@mu1r-~fn`PzI0>S~>5%UaMy!Xj6a|%LAln=mR zlmW#dKNW1|m2>1dFyaDlmkkslXPvCcfFHDa#PZ(sn@r2lS7lFe-f=(918ps2JK!c{3+GruVfS=^3_2fx6&zau)yWS^GyXAf9v{Et9lBcu? zvwJMo=Z;m#)SzmJ+9bq}rc3PW1DrMvpz_u#8}{j;XXN<9`kJ)6Q!`6FK^9bWve^9r zm`0*fCNu9Y;a!%Lu{aUtR-5A$F@>5`6Ye?5+zgV>#F!xgmr1m_ueXw_$eJG!&5$|L zloLfaoUfQ_>A~a>9)B-_ z&AWTM5TfX#O4k5+9S;Al^YFCHU|@k{M37Eg-MzSLdfF;_T{ZT}^5RJ?jQUoBuWXl8 z3-Hv$hY{KQ`W;{}k^z|rL>@}ud4|HjKP->61&@h;r}A;P+X+K8YS|E(N? z`s`3`=1?VKe@?!PuJ$tb^O5#*+0k+)V z4(W&sV{0o$QkL_rtgY?YC^MD{=UB*>#U#ZEZGSd+ufbA|b6xdMxKCM+qOVMzZ`(XG z+X_oHik>suoRsQ+29N7fODPAcfVf(@O>IKy7F zkx%~<0MU>1X>-vPaLHufSjQKxK-t1S?DG?QZxmpTk3UO8@*Oo|hwoNS{G6vkO$loC zSik<-TS@5#74?VW-4B~rmtW~SlAzgd-(&IBA_^j=)GMdnIw!CM3|9@H3tIj^vd#i3 z>TYfOl$3NM;n314-HkLTA>AM_3?SW-A`ODbP)bRcFobkSDF-uImM zTZ`p#u~@{+{_lP7`@XKv!ciZ-**-VZXYO_p!StAI%rsM|q{94M}8=CwiS0!T1lh&482!It;WTUw&y?u!UJ`f(%WpW7s|zL7@bxYc?-d+a7O;q>sZ z&r)g2h^cxfeWu@QS520kFLWpb?N-;;;ys!Bw~X%gsOBp^YG~4YXbR?2OfGlrf<73t zjt9LEW)$z*OTFF%17f_USpX@GY<3SO@GImY)4<^@4sZZHLS``Vk~WD5zXC%lB; zAxc;KTrO1`P!#`sja6;$hvEy{!%%}*zkd=Wg0C6SsYTexlWiS2f)o~3Pt?6vPpljZ z`peVc$4s;4f0Y;ib5jYxur{X}B-9FaS+)LgpiE5Yj#$xFoUiGY`u#K&xj|*4h_egL$kwHt z)5WgUh4aHvSs<<>ONbPP-P@k~Smt*QEj~(^87ms-&BtLw(sHs-I>wvgOmh8V+5xdv zpN{ZhlT26m3XmiW0PBfH>?ojOHUsOQF=1t%s1?I6rPduhdfU~KNr3p7R-E0HDA2RB zu*^dGBx2-^dFAgr_#4hs(5D0W$+rTmKUJSY!wesV2^gv;mwx{NCpmFRwmkqW?ew55 z%E8emYwNiq$LpE8Ov4RY2CBD6eX1rl7NzDwj$Yh;Ly>_9_KUa8T?ZO`$Lco_tncU3v)kX#zYN?Yu+g5 zcq`RvSJR>ss1e?R%I;<3=LFC9n@)7t4r7G?u9Ji|UQVH8^ojCM*(!mNb? zjVoji=A2HmopsEGed(3`eQ5wCpz(fCo8S^S;fMZk!G(yUbp&Ez@oGqn)X&~e`+aKc z%fzk8kJ`Yk+CDf>26PC2OJoIgV0IZg!1kgGJ>s{>aJ9@g9LPe94}hxOTLbAE7QP(IERqXTDS348}b z#RsOTIiR_fsU6(ajFT%Q24P;a%6+rzb_PEQDsKT4&POv zW}$YmWtYKow_jFnt)e-|w6l38^MAB=2n<-3XHhf0j~_R3$Z?LLwKosB4dgc>;PO>o zEvrwDc(%t9(01HirJ4bx3vEG{5oy(un+;)WIzX&55)PwRzKjLdT%^qgNq+5PA!$_I zR}j7La`}{pWdf$dXjc5`ER5=P00jFfF&T0uIb7_D{Z#EwrZE~SQWrT5+6o!v^I#NA zf$=ovqwg2(W&=g`#ZiR;3f!an2tsOso*45PLsh3O?qNHcKd%A~KC!6@O&Rnh=0euk zPLgsPZ@42LO(ntq3_eQV#qs$0gF)v_V)2C)}B5}^zRbn9KSY@2ttMu>3$PiJ^l z;6SoUPB!L}zA{zV_h4MXry&nlz z%_<|&ap34?8P-LiGim-nmc|W!&4=I@a#;U{B7n=Erz+8;3A2*;t&^@p^y@;pfv>&PqO>TCm-z8%V7h zC1Bn3v=883{^?)x86H_nzHWoW{0zMJig=WNXv8y^tM-fVe@sRobwr1^Wo&gsUxNRS zGEw7EXtbInmEQEVMl-r&;{?1T(*|q((1+A+BSN{>XG+Qg^eo3)HK{+LB3ypu(R@uH zkNkD`E8PUj?}P&|frEJoDF~jGXT9OJ3yeU0^(>+AtK}JJ82IYFUXu)eKyJlUsaH@} ze1Ga1bE5z_=h$B2_uu{SP|)L0mXyH&08HWqGsz=sHC01mebXPOB4^4#B-?Qudhh6k z;K?)QIHHgh$0$z%x#opFwSD6iWe_)+iYb4V>Qxq!E;G%7Q=xp4BJE?40u>>D-L_Zy z`TQ&4=OTQyeWUh@H0dD!vIjz@9Z#iQ&~7WUIWJ`b6cgMu_va|Ql`FRUSVYZ82OsfWyLa)E^a{p_yfw+>(-VZ4@?Ut1A0T(~UtpAx)rlMP zMxHpbw$hR(I!$e_WBuFK@aCsrkp|H5S+P`owr>3L zF`xl>qd~U4%WJLsQ$OLC76Un>KC*4TMkXk>qq;MeUyWNBABGVdmfo+lxD?9T0@v4| z-1bMbT>*re9nhh$GNo%Wxb6I)b5N_b;}0FMfHWUd*1rnV7KU4Q0j&BPXY-yjU^txX z@^JtiVFo*C93i9r%K6Le1_sk5&|jLV3c2~y-_l%tyCI^CY&gG^r;eycI_>+nstpg@ z?<}0tOHAYM=+M5;9-0{wb@dGVO%dr~Hs(ejLd~-GD{OI=FdNOu!cN~`at<_i0)cq2 zXj|6W$zn%q#HlmE_^bFvvHg87v;P{f3;@|Tud2D$?f<7r3@3(|(P&{Jo;!jLOi~m^ z%DB>fv*S#^^#@PYNJ@QD7RcR_xMn?ytlkSOma6sM%sE#L0Mv+Nc6WR!5Wjc;>4Se! zhNcda6$ zNL1C)qBFG9)ccoynJ|&V!B?XDNgx^@}$5nz{cr2wiTG~+LG)f0P|BSoTe1YOWv*#=I_~m4qB(dK!Gr zReLf5i8hJ_%Ed>j+u7 zSH9;SZi92lj-Es0&R~wm{CTn7DYclr;0fWwnK5FvUl-tMzEi_`$vgd4m_=$&9y0bY zxk}h&zCrU!?BO`H^1x+gN2LMGokyhlbucG%LV%<^!sao65cHZaF*Y|Qj4WQhuMkP` z>1jY@i}#l1Ppt)U-`n-6C2L3Mc zBvc%r??i__-b(?8|9>oe>_`-+AMWN~z$YQzV1{$_YWMaxsuq_;#4!st(bh0d9LmH?in;|`gbi@iYl{S~7giLlK`q49gbYCI9PKpIw3b1&J7^&$fVR>r2-V?S<_El|6 z1%{*_Z+cN^&10TBfZS~4WnXPCzJ>LjC?<;^*2x!d3#;Dt;cn`w<`fX6IE@4o)?xQ! zn+mvdo)SzsE9DP+HYfUL#Qz9stNK7!@OWVQsXkO0QwwgGK~Mf}#`fKw>g&(tL7}?ZTkZGpM@qpWLwUD`hyp zjq;arI=q|?)D|#pV+hI>>sy&K1u~-;%!frHeVG;Qoeg71s2`wh5gKrn|FPAv;`_HJ z!d4n-S`M5y4JiL#B{|Z77`H=6NC&T!jqQ~}Q<)B8k2Y*wF^_zzKTIszn%LI6pF!A^4hm<2oTJ!&M2_ zKcddtWM!FzYq#Mev`(_5k4{Gc$M!i|G2vcP_>wd?7G*o+h_Vqx!74=#I{b#VjLXoj z5j8_LGXa;B7%>90WUrgQm)ZiPb>E-4DKKjUoBHXJ?E%7s@yhw@yGYIrZH|8KI)DYW zhbYv(F8nHky`<;iLTHy|vO;7Qr)1?QdWn&sk5}6SI*9LAUqpRLrbG`k_upb+5}F5E z&wG1x4pqXm1`fQ}OYBHW4{~IDh0G83toT{B%a$8xy&&gK{!yzOo27y;t&`^_B0okx zTi(2FqZ7?XYhm*x(oeVum{k;7D%K&N*4zXXp$i_=+8E ziuuDTLM~Xlhat@SIb4+LVV*_g3If>AfU(LRre8lt6@S1#Poi7sDVx!LI$`0a`(SHt zw!O=X?xc~R$g@&S4MT#S!LbhdA#UhcR834L<6oIvi+Nd=(as-Mn0#}R%FOKeK>F)|_u#GJ zD9J|_?eCY&m1%Aw`NMGovpx$i07lwIG2g&+pj&Lba?LiPyC_SpR6QaNEEGY);)-Ry z6rmIZ{feYNu<}nRnr3%9JF8#KydMcpTa_NS8CqLZ@Omqr;zeyAttxwfLZy+B$oHUKk_cHo$2Gftu5|Um= zmx?OQx~dqDJ}KZ(R@4V_oERlFF74ckB+986cK8e9g9c*}qaG>@!qV^F`-kSmH&qzc z2^|AAti6&>Ki7C1EivA?+f{zq`Aj5C7EVNzdc2x10>UN*i=RMF`^|{h`amieRin(D ze3mGyc(@aS+XuM2l?diX#Xrdakj=Dc8Dpv1PR9oUV8~^MD(AUEBlAW17;)nwu^n>r zKEb1#qB_JR9>U$MBGGyGKZ+Kw11051b>t9-kplHqw+}HYU1i>w)EOK^4@%5hI|C5I zbt5UU1F2}Rdquy`2DmAtfk#;mIVv|9Zan~(Q$*F=0cE%qQQ)1sl^NxHY0hdr0gLF5 zh_~jR|C-#;-bBLCE_NyV?_UNji;wxau9K-V*ehIZ1)0Sg#deyHc5DerVG)#KJGt`d z#M!`v7~d}01RElyz`wwV2g}7D44%e33V&Wj_-3L)p-MpXy#DSLk4K?+NI%o)LBmK* znzA(9#^4$J*lZS?Uk|6BHR8A}K?3{zDc);XgyGjmWxDBTIH3YwAbiLL04Bkm#FvGjEhXjLw=GrVQB@3#U2Ox>?UYg@k9 znV8+&UAjwG@Tt{(+)qG8+SPrZQxs3dQl7&?u@Iq8A{xkOAJ2?5F=FH)<`0*%pQlMu z{aBG+4MVE`sH84;>+C-*qTfNZ>m8+(GHy&JtH0GIXrTsDr3?W>N%pLC3UWQdRFcVz zH{tb>lC%o6%X@ecuZX*h=!sILzs1Xbeq}@&}uaAMj8U)x0>~dR!YlwMan}5d3$9Nk0p?unlhX(_~Q=KgU>bFK&*7g^)er= z-^;Y3b%L7-Qw}4_w~tywrG#QcwmiJ!5QwO>r)qrXGDOHpPCSIyOWYE}6#1^~w1IKMN2Hud5??YwjIp*TlCYh&1LvLu<9 z^oUxQZaP-jP6SOJa|$BQW_AU7C?m_cKzB2qF>TqgCERc#)QSfhP-3tsU1JN zzquqBU8)c!?E~W7VK`H4X*2d z>I7h{j-#Lacg34DhXEclk;GTrVMlT|&k3xGf z348tc6mSP8v3pLj3Dl-v9<%Yt0QUOXPT!Wx1W*LU$$pi_R$}f}_>+d|H0?(cX+k7MDS>%3NGeLy9FkTyP%R8>a(+qu)P5broj+g&XScQ!0r=hIRXG0Wk zCsQ6{FfGUt4=fLE;q|nNYS--fcC2_GqC~oqt9~9*kZia=9D@`%6dVt268>DUuQ;(Y zMJqmaO$%wG;=)SN8|gQ65T0ASRR&nw#yTAp&*Rd^1GF-4RGtRFLndrG z&gb1y9cWjcilrU4B@ozUI%dfIJ|N=>s7fryMx=|Q=kty>=3{p0C6tAsMVl_%yr(mu zimijzkFm5}q`d9tve+4OnV@nUuneGCFj2bNcZNJOHHGsTrBb2=R5rPQP7vn{m>9gX zz}q-z>>Ps%0U}H%Lh0<5YPxhVb~*>K$~7GR_MQOB^zhaqd8;)mj_=s(s7Hyiv!#8~ zajSJ_E)dk4|1rxZqCi!Yz0vy=`6QXb0NkIRVB2!)D3g?VUFC9S5pa3PZ=f>1Q-(*E zmtl(ZxE~^&JMm@7b%FIVK08w*1soezNE4!le-CJ2V`_YSmxxsVT@_s123c(JCd2NAzezBTKOjrcEmtWOF+aI^BNjcQS$QZV*YZ@Or8Txq- z8#T4cxiVq*x(-q=Ovr_X%0eDu@?ensTHQWHjv`gK=3->Y!?@3KkTZEzt>xh(1&?#! zj6c7eW;UEHQgiw#p>FzelK2Okn_Az+82gP!Fu~-IH86e=xuZDzMg+}o?}VrU>Gh+B#BycCzgDrGZjGWyPjcEXkuYV1hwJoGoXV`~a0qRJwZ1l*T;yq<$Q_rT8ywgut)LBGG& zDf*HfS6`X(OKxjVM}{NBpy#Eaat~Pz~zSi^}+O(X_erEe$1tSHXrQ5 z)@e=Z1%W2v^^0#3>JV${h)7eJ?z>iEoy%OoggUu(qq5;~NUEY{eEy*)04r=h!o^0gIEe z!p0y^*e=~~LEozn_)-HwsFvONun!t4k^<#s&ku>ZZF0;1N96r4afBnuXFdRpksojV zKdp9UhK~4t;3bL`lrmA?GT}O5GMwdPF}c|+tVk$qv!809{d0mYc5xYUUtal@+`=9F z8_sI>2_u0lbq2y*_lAO{0@Aa68FqJKixmH5eKC1wN0_}qZPdm zCzKBEXXZTcTXhk?r%?pFOz|lZ`J=-)1+(i6&wxEPRjP-ucwcqsg5+0i1&s4)jdkP) zK-Df~9dRy~ex6u=&pX&doho}d@e9I~9vY*uDUSXc)tFcgSx(GlAhjvRjxV@1Mi`1F=bXKSU2K^N zOVzGQbllzGtzBa%0zObUvC2hr6j(B+8FnE+k>hEm_SQe*bZ6 zra&86!mf#k2#n6z>;tU_a(|G;=7xWdj_I+7)SwUQ*Rpn5zM+S+AU6B~FgK(ko%p6Q zjI>-Jsn~%ZQ|8Y$`gBHHQ2@o&64v(JLim{n^fs~1j;p?VB)H~4Gh6(Gt9T9!CUGtu z>cf|WGfX|y>J4o$8QXv<&0Z?7nDOPX_h@2-E*EzSri?r) zMvaq^S)MQH8;ZRaPf0N&80 zHQHSC$T~^8?Dmx)?tXr}jmH8|Slcp{MT3j+@oLLvkT%=GjrjbU!DYAIX4#U#AyTG&cgTWtTN5c~sD`~@GHJwQmW&zJ!W#RuRZG;(EmMflEXbQ*6Ngb_D4 z_1jeW4Scq)L$4+bAoO;xbOE5NpZ-zTzMyBT_f8SV^Lxif1>kdsE1CV-J-t|1VB5R} z)@3}yQ{J47>Y!csj^IR;m7Rcl@dxoDzteta1ic6fukPoU_8iM_ej0q=BWUQX6x>X$ z2pI{_5IxP;N{=qKs zS!A~S&lLd?xa;F`BVA;8T0xq|PKRFw5K8=Hz$aApoe95WhH8pV&n#m;xV`{Wpb_Tr zPtly`)n1Vo370AD(W8>T`+G5>{-{r8^mLIcR0tP%hZ_SWQ7B|a%KP9mHVyrvc0~-R{i`yVGD2G zY0oGYCu!RsiCQ=2OB+PkFU!3P;=2bGw_Bh9Z%EcNrx0qCPIUzw491So2c|AeIO*|^ z-%vOP#qfb@!AeJMe%|^d-c8985 zeF69u>~$)ue#K}~TZ#jyv35Y~5Ccg8otEKu*dveH=aS-ZObfXGey=6tR1dcppvX1!^t>mh!4 z^=ATEVLG(rB~V?v@{dWNzn#$rjR#k4Wysj@ZII;`yl`bC3WUr-3KkFq-6wtH&lf{W zVerM(_;5ZN)nP$o-P8e#?ffD~c`d+ZenmN?Nw|JCf(r84dwr1?dbsfZH$g(?u68G8 zu%f@|FZ27iEnl@QPPTCd3@d2a1y-rx`Rer2VuF+g6i{ z!|$H-gN?6`tE=rzl_EPXdTuO#sSzQ}j+}UXJs}N5bQBbZ){f1hLy4m4;TN&45Te zY$Docs8dPJy50T6cB%OKN6+YzyoHgvy*L_eqTd(FZ3s@l_YMUI^TzMqCZC645~kIb zVZ>??tw|JrVWR-9c{pDIq~SS8vW0}_a6|vT>JpoF&hCeaKPzCGmyAQoD$2Iyz_QGN zy00#}2I77x6ut8?h8P8a<@{~aLFcj#jp&a%cO9rVLbdhA1$Cx?jF_kLHLx2!EA>kE z2|jJq+GvL7X0KC!QJA8jnh6jZ{c|dK_AU!Vj_&WwINfa5AN%>FyEn}KnKfSgGuu>t zTvr!Ym!m^f%cU_u(%o=((%~mV#2x^4IM9erXH(=7AFK+CfvAH}Fw2TEu|eL`kt3G* z$BJLERR(^napT%CoCkwGi+wiU+lCeA02ps&=yfV1{9W)A4u9S zG>LI)E&qO%5&8ZKLF_y;+85wVHv@8FAO#!(+yZXkHae12?2tosAf%5~7F1p76{m_H zi+@Z{+j+0D;JQmH;<0s|%(VuOi=Wctw<$W+t*TRSWg_*bO-4AQ@j&CNHbo1!wDwwh zG^KOR1_@J;(Mq1cYQ*AtFL4rMVGvQQB*dr+y$v(kM8Xu# zKD}$AuaNL0MVw5T#LtX1JEh=6gyjGlRT^--(nPCbBBE%nq?PMc9=SO*Um#`l$0i>E z1V_3oXf0kOP|M+qW<9NIld{73=H8X63~cqsB0)F|zN)q#o(33&;I?6-H>@&ek(;f# z(xXF->}~!6NL@A)nxJ=M7>q`W(HLh<2rNZ$w-9S@eLnJ=EAV=b0}Z>a^JdPNDg+TelOTxG7EO9T%*=nQ@MjbHSqD(g*;TF&q}T|qi|$nC z5)0Mw)*Q?)-{74b6UdyhY@AsGsD(YBF>^vWv}$Z5=*6Yy?*Rg%D6F$zqJ7KhgJ*j{ zN+N7+^QJ%vF>B#)IZ$F7ZbMnwVoUXIOe=pgnMoy1{~0LHBQJYLRkz#+j1B8AwoIeJ zy8EC8>6Y>8!Vh0o90unNa#(7P?Q8L+Aj8{P;%}u3@y3Bkl|%DuT7v5BGGk=ZT~c=5 z*{2x2ulpf+P^&TNerv`ebp`U6(Zp3LxSu{ILKv3lbQUCVfDnaSTpL@0E_o<)Rk8{C zT|5)Wf~Z%ZDkp0lUw|c^thfWWxMg8MrC{)`E*{e__dm<_#{d(*UWhZnVv=wUE5$2w zX|sMEuOplukuPc*c(GMnbpMKAO%8RRQnIIWB|K~V-d1WyyG%PLoA>7OkkOofe}o>pv?m}G>6$_-+{?B34r5=kij0o{mP7b z_=uF-5!)}7`eeA25wqn>n9%4LIh8mnE4Iu4G3?5P&8lKON*N4mY<*z52zY?hd332c zkOJnv8Piiq5Z#p-xA_}99{l0(>~+0k!82jFT)^jN-QJ#kNK>Qmj~jBi1{%HBscqk> zZTH<{Pd+1l0YlK;4{fg1A&>&^*zi5c4GDtGQ2{(_)(V7Y9?uJz;QO%hMmdfXRUpr; z9NP;*tJKnU1hlhZ=?${TTc8v8`G!c<#hJS4dfz)F=wlU9wE&P^ey1!A*GS!pskL^t zxE)0&dD_7&ozFsYd2AYe#;#k>WHe4TbZ3QCEufXQhFx+ zze@8O#n8KpsyvQ19|-3t{$AN*xY0}rQ=#1f&tWbf^-SJl2ndI9HT_bP|0bNGQ}M}m zNT18bM|gNK*_;EQdGefDp&2pau$c{3cYoZ<1Ha^71F`a8(K|y6);f}&t~@ug%m!E# z0GKb>DK%-Vgfxu2ezPDpvDaW1&&eg>v;VwhE@meSbb*@kHSQpEAwPnE3P4icyuk#h zxfm-gD8aecArhv4>ynIafuCvPTBa9XT0L^VUb5xzX{DKt5y#9@@x5{so?;|Y*e_$!sPFVvD({1s95~L_7WNa9 z8;C|TMyxlduj@&G;3}K_KQkvOMYLgss^Jj?&br68-!8u}oOcxO?> zNx&obquV2h0k$nKET4IDler0Slxly10({)a$)vnKyfe%DhflRI1M~-~fr#Ly z5beD+&cdBlx?_MwohsV^Co#PE6*nug_nH&K*Ee|HwK0>D5RQcYg2hNmuZo46b*~O6 zsFh@Q1cbs?iKTd5*ufWC80zz^gG{o$ZL62cfa zAiL+z!oUNPc;#nXe5#6toI2c%>f2>y!sav0^AL()hgAWe;`{S>@B1Fdj;71~FBv%{SZ!f zv|+UFn8U3~`QE_*h`5fNvxmRk1OA4V?-mw&y+;#Ed5mqI;O8FGI)B1~w|JR8iVwcn zZULafudGQck@;USOHTehAo*9<=C^F9(61QSKaDdfH1|RpRvdZIEc+1Uw2GVLFQxhC zE#kw#gG0+s1#;+(fPnNT4A(yL?nMoiA6-Id4v`?Mv*@Ye4ail{mS{B`#CM=CzxgwV zwOD6*eS5xQrdCNjKdb<9D!1P}K79>1peF~|FUCNCOJ*B`4$G%%uaxdgZ$M7&LQen_ zfVY!olCVQ9%1sWc3Jn}vMl@qmT=g!yJ?0yk-RwJv$4@SMEt*^IFc-Ec%0AK?Oi$O7 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ÐazchI#tF+ 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

6j2yRO`GM|IMd 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.14,<2", markers = "python_version >= \"3.11\""} + +[[package]] +name = "asttokens" +version = "2.4.1" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] +test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] + +[[package]] +name = "attrs" +version = "23.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, + {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] +tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +description = "Backport of CPython tarfile module" +optional = false +python-versions = ">=3.8" +files = [ + {file = "backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34"}, + {file = "backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["jaraco.test", "pytest (!=8.0.*)", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)"] + +[[package]] +name = "black" +version = "24.4.2" +description = "The uncompromising code formatter." +optional = false +python-versions = ">=3.8" +files = [ + {file = "black-24.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dd1b5a14e417189db4c7b64a6540f31730713d173f0b63e55fabd52d61d8fdce"}, + {file = "black-24.4.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e537d281831ad0e71007dcdcbe50a71470b978c453fa41ce77186bbe0ed6021"}, + {file = "black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaea3008c281f1038edb473c1aa8ed8143a5535ff18f978a318f10302b254063"}, + {file = "black-24.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:7768a0dbf16a39aa5e9a3ded568bb545c8c2727396d063bbaf847df05b08cd96"}, + {file = "black-24.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:257d724c2c9b1660f353b36c802ccece186a30accc7742c176d29c146df6e474"}, + {file = "black-24.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bdde6f877a18f24844e381d45e9947a49e97933573ac9d4345399be37621e26c"}, + {file = "black-24.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e151054aa00bad1f4e1f04919542885f89f5f7d086b8a59e5000e6c616896ffb"}, + {file = "black-24.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:7e122b1c4fb252fd85df3ca93578732b4749d9be076593076ef4d07a0233c3e1"}, + {file = "black-24.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:accf49e151c8ed2c0cdc528691838afd217c50412534e876a19270fea1e28e2d"}, + {file = "black-24.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:88c57dc656038f1ab9f92b3eb5335ee9b021412feaa46330d5eba4e51fe49b04"}, + {file = "black-24.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be8bef99eb46d5021bf053114442914baeb3649a89dc5f3a555c88737e5e98fc"}, + {file = "black-24.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:415e686e87dbbe6f4cd5ef0fbf764af7b89f9057b97c908742b6008cc554b9c0"}, + {file = "black-24.4.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bf10f7310db693bb62692609b397e8d67257c55f949abde4c67f9cc574492cc7"}, + {file = "black-24.4.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:98e123f1d5cfd42f886624d84464f7756f60ff6eab89ae845210631714f6db94"}, + {file = "black-24.4.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48a85f2cb5e6799a9ef05347b476cce6c182d6c71ee36925a6c194d074336ef8"}, + {file = "black-24.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:b1530ae42e9d6d5b670a34db49a94115a64596bc77710b1d05e9801e62ca0a7c"}, + {file = "black-24.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:37aae07b029fa0174d39daf02748b379399b909652a806e5708199bd93899da1"}, + {file = "black-24.4.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da33a1a5e49c4122ccdfd56cd021ff1ebc4a1ec4e2d01594fef9b6f267a9e741"}, + {file = "black-24.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef703f83fc32e131e9bcc0a5094cfe85599e7109f896fe8bc96cc402f3eb4b6e"}, + {file = "black-24.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:b9176b9832e84308818a99a561e90aa479e73c523b3f77afd07913380ae2eab7"}, + {file = "black-24.4.2-py3-none-any.whl", hash = "sha256:d36ed1124bb81b32f8614555b34cc4259c3fbc7eec17870e8ff8ded335b58d8c"}, + {file = "black-24.4.2.tar.gz", hash = "sha256:c872b53057f000085da66a19c55d68f6f8ddcac2642392ad3a355878406fbd4d"}, +] + +[package.dependencies] +click = ">=8.0.0" +ipython = {version = ">=7.8.0", optional = true, markers = "extra == \"jupyter\""} +mypy-extensions = ">=0.4.3" +packaging = ">=22.0" +pathspec = ">=0.9.0" +platformdirs = ">=2" +tokenize-rt = {version = ">=3.2.0", optional = true, markers = "extra == \"jupyter\""} + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + +[[package]] +name = "certifi" +version = "2024.7.4" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.7.4-py3-none-any.whl", hash = "sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90"}, + {file = "certifi-2024.7.4.tar.gz", hash = "sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b"}, +] + +[[package]] +name = "cffi" +version = "1.16.0" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, +] + +[package.dependencies] +pycparser = "*" + +[[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 = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[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 = "click-log" +version = "0.4.0" +description = "Logging integration for Click" +optional = false +python-versions = "*" +files = [ + {file = "click-log-0.4.0.tar.gz", hash = "sha256:3970f8570ac54491237bcdb3d8ab5e3eef6c057df29f8c3d1151a51a9c23b975"}, + {file = "click_log-0.4.0-py2.py3-none-any.whl", hash = "sha256:a43e394b528d52112af599f2fc9e4b7cf3c15f94e53581f74fa6867e68c91756"}, +] + +[package.dependencies] +click = "*" + +[[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 = "coloredlogs" +version = "15.0.1" +description = "Colored terminal output for Python's logging module" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "coloredlogs-15.0.1-py2.py3-none-any.whl", hash = "sha256:612ee75c546f53e92e70049c9dbfcc18c935a2b9a53b66085ce9ef6a6e5c0934"}, + {file = "coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0"}, +] + +[package.dependencies] +humanfriendly = ">=9.1" + +[package.extras] +cron = ["capturer (>=2.4)"] + +[[package]] +name = "cryptography" +version = "42.0.8" +description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." +optional = false +python-versions = ">=3.7" +files = [ + {file = "cryptography-42.0.8-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:81d8a521705787afe7a18d5bfb47ea9d9cc068206270aad0b96a725022e18d2e"}, + {file = "cryptography-42.0.8-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:961e61cefdcb06e0c6d7e3a1b22ebe8b996eb2bf50614e89384be54c48c6b63d"}, + {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3ec3672626e1b9e55afd0df6d774ff0e953452886e06e0f1eb7eb0c832e8902"}, + {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e599b53fd95357d92304510fb7bda8523ed1f79ca98dce2f43c115950aa78801"}, + {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:5226d5d21ab681f432a9c1cf8b658c0cb02533eece706b155e5fbd8a0cdd3949"}, + {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6b7c4f03ce01afd3b76cf69a5455caa9cfa3de8c8f493e0d3ab7d20611c8dae9"}, + {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:2346b911eb349ab547076f47f2e035fc8ff2c02380a7cbbf8d87114fa0f1c583"}, + {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:ad803773e9df0b92e0a817d22fd8a3675493f690b96130a5e24f1b8fabbea9c7"}, + {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2f66d9cd9147ee495a8374a45ca445819f8929a3efcd2e3df6428e46c3cbb10b"}, + {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:d45b940883a03e19e944456a558b67a41160e367a719833c53de6911cabba2b7"}, + {file = "cryptography-42.0.8-cp37-abi3-win32.whl", hash = "sha256:a0c5b2b0585b6af82d7e385f55a8bc568abff8923af147ee3c07bd8b42cda8b2"}, + {file = "cryptography-42.0.8-cp37-abi3-win_amd64.whl", hash = "sha256:57080dee41209e556a9a4ce60d229244f7a66ef52750f813bfbe18959770cfba"}, + {file = "cryptography-42.0.8-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:dea567d1b0e8bc5764b9443858b673b734100c2871dc93163f58c46a97a83d28"}, + {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4783183f7cb757b73b2ae9aed6599b96338eb957233c58ca8f49a49cc32fd5e"}, + {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0608251135d0e03111152e41f0cc2392d1e74e35703960d4190b2e0f4ca9c70"}, + {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dc0fdf6787f37b1c6b08e6dfc892d9d068b5bdb671198c72072828b80bd5fe4c"}, + {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:9c0c1716c8447ee7dbf08d6db2e5c41c688544c61074b54fc4564196f55c25a7"}, + {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fff12c88a672ab9c9c1cf7b0c80e3ad9e2ebd9d828d955c126be4fd3e5578c9e"}, + {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:cafb92b2bc622cd1aa6a1dce4b93307792633f4c5fe1f46c6b97cf67073ec961"}, + {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:31f721658a29331f895a5a54e7e82075554ccfb8b163a18719d342f5ffe5ecb1"}, + {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b297f90c5723d04bcc8265fc2a0f86d4ea2e0f7ab4b6994459548d3a6b992a14"}, + {file = "cryptography-42.0.8-cp39-abi3-win32.whl", hash = "sha256:2f88d197e66c65be5e42cd72e5c18afbfae3f741742070e3019ac8f4ac57262c"}, + {file = "cryptography-42.0.8-cp39-abi3-win_amd64.whl", hash = "sha256:fa76fbb7596cc5839320000cdd5d0955313696d9511debab7ee7278fc8b5c84a"}, + {file = "cryptography-42.0.8-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ba4f0a211697362e89ad822e667d8d340b4d8d55fae72cdd619389fb5912eefe"}, + {file = "cryptography-42.0.8-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:81884c4d096c272f00aeb1f11cf62ccd39763581645b0812e99a91505fa48e0c"}, + {file = "cryptography-42.0.8-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c9bb2ae11bfbab395bdd072985abde58ea9860ed84e59dbc0463a5d0159f5b71"}, + {file = "cryptography-42.0.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7016f837e15b0a1c119d27ecd89b3515f01f90a8615ed5e9427e30d9cdbfed3d"}, + {file = "cryptography-42.0.8-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5a94eccb2a81a309806027e1670a358b99b8fe8bfe9f8d329f27d72c094dde8c"}, + {file = "cryptography-42.0.8-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dec9b018df185f08483f294cae6ccac29e7a6e0678996587363dc352dc65c842"}, + {file = "cryptography-42.0.8-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:343728aac38decfdeecf55ecab3264b015be68fc2816ca800db649607aeee648"}, + {file = "cryptography-42.0.8-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:013629ae70b40af70c9a7a5db40abe5d9054e6f4380e50ce769947b73bf3caad"}, + {file = "cryptography-42.0.8.tar.gz", hash = "sha256:8d09d05439ce7baa8e9e95b07ec5b6c886f548deb7e0f69ef25f64b3bce842f2"}, +] + +[package.dependencies] +cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""} + +[package.extras] +docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"] +docstest = ["pyenchant (>=1.6.11)", "readme-renderer", "sphinxcontrib-spelling (>=4.0.1)"] +nox = ["nox"] +pep8test = ["check-sdist", "click", "mypy", "ruff"] +sdist = ["build"] +ssh = ["bcrypt (>=3.1.5)"] +test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] +test-randomorder = ["pytest-randomly"] + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +optional = false +python-versions = ">=3.5" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "dill" +version = "0.3.8" +description = "serialize all of Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"}, + {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"}, +] + +[package.extras] +graph = ["objgraph (>=1.7.2)"] +profile = ["gprof2dot (>=2022.7.29)"] + +[[package]] +name = "distance" +version = "0.1.3" +description = "Utilities for comparing sequences" +optional = false +python-versions = "*" +files = [ + {file = "Distance-0.1.3.tar.gz", hash = "sha256:60807584f5b6003f5c521aa73f39f51f631de3be5cccc5a1d67166fcbf0d4551"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +description = "Distribution utilities" +optional = false +python-versions = "*" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "docutils" +version = "0.21.2" +description = "Docutils -- Python Documentation Utilities" +optional = false +python-versions = ">=3.9" +files = [ + {file = "docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2"}, + {file = "docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f"}, +] + +[[package]] +name = "dotty-dict" +version = "1.3.1" +description = "Dictionary wrapper for quick access to deeply nested keys." +optional = false +python-versions = ">=3.5,<4.0" +files = [ + {file = "dotty_dict-1.3.1-py3-none-any.whl", hash = "sha256:5022d234d9922f13aa711b4950372a06a6d64cb6d6db9ba43d0ba133ebfce31f"}, + {file = "dotty_dict-1.3.1.tar.gz", hash = "sha256:4b016e03b8ae265539757a53eba24b9bfda506fb94fbce0bee843c6f05541a15"}, +] + +[[package]] +name = "execnet" +version = "2.1.1" +description = "execnet: rapid multi-Python deployment" +optional = false +python-versions = ">=3.8" +files = [ + {file = "execnet-2.1.1-py3-none-any.whl", hash = "sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc"}, + {file = "execnet-2.1.1.tar.gz", hash = "sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3"}, +] + +[package.extras] +testing = ["hatch", "pre-commit", "pytest", "tox"] + +[[package]] +name = "executing" +version = "2.0.1" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = ">=3.5" +files = [ + {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, + {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, +] + +[package.extras] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] + +[[package]] +name = "filelock" +version = "3.15.4" +description = "A platform independent file lock." +optional = false +python-versions = ">=3.8" +files = [ + {file = "filelock-3.15.4-py3-none-any.whl", hash = "sha256:6ca1fffae96225dab4c6eaf1c4f4f28cd2568d3ec2a44e15a08520504de468e7"}, + {file = "filelock-3.15.4.tar.gz", hash = "sha256:2207938cbc1844345cb01a5a95524dae30f0ce089eba5b00378295a17e3e90cb"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-asyncio (>=0.21)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)", "virtualenv (>=20.26.2)"] +typing = ["typing-extensions (>=4.8)"] + +[[package]] +name = "flake8" +version = "6.1.0" +description = "the modular source code checker: pep8 pyflakes and co" +optional = false +python-versions = ">=3.8.1" +files = [ + {file = "flake8-6.1.0-py2.py3-none-any.whl", hash = "sha256:ffdfce58ea94c6580c77888a86506937f9a1a227dfcd15f245d694ae20a6b6e5"}, + {file = "flake8-6.1.0.tar.gz", hash = "sha256:d5b3857f07c030bdb5bf41c7f53799571d75c4491748a3adcd47de929e34cd23"}, +] + +[package.dependencies] +mccabe = ">=0.7.0,<0.8.0" +pycodestyle = ">=2.11.0,<2.12.0" +pyflakes = ">=3.1.0,<3.2.0" + +[[package]] +name = "flake8-pyproject" +version = "1.2.3" +description = "Flake8 plug-in loading the configuration from pyproject.toml" +optional = false +python-versions = ">= 3.6" +files = [ + {file = "flake8_pyproject-1.2.3-py3-none-any.whl", hash = "sha256:6249fe53545205af5e76837644dc80b4c10037e73a0e5db87ff562d75fb5bd4a"}, +] + +[package.dependencies] +Flake8 = ">=5" + +[package.extras] +dev = ["pyTest", "pyTest-cov"] + +[[package]] +name = "flatbuffers" +version = "24.3.25" +description = "The FlatBuffers serialization format for Python" +optional = false +python-versions = "*" +files = [ + {file = "flatbuffers-24.3.25-py2.py3-none-any.whl", hash = "sha256:8dbdec58f935f3765e4f7f3cf635ac3a77f83568138d6a2311f524ec96364812"}, + {file = "flatbuffers-24.3.25.tar.gz", hash = "sha256:de2ec5b203f21441716617f38443e0a8ebf3d25bf0d9c0bb0ce68fa00ad546a4"}, +] + +[[package]] +name = "fsspec" +version = "2024.6.1" +description = "File-system specification" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fsspec-2024.6.1-py3-none-any.whl", hash = "sha256:3cb443f8bcd2efb31295a5b9fdb02aee81d8452c80d28f97a6d0959e6cee101e"}, + {file = "fsspec-2024.6.1.tar.gz", hash = "sha256:fad7d7e209dd4c1208e3bbfda706620e0da5142bebbd9c384afb95b07e798e49"}, +] + +[package.extras] +abfs = ["adlfs"] +adl = ["adlfs"] +arrow = ["pyarrow (>=1)"] +dask = ["dask", "distributed"] +dev = ["pre-commit", "ruff"] +doc = ["numpydoc", "sphinx", "sphinx-design", "sphinx-rtd-theme", "yarl"] +dropbox = ["dropbox", "dropboxdrivefs", "requests"] +full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "dask", "distributed", "dropbox", "dropboxdrivefs", "fusepy", "gcsfs", "libarchive-c", "ocifs", "panel", "paramiko", "pyarrow (>=1)", "pygit2", "requests", "s3fs", "smbprotocol", "tqdm"] +fuse = ["fusepy"] +gcs = ["gcsfs"] +git = ["pygit2"] +github = ["requests"] +gs = ["gcsfs"] +gui = ["panel"] +hdfs = ["pyarrow (>=1)"] +http = ["aiohttp (!=4.0.0a0,!=4.0.0a1)"] +libarchive = ["libarchive-c"] +oci = ["ocifs"] +s3 = ["s3fs"] +sftp = ["paramiko"] +smb = ["smbprotocol"] +ssh = ["paramiko"] +test = ["aiohttp (!=4.0.0a0,!=4.0.0a1)", "numpy", "pytest", "pytest-asyncio (!=0.22.0)", "pytest-benchmark", "pytest-cov", "pytest-mock", "pytest-recording", "pytest-rerunfailures", "requests"] +test-downstream = ["aiobotocore (>=2.5.4,<3.0.0)", "dask-expr", "dask[dataframe,test]", "moto[server] (>4,<5)", "pytest-timeout", "xarray"] +test-full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "cloudpickle", "dask", "distributed", "dropbox", "dropboxdrivefs", "fastparquet", "fusepy", "gcsfs", "jinja2", "kerchunk", "libarchive-c", "lz4", "notebook", "numpy", "ocifs", "pandas", "panel", "paramiko", "pyarrow", "pyarrow (>=1)", "pyftpdlib", "pygit2", "pytest", "pytest-asyncio (!=0.22.0)", "pytest-benchmark", "pytest-cov", "pytest-mock", "pytest-recording", "pytest-rerunfailures", "python-snappy", "requests", "smbprotocol", "tqdm", "urllib3", "zarr", "zstandard"] +tqdm = ["tqdm"] + +[[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 = "humanfriendly" +version = "10.0" +description = "Human friendly output for text interfaces using Python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477"}, + {file = "humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc"}, +] + +[package.dependencies] +pyreadline3 = {version = "*", markers = "sys_platform == \"win32\" and python_version >= \"3.8\""} + +[[package]] +name = "identify" +version = "2.6.0" +description = "File identification library for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"}, + {file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"}, +] + +[package.extras] +license = ["ukkonen"] + +[[package]] +name = "idna" +version = "3.7" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"}, + {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"}, +] + +[[package]] +name = "importlib-metadata" +version = "8.0.0" +description = "Read metadata from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_metadata-8.0.0-py3-none-any.whl", hash = "sha256:15584cf2b1bf449d98ff8a6ff1abef57bf20f3ac6454f431736cd3e660921b2f"}, + {file = "importlib_metadata-8.0.0.tar.gz", hash = "sha256:188bd24e4c346d3f0a933f275c2fec67050326a856b9a359881d7c2a697e8812"}, +] + +[package.dependencies] +zipp = ">=0.5" + +[package.extras] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +perf = ["ipython"] +test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"] + +[[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 = "invoke" +version = "2.2.0" +description = "Pythonic task execution" +optional = false +python-versions = ">=3.6" +files = [ + {file = "invoke-2.2.0-py3-none-any.whl", hash = "sha256:6ea924cc53d4f78e3d98bc436b08069a03077e6f85ad1ddaa8a116d7dad15820"}, + {file = "invoke-2.2.0.tar.gz", hash = "sha256:ee6cbb101af1a859c7fe84f2a264c059020b0cb7fe3535f9424300ab568f6bd5"}, +] + +[[package]] +name = "ipython" +version = "8.26.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.10" +files = [ + {file = "ipython-8.26.0-py3-none-any.whl", hash = "sha256:e6b347c27bdf9c32ee9d31ae85defc525755a1869f14057e900675b9e8d6e6ff"}, + {file = "ipython-8.26.0.tar.gz", hash = "sha256:1cec0fbba8404af13facebe83d04436a7434c7400e59f47acf467c64abd0956c"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} +prompt-toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5.13.0" +typing-extensions = {version = ">=4.6", markers = "python_version < \"3.12\""} + +[package.extras] +all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "intersphinx-registry", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "tomli", "typing-extensions"] +kernel = ["ipykernel"] +matplotlib = ["matplotlib"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["packaging", "pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] +test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] + +[[package]] +name = "isort" +version = "5.13.2" +description = "A Python utility / library to sort Python imports." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"}, + {file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"}, +] + +[package.extras] +colors = ["colorama (>=0.4.6)"] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +description = "Utility functions for Python class constructs" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790"}, + {file = "jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd"}, +] + +[package.dependencies] +more-itertools = "*" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"] + +[[package]] +name = "jaraco-context" +version = "5.3.0" +description = "Useful decorators and context managers" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jaraco.context-5.3.0-py3-none-any.whl", hash = "sha256:3e16388f7da43d384a1a7cd3452e72e14732ac9fe459678773a3608a812bf266"}, + {file = "jaraco.context-5.3.0.tar.gz", hash = "sha256:c2f67165ce1f9be20f32f650f25d8edfc1646a8aeee48ae06fb35f90763576d2"}, +] + +[package.dependencies] +"backports.tarfile" = {version = "*", markers = "python_version < \"3.12\""} + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["portend", "pytest (>=6,!=8.1.1)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"] + +[[package]] +name = "jaraco-functools" +version = "4.0.1" +description = "Functools like those found in stdlib" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jaraco.functools-4.0.1-py3-none-any.whl", hash = "sha256:3b24ccb921d6b593bdceb56ce14799204f473976e2a9d4b15b04d0f2c2326664"}, + {file = "jaraco_functools-4.0.1.tar.gz", hash = "sha256:d33fa765374c0611b52f8b3a795f8900869aa88c84769d4d1746cd68fb28c3e8"}, +] + +[package.dependencies] +more-itertools = "*" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["jaraco.classes", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"] + +[[package]] +name = "jedi" +version = "0.19.1" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + +[[package]] +name = "jeepney" +version = "0.8.0" +description = "Low-level, pure Python DBus protocol wrapper." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jeepney-0.8.0-py3-none-any.whl", hash = "sha256:c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755"}, + {file = "jeepney-0.8.0.tar.gz", hash = "sha256:5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806"}, +] + +[package.extras] +test = ["async-timeout", "pytest", "pytest-asyncio (>=0.17)", "pytest-trio", "testpath", "trio"] +trio = ["async_generator", "trio"] + +[[package]] +name = "jinja2" +version = "3.1.4" +description = "A very fast and expressive template engine." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"}, + {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[package]] +name = "jsonlines" +version = "3.1.0" +description = "Library with helpers for the jsonlines file format" +optional = false +python-versions = ">=3.6" +files = [ + {file = "jsonlines-3.1.0-py3-none-any.whl", hash = "sha256:632f5e38f93dfcb1ac8c4e09780b92af3a55f38f26e7c47ae85109d420b6ad39"}, + {file = "jsonlines-3.1.0.tar.gz", hash = "sha256:2579cb488d96f815b0eb81629e3e6b0332da0962a18fa3532958f7ba14a5c37f"}, +] + +[package.dependencies] +attrs = ">=19.2.0" + +[[package]] +name = "keyring" +version = "25.2.1" +description = "Store and access your passwords safely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "keyring-25.2.1-py3-none-any.whl", hash = "sha256:2458681cdefc0dbc0b7eb6cf75d0b98e59f9ad9b2d4edd319d18f68bdca95e50"}, + {file = "keyring-25.2.1.tar.gz", hash = "sha256:daaffd42dbda25ddafb1ad5fec4024e5bbcfe424597ca1ca452b299861e49f1b"}, +] + +[package.dependencies] +importlib-metadata = {version = ">=4.11.4", markers = "python_version < \"3.12\""} +"jaraco.classes" = "*" +"jaraco.context" = "*" +"jaraco.functools" = "*" +jeepney = {version = ">=0.4.2", markers = "sys_platform == \"linux\""} +pywin32-ctypes = {version = ">=0.2.0", markers = "sys_platform == \"win32\""} +SecretStorage = {version = ">=3.2", markers = "sys_platform == \"linux\""} + +[package.extras] +completion = ["shtab (>=1.1.0)"] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"] + +[[package]] +name = "lazy-object-proxy" +version = "1.10.0" +description = "A fast and thorough lazy object proxy." +optional = false +python-versions = ">=3.8" +files = [ + {file = "lazy-object-proxy-1.10.0.tar.gz", hash = "sha256:78247b6d45f43a52ef35c25b5581459e85117225408a4128a3daf8bf9648ac69"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:855e068b0358ab916454464a884779c7ffa312b8925c6f7401e952dcf3b89977"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab7004cf2e59f7c2e4345604a3e6ea0d92ac44e1c2375527d56492014e690c3"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc0d2fc424e54c70c4bc06787e4072c4f3b1aa2f897dfdc34ce1013cf3ceef05"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e2adb09778797da09d2b5ebdbceebf7dd32e2c96f79da9052b2e87b6ea495895"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b1f711e2c6dcd4edd372cf5dec5c5a30d23bba06ee012093267b3376c079ec83"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-win32.whl", hash = "sha256:76a095cfe6045c7d0ca77db9934e8f7b71b14645f0094ffcd842349ada5c5fb9"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:b4f87d4ed9064b2628da63830986c3d2dca7501e6018347798313fcf028e2fd4"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fec03caabbc6b59ea4a638bee5fce7117be8e99a4103d9d5ad77f15d6f81020c"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02c83f957782cbbe8136bee26416686a6ae998c7b6191711a04da776dc9e47d4"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:009e6bb1f1935a62889ddc8541514b6a9e1fcf302667dcb049a0be5c8f613e56"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:75fc59fc450050b1b3c203c35020bc41bd2695ed692a392924c6ce180c6f1dc9"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:782e2c9b2aab1708ffb07d4bf377d12901d7a1d99e5e410d648d892f8967ab1f"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-win32.whl", hash = "sha256:edb45bb8278574710e68a6b021599a10ce730d156e5b254941754a9cc0b17d03"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:e271058822765ad5e3bca7f05f2ace0de58a3f4e62045a8c90a0dfd2f8ad8cc6"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e98c8af98d5707dcdecc9ab0863c0ea6e88545d42ca7c3feffb6b4d1e370c7ba"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:952c81d415b9b80ea261d2372d2a4a2332a3890c2b83e0535f263ddfe43f0d43"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80b39d3a151309efc8cc48675918891b865bdf742a8616a337cb0090791a0de9"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e221060b701e2aa2ea991542900dd13907a5c90fa80e199dbf5a03359019e7a3"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:92f09ff65ecff3108e56526f9e2481b8116c0b9e1425325e13245abfd79bdb1b"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-win32.whl", hash = "sha256:3ad54b9ddbe20ae9f7c1b29e52f123120772b06dbb18ec6be9101369d63a4074"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:127a789c75151db6af398b8972178afe6bda7d6f68730c057fbbc2e96b08d282"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4ed0518a14dd26092614412936920ad081a424bdcb54cc13349a8e2c6d106a"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ad9e6ed739285919aa9661a5bbed0aaf410aa60231373c5579c6b4801bd883c"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fc0a92c02fa1ca1e84fc60fa258458e5bf89d90a1ddaeb8ed9cc3147f417255"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0aefc7591920bbd360d57ea03c995cebc204b424524a5bd78406f6e1b8b2a5d8"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5faf03a7d8942bb4476e3b62fd0f4cf94eaf4618e304a19865abf89a35c0bbee"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-win32.whl", hash = "sha256:e333e2324307a7b5d86adfa835bb500ee70bfcd1447384a822e96495796b0ca4"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-win_amd64.whl", hash = "sha256:cb73507defd385b7705c599a94474b1d5222a508e502553ef94114a143ec6696"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:366c32fe5355ef5fc8a232c5436f4cc66e9d3e8967c01fb2e6302fd6627e3d94"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2297f08f08a2bb0d32a4265e98a006643cd7233fb7983032bd61ac7a02956b3b"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18dd842b49456aaa9a7cf535b04ca4571a302ff72ed8740d06b5adcd41fe0757"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:217138197c170a2a74ca0e05bddcd5f1796c735c37d0eee33e43259b192aa424"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9a3a87cf1e133e5b1994144c12ca4aa3d9698517fe1e2ca82977781b16955658"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-win32.whl", hash = "sha256:30b339b2a743c5288405aa79a69e706a06e02958eab31859f7f3c04980853b70"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:a899b10e17743683b293a729d3a11f2f399e8a90c73b089e29f5d0fe3509f0dd"}, + {file = "lazy_object_proxy-1.10.0-pp310.pp311.pp312.pp38.pp39-none-any.whl", hash = "sha256:80fa48bd89c8f2f456fc0765c11c23bf5af827febacd2f523ca5bc1893fcc09d"}, +] + +[[package]] +name = "lxml" +version = "4.9.4" +description = "Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, != 3.4.*" +files = [ + {file = "lxml-4.9.4-cp27-cp27m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e214025e23db238805a600f1f37bf9f9a15413c7bf5f9d6ae194f84980c78722"}, + {file = "lxml-4.9.4-cp27-cp27m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:ec53a09aee61d45e7dbe7e91252ff0491b6b5fee3d85b2d45b173d8ab453efc1"}, + {file = "lxml-4.9.4-cp27-cp27m-win32.whl", hash = "sha256:7d1d6c9e74c70ddf524e3c09d9dc0522aba9370708c2cb58680ea40174800013"}, + {file = "lxml-4.9.4-cp27-cp27m-win_amd64.whl", hash = "sha256:cb53669442895763e61df5c995f0e8361b61662f26c1b04ee82899c2789c8f69"}, + {file = "lxml-4.9.4-cp27-cp27mu-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:647bfe88b1997d7ae8d45dabc7c868d8cb0c8412a6e730a7651050b8c7289cf2"}, + {file = "lxml-4.9.4-cp27-cp27mu-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:4d973729ce04784906a19108054e1fd476bc85279a403ea1a72fdb051c76fa48"}, + {file = "lxml-4.9.4-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:056a17eaaf3da87a05523472ae84246f87ac2f29a53306466c22e60282e54ff8"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:aaa5c173a26960fe67daa69aa93d6d6a1cd714a6eb13802d4e4bd1d24a530644"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:647459b23594f370c1c01768edaa0ba0959afc39caeeb793b43158bb9bb6a663"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:bdd9abccd0927673cffe601d2c6cdad1c9321bf3437a2f507d6b037ef91ea307"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:00e91573183ad273e242db5585b52670eddf92bacad095ce25c1e682da14ed91"}, + {file = "lxml-4.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:a602ed9bd2c7d85bd58592c28e101bd9ff9c718fbde06545a70945ffd5d11868"}, + {file = "lxml-4.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:de362ac8bc962408ad8fae28f3967ce1a262b5d63ab8cefb42662566737f1dc7"}, + {file = "lxml-4.9.4-cp310-cp310-win32.whl", hash = "sha256:33714fcf5af4ff7e70a49731a7cc8fd9ce910b9ac194f66eaa18c3cc0a4c02be"}, + {file = "lxml-4.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:d3caa09e613ece43ac292fbed513a4bce170681a447d25ffcbc1b647d45a39c5"}, + {file = "lxml-4.9.4-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:359a8b09d712df27849e0bcb62c6a3404e780b274b0b7e4c39a88826d1926c28"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:43498ea734ccdfb92e1886dfedaebeb81178a241d39a79d5351ba2b671bff2b2"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:4855161013dfb2b762e02b3f4d4a21cc7c6aec13c69e3bffbf5022b3e708dd97"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:c71b5b860c5215fdbaa56f715bc218e45a98477f816b46cfde4a84d25b13274e"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9a2b5915c333e4364367140443b59f09feae42184459b913f0f41b9fed55794a"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d82411dbf4d3127b6cde7da0f9373e37ad3a43e89ef374965465928f01c2b979"}, + {file = "lxml-4.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:273473d34462ae6e97c0f4e517bd1bf9588aa67a1d47d93f760a1282640e24ac"}, + {file = "lxml-4.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:389d2b2e543b27962990ab529ac6720c3dded588cc6d0f6557eec153305a3622"}, + {file = "lxml-4.9.4-cp311-cp311-win32.whl", hash = "sha256:8aecb5a7f6f7f8fe9cac0bcadd39efaca8bbf8d1bf242e9f175cbe4c925116c3"}, + {file = "lxml-4.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:c7721a3ef41591341388bb2265395ce522aba52f969d33dacd822da8f018aff8"}, + {file = "lxml-4.9.4-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:dbcb2dc07308453db428a95a4d03259bd8caea97d7f0776842299f2d00c72fc8"}, + {file = "lxml-4.9.4-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:01bf1df1db327e748dcb152d17389cf6d0a8c5d533ef9bab781e9d5037619229"}, + {file = "lxml-4.9.4-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e8f9f93a23634cfafbad6e46ad7d09e0f4a25a2400e4a64b1b7b7c0fbaa06d9d"}, + {file = "lxml-4.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3f3f00a9061605725df1816f5713d10cd94636347ed651abdbc75828df302b20"}, + {file = "lxml-4.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:953dd5481bd6252bd480d6ec431f61d7d87fdcbbb71b0d2bdcfc6ae00bb6fb10"}, + {file = "lxml-4.9.4-cp312-cp312-win32.whl", hash = "sha256:266f655d1baff9c47b52f529b5f6bec33f66042f65f7c56adde3fcf2ed62ae8b"}, + {file = "lxml-4.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:f1faee2a831fe249e1bae9cbc68d3cd8a30f7e37851deee4d7962b17c410dd56"}, + {file = "lxml-4.9.4-cp35-cp35m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:23d891e5bdc12e2e506e7d225d6aa929e0a0368c9916c1fddefab88166e98b20"}, + {file = "lxml-4.9.4-cp35-cp35m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:e96a1788f24d03e8d61679f9881a883ecdf9c445a38f9ae3f3f193ab6c591c66"}, + {file = "lxml-4.9.4-cp36-cp36m-macosx_11_0_x86_64.whl", hash = "sha256:5557461f83bb7cc718bc9ee1f7156d50e31747e5b38d79cf40f79ab1447afd2d"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:fdb325b7fba1e2c40b9b1db407f85642e32404131c08480dd652110fc908561b"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d74d4a3c4b8f7a1f676cedf8e84bcc57705a6d7925e6daef7a1e54ae543a197"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:ac7674d1638df129d9cb4503d20ffc3922bd463c865ef3cb412f2c926108e9a4"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_28_x86_64.whl", hash = "sha256:ddd92e18b783aeb86ad2132d84a4b795fc5ec612e3545c1b687e7747e66e2b53"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2bd9ac6e44f2db368ef8986f3989a4cad3de4cd55dbdda536e253000c801bcc7"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:bc354b1393dce46026ab13075f77b30e40b61b1a53e852e99d3cc5dd1af4bc85"}, + {file = "lxml-4.9.4-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:f836f39678cb47c9541f04d8ed4545719dc31ad850bf1832d6b4171e30d65d23"}, + {file = "lxml-4.9.4-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:9c131447768ed7bc05a02553d939e7f0e807e533441901dd504e217b76307745"}, + {file = "lxml-4.9.4-cp36-cp36m-win32.whl", hash = "sha256:bafa65e3acae612a7799ada439bd202403414ebe23f52e5b17f6ffc2eb98c2be"}, + {file = "lxml-4.9.4-cp36-cp36m-win_amd64.whl", hash = "sha256:6197c3f3c0b960ad033b9b7d611db11285bb461fc6b802c1dd50d04ad715c225"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:7b378847a09d6bd46047f5f3599cdc64fcb4cc5a5a2dd0a2af610361fbe77b16"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:1343df4e2e6e51182aad12162b23b0a4b3fd77f17527a78c53f0f23573663545"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:6dbdacf5752fbd78ccdb434698230c4f0f95df7dd956d5f205b5ed6911a1367c"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:506becdf2ecaebaf7f7995f776394fcc8bd8a78022772de66677c84fb02dd33d"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ca8e44b5ba3edb682ea4e6185b49661fc22b230cf811b9c13963c9f982d1d964"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:9d9d5726474cbbef279fd709008f91a49c4f758bec9c062dfbba88eab00e3ff9"}, + {file = "lxml-4.9.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:bbdd69e20fe2943b51e2841fc1e6a3c1de460d630f65bde12452d8c97209464d"}, + {file = "lxml-4.9.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8671622256a0859f5089cbe0ce4693c2af407bc053dcc99aadff7f5310b4aa02"}, + {file = "lxml-4.9.4-cp37-cp37m-win32.whl", hash = "sha256:dd4fda67f5faaef4f9ee5383435048ee3e11ad996901225ad7615bc92245bc8e"}, + {file = "lxml-4.9.4-cp37-cp37m-win_amd64.whl", hash = "sha256:6bee9c2e501d835f91460b2c904bc359f8433e96799f5c2ff20feebd9bb1e590"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:1f10f250430a4caf84115b1e0f23f3615566ca2369d1962f82bef40dd99cd81a"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:3b505f2bbff50d261176e67be24e8909e54b5d9d08b12d4946344066d66b3e43"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:1449f9451cd53e0fd0a7ec2ff5ede4686add13ac7a7bfa6988ff6d75cff3ebe2"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:4ece9cca4cd1c8ba889bfa67eae7f21d0d1a2e715b4d5045395113361e8c533d"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:59bb5979f9941c61e907ee571732219fa4774d5a18f3fa5ff2df963f5dfaa6bc"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:b1980dbcaad634fe78e710c8587383e6e3f61dbe146bcbfd13a9c8ab2d7b1192"}, + {file = "lxml-4.9.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9ae6c3363261021144121427b1552b29e7b59de9d6a75bf51e03bc072efb3c37"}, + {file = "lxml-4.9.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bcee502c649fa6351b44bb014b98c09cb00982a475a1912a9881ca28ab4f9cd9"}, + {file = "lxml-4.9.4-cp38-cp38-win32.whl", hash = "sha256:a8edae5253efa75c2fc79a90068fe540b197d1c7ab5803b800fccfe240eed33c"}, + {file = "lxml-4.9.4-cp38-cp38-win_amd64.whl", hash = "sha256:701847a7aaefef121c5c0d855b2affa5f9bd45196ef00266724a80e439220e46"}, + {file = "lxml-4.9.4-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:f610d980e3fccf4394ab3806de6065682982f3d27c12d4ce3ee46a8183d64a6a"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:aa9b5abd07f71b081a33115d9758ef6077924082055005808f68feccb27616bd"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:365005e8b0718ea6d64b374423e870648ab47c3a905356ab6e5a5ff03962b9a9"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:16b9ec51cc2feab009e800f2c6327338d6ee4e752c76e95a35c4465e80390ccd"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:a905affe76f1802edcac554e3ccf68188bea16546071d7583fb1b693f9cf756b"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fd814847901df6e8de13ce69b84c31fc9b3fb591224d6762d0b256d510cbf382"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:91bbf398ac8bb7d65a5a52127407c05f75a18d7015a270fdd94bbcb04e65d573"}, + {file = "lxml-4.9.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f99768232f036b4776ce419d3244a04fe83784bce871b16d2c2e984c7fcea847"}, + {file = "lxml-4.9.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bb5bd6212eb0edfd1e8f254585290ea1dadc3687dd8fd5e2fd9a87c31915cdab"}, + {file = "lxml-4.9.4-cp39-cp39-win32.whl", hash = "sha256:88f7c383071981c74ec1998ba9b437659e4fd02a3c4a4d3efc16774eb108d0ec"}, + {file = "lxml-4.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:936e8880cc00f839aa4173f94466a8406a96ddce814651075f95837316369899"}, + {file = "lxml-4.9.4-pp310-pypy310_pp73-macosx_11_0_x86_64.whl", hash = "sha256:f6c35b2f87c004270fa2e703b872fcc984d714d430b305145c39d53074e1ffe0"}, + {file = "lxml-4.9.4-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:606d445feeb0856c2b424405236a01c71af7c97e5fe42fbc778634faef2b47e4"}, + {file = "lxml-4.9.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a1bdcbebd4e13446a14de4dd1825f1e778e099f17f79718b4aeaf2403624b0f7"}, + {file = "lxml-4.9.4-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:0a08c89b23117049ba171bf51d2f9c5f3abf507d65d016d6e0fa2f37e18c0fc5"}, + {file = "lxml-4.9.4-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:232fd30903d3123be4c435fb5159938c6225ee8607b635a4d3fca847003134ba"}, + {file = "lxml-4.9.4-pp37-pypy37_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:231142459d32779b209aa4b4d460b175cadd604fed856f25c1571a9d78114771"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-macosx_11_0_x86_64.whl", hash = "sha256:520486f27f1d4ce9654154b4494cf9307b495527f3a2908ad4cb48e4f7ed7ef7"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:562778586949be7e0d7435fcb24aca4810913771f845d99145a6cee64d5b67ca"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:a9e7c6d89c77bb2770c9491d988f26a4b161d05c8ca58f63fb1f1b6b9a74be45"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:786d6b57026e7e04d184313c1359ac3d68002c33e4b1042ca58c362f1d09ff58"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:95ae6c5a196e2f239150aa4a479967351df7f44800c93e5a975ec726fef005e2"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-macosx_11_0_x86_64.whl", hash = "sha256:9b556596c49fa1232b0fff4b0e69b9d4083a502e60e404b44341e2f8fb7187f5"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:cc02c06e9e320869d7d1bd323df6dd4281e78ac2e7f8526835d3d48c69060683"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:857d6565f9aa3464764c2cb6a2e3c2e75e1970e877c188f4aeae45954a314e0c"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c42ae7e010d7d6bc51875d768110c10e8a59494855c3d4c348b068f5fb81fdcd"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f10250bb190fb0742e3e1958dd5c100524c2cc5096c67c8da51233f7448dc137"}, + {file = "lxml-4.9.4.tar.gz", hash = "sha256:b1541e50b78e15fa06a2670157a1962ef06591d4c998b998047fff5e3236880e"}, +] + +[package.extras] +cssselect = ["cssselect (>=0.7)"] +html5 = ["html5lib"] +htmlsoup = ["BeautifulSoup4"] +source = ["Cython (==0.29.37)"] + +[[package]] +name = "markupsafe" +version = "2.1.5" +description = "Safely add untrusted strings to HTML/XML markup." +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "mccabe" +version = "0.7.0" +description = "McCabe checker, plugin for flake8" +optional = false +python-versions = ">=3.6" +files = [ + {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"}, + {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, +] + +[[package]] +name = "mean-average-precision" +version = "2021.4.26.0" +description = "Mean Average Precision evaluator for object detection." +optional = false +python-versions = "*" +files = [ + {file = "mean_average_precision-2021.4.26.0-py3-none-any.whl", hash = "sha256:4a4d08e27f016c8e6ffb8bea0687f59eca63c0060543f90c2e1373a48e5500c5"}, + {file = "mean_average_precision-2021.4.26.0.tar.gz", hash = "sha256:20596a0a411fcdd2bdb159636f21f3501de76395fcb8ac3db0b90982b4bdfd7d"}, +] + +[package.dependencies] +numpy = "*" +pandas = "*" + +[[package]] +name = "more-itertools" +version = "10.3.0" +description = "More routines for operating on iterables, beyond itertools" +optional = false +python-versions = ">=3.8" +files = [ + {file = "more-itertools-10.3.0.tar.gz", hash = "sha256:e5d93ef411224fbcef366a6e8ddc4c5781bc6359d43412a65dd5964e46111463"}, + {file = "more_itertools-10.3.0-py3-none-any.whl", hash = "sha256:ea6a02e24a9161e51faad17a8782b92a0df82c12c1c8886fec7f0c3fa1a1b320"}, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +description = "Python library for arbitrary-precision floating-point arithmetic" +optional = false +python-versions = "*" +files = [ + {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, + {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, +] + +[package.extras] +develop = ["codecov", "pycodestyle", "pytest (>=4.6)", "pytest-cov", "wheel"] +docs = ["sphinx"] +gmpy = ["gmpy2 (>=2.1.0a4)"] +tests = ["pytest (>=4.6)"] + +[[package]] +name = "mypy" +version = "1.10.1" +description = "Optional static typing for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "mypy-1.10.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e36f229acfe250dc660790840916eb49726c928e8ce10fbdf90715090fe4ae02"}, + {file = "mypy-1.10.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:51a46974340baaa4145363b9e051812a2446cf583dfaeba124af966fa44593f7"}, + {file = "mypy-1.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:901c89c2d67bba57aaaca91ccdb659aa3a312de67f23b9dfb059727cce2e2e0a"}, + {file = "mypy-1.10.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0cd62192a4a32b77ceb31272d9e74d23cd88c8060c34d1d3622db3267679a5d9"}, + {file = "mypy-1.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:a2cbc68cb9e943ac0814c13e2452d2046c2f2b23ff0278e26599224cf164e78d"}, + {file = "mypy-1.10.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:bd6f629b67bb43dc0d9211ee98b96d8dabc97b1ad38b9b25f5e4c4d7569a0c6a"}, + {file = "mypy-1.10.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a1bbb3a6f5ff319d2b9d40b4080d46cd639abe3516d5a62c070cf0114a457d84"}, + {file = "mypy-1.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8edd4e9bbbc9d7b79502eb9592cab808585516ae1bcc1446eb9122656c6066f"}, + {file = "mypy-1.10.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:6166a88b15f1759f94a46fa474c7b1b05d134b1b61fca627dd7335454cc9aa6b"}, + {file = "mypy-1.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:5bb9cd11c01c8606a9d0b83ffa91d0b236a0e91bc4126d9ba9ce62906ada868e"}, + {file = "mypy-1.10.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d8681909f7b44d0b7b86e653ca152d6dff0eb5eb41694e163c6092124f8246d7"}, + {file = "mypy-1.10.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:378c03f53f10bbdd55ca94e46ec3ba255279706a6aacaecac52ad248f98205d3"}, + {file = "mypy-1.10.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bacf8f3a3d7d849f40ca6caea5c055122efe70e81480c8328ad29c55c69e93e"}, + {file = "mypy-1.10.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:701b5f71413f1e9855566a34d6e9d12624e9e0a8818a5704d74d6b0402e66c04"}, + {file = "mypy-1.10.1-cp312-cp312-win_amd64.whl", hash = "sha256:3c4c2992f6ea46ff7fce0072642cfb62af7a2484efe69017ed8b095f7b39ef31"}, + {file = "mypy-1.10.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:604282c886497645ffb87b8f35a57ec773a4a2721161e709a4422c1636ddde5c"}, + {file = "mypy-1.10.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37fd87cab83f09842653f08de066ee68f1182b9b5282e4634cdb4b407266bade"}, + {file = "mypy-1.10.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8addf6313777dbb92e9564c5d32ec122bf2c6c39d683ea64de6a1fd98b90fe37"}, + {file = "mypy-1.10.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5cc3ca0a244eb9a5249c7c583ad9a7e881aa5d7b73c35652296ddcdb33b2b9c7"}, + {file = "mypy-1.10.1-cp38-cp38-win_amd64.whl", hash = "sha256:1b3a2ffce52cc4dbaeee4df762f20a2905aa171ef157b82192f2e2f368eec05d"}, + {file = "mypy-1.10.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fe85ed6836165d52ae8b88f99527d3d1b2362e0cb90b005409b8bed90e9059b3"}, + {file = "mypy-1.10.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c2ae450d60d7d020d67ab440c6e3fae375809988119817214440033f26ddf7bf"}, + {file = "mypy-1.10.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6be84c06e6abd72f960ba9a71561c14137a583093ffcf9bbfaf5e613d63fa531"}, + {file = "mypy-1.10.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:2189ff1e39db399f08205e22a797383613ce1cb0cb3b13d8bcf0170e45b96cc3"}, + {file = "mypy-1.10.1-cp39-cp39-win_amd64.whl", hash = "sha256:97a131ee36ac37ce9581f4220311247ab6cba896b4395b9c87af0675a13a755f"}, + {file = "mypy-1.10.1-py3-none-any.whl", hash = "sha256:71d8ac0b906354ebda8ef1673e5fde785936ac1f29ff6987c7483cfbd5a4235a"}, + {file = "mypy-1.10.1.tar.gz", hash = "sha256:1f8f492d7db9e3593ef42d4f115f04e556130f2819ad33ab84551403e97dd4c0"}, +] + +[package.dependencies] +mypy-extensions = ">=1.0.0" +typing-extensions = ">=4.1.0" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +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 = "networkx" +version = "3.3" +description = "Python package for creating and manipulating graphs and networks" +optional = false +python-versions = ">=3.10" +files = [ + {file = "networkx-3.3-py3-none-any.whl", hash = "sha256:28575580c6ebdaf4505b22c6256a2b9de86b316dc63ba9e93abde3d78dfdbcf2"}, + {file = "networkx-3.3.tar.gz", hash = "sha256:0c127d8b2f4865f59ae9cb8aafcd60b5c70f3241ebd66f7defad7c4ab90126c9"}, +] + +[package.extras] +default = ["matplotlib (>=3.6)", "numpy (>=1.23)", "pandas (>=1.4)", "scipy (>=1.9,!=1.11.0,!=1.11.1)"] +developer = ["changelist (==0.5)", "mypy (>=1.1)", "pre-commit (>=3.2)", "rtoml"] +doc = ["myst-nb (>=1.0)", "numpydoc (>=1.7)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.14)", "sphinx (>=7)", "sphinx-gallery (>=0.14)", "texext (>=0.6.7)"] +extra = ["lxml (>=4.6)", "pydot (>=2.0)", "pygraphviz (>=1.12)", "sympy (>=1.10)"] +test = ["pytest (>=7.2)", "pytest-cov (>=4.0)"] + +[[package]] +name = "nh3" +version = "0.2.18" +description = "Python bindings to the ammonia HTML sanitization library." +optional = false +python-versions = "*" +files = [ + {file = "nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:14c5a72e9fe82aea5fe3072116ad4661af5cf8e8ff8fc5ad3450f123e4925e86"}, + {file = "nh3-0.2.18-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:7b7c2a3c9eb1a827d42539aa64091640bd275b81e097cd1d8d82ef91ffa2e811"}, + {file = "nh3-0.2.18-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42c64511469005058cd17cc1537578eac40ae9f7200bedcfd1fc1a05f4f8c200"}, + {file = "nh3-0.2.18-cp37-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0411beb0589eacb6734f28d5497ca2ed379eafab8ad8c84b31bb5c34072b7164"}, + {file = "nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:5f36b271dae35c465ef5e9090e1fdaba4a60a56f0bb0ba03e0932a66f28b9189"}, + {file = "nh3-0.2.18-cp37-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:34c03fa78e328c691f982b7c03d4423bdfd7da69cd707fe572f544cf74ac23ad"}, + {file = "nh3-0.2.18-cp37-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:19aaba96e0f795bd0a6c56291495ff59364f4300d4a39b29a0abc9cb3774a84b"}, + {file = "nh3-0.2.18-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de3ceed6e661954871d6cd78b410213bdcb136f79aafe22aa7182e028b8c7307"}, + {file = "nh3-0.2.18-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6955369e4d9f48f41e3f238a9e60f9410645db7e07435e62c6a9ea6135a4907f"}, + {file = "nh3-0.2.18-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f0eca9ca8628dbb4e916ae2491d72957fdd35f7a5d326b7032a345f111ac07fe"}, + {file = "nh3-0.2.18-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:3a157ab149e591bb638a55c8c6bcb8cdb559c8b12c13a8affaba6cedfe51713a"}, + {file = "nh3-0.2.18-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:c8b3a1cebcba9b3669ed1a84cc65bf005728d2f0bc1ed2a6594a992e817f3a50"}, + {file = "nh3-0.2.18-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36c95d4b70530b320b365659bb5034341316e6a9b30f0b25fa9c9eff4c27a204"}, + {file = "nh3-0.2.18-cp37-abi3-win32.whl", hash = "sha256:a7f1b5b2c15866f2db413a3649a8fe4fd7b428ae58be2c0f6bca5eefd53ca2be"}, + {file = "nh3-0.2.18-cp37-abi3-win_amd64.whl", hash = "sha256:8ce0f819d2f1933953fca255db2471ad58184a60508f03e6285e5114b6254844"}, + {file = "nh3-0.2.18.tar.gz", hash = "sha256:94a166927e53972a9698af9542ace4e38b9de50c34352b962f4d9a7d4c927af4"}, +] + +[[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 = "nvidia-cublas-cu12" +version = "12.1.3.1" +description = "CUBLAS native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl", hash = "sha256:ee53ccca76a6fc08fb9701aa95b6ceb242cdaab118c3bb152af4e579af792728"}, + {file = "nvidia_cublas_cu12-12.1.3.1-py3-none-win_amd64.whl", hash = "sha256:2b964d60e8cf11b5e1073d179d85fa340c120e99b3067558f3cf98dd69d02906"}, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.1.105" +description = "CUDA profiling tools runtime libs." +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:e54fde3983165c624cb79254ae9818a456eb6e87a7fd4d56a2352c24ee542d7e"}, + {file = "nvidia_cuda_cupti_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:bea8236d13a0ac7190bd2919c3e8e6ce1e402104276e6f9694479e48bb0eb2a4"}, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.1.105" +description = "NVRTC native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:339b385f50c309763ca65456ec75e17bbefcbbf2893f462cb8b90584cd27a1c2"}, + {file = "nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:0a98a522d9ff138b96c010a65e145dc1b4850e9ecb75a0172371793752fd46ed"}, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.1.105" +description = "CUDA Runtime native Libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:6e258468ddf5796e25f1dc591a31029fa317d97a0a94ed93468fc86301d61e40"}, + {file = "nvidia_cuda_runtime_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:dfb46ef84d73fababab44cf03e3b83f80700d27ca300e537f85f636fac474344"}, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "8.9.2.26" +description = "cuDNN runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl", hash = "sha256:5ccb288774fdfb07a7e7025ffec286971c06d8d7b4fb162525334616d7629ff9"}, +] + +[package.dependencies] +nvidia-cublas-cu12 = "*" + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.0.2.54" +description = "CUFFT native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl", hash = "sha256:794e3948a1aa71fd817c3775866943936774d1c14e7628c74f6f7417224cdf56"}, + {file = "nvidia_cufft_cu12-11.0.2.54-py3-none-win_amd64.whl", hash = "sha256:d9ac353f78ff89951da4af698f80870b1534ed69993f10a4cf1d96f21357e253"}, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.2.106" +description = "CURAND native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:9d264c5036dde4e64f1de8c50ae753237c12e0b1348738169cd0f8a536c0e1e0"}, + {file = "nvidia_curand_cu12-10.3.2.106-py3-none-win_amd64.whl", hash = "sha256:75b6b0c574c0037839121317e17fd01f8a69fd2ef8e25853d826fec30bdba74a"}, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.4.5.107" +description = "CUDA solver native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl", hash = "sha256:8a7ec542f0412294b15072fa7dab71d31334014a69f953004ea7a118206fe0dd"}, + {file = "nvidia_cusolver_cu12-11.4.5.107-py3-none-win_amd64.whl", hash = "sha256:74e0c3a24c78612192a74fcd90dd117f1cf21dea4822e66d89e8ea80e3cd2da5"}, +] + +[package.dependencies] +nvidia-cublas-cu12 = "*" +nvidia-cusparse-cu12 = "*" +nvidia-nvjitlink-cu12 = "*" + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.1.0.106" +description = "CUSPARSE native runtime libraries" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:f3b50f42cf363f86ab21f720998517a659a48131e8d538dc02f8768237bd884c"}, + {file = "nvidia_cusparse_cu12-12.1.0.106-py3-none-win_amd64.whl", hash = "sha256:b798237e81b9719373e8fae8d4f091b70a0cf09d9d85c95a557e11df2d8e9a5a"}, +] + +[package.dependencies] +nvidia-nvjitlink-cu12 = "*" + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.19.3" +description = "NVIDIA Collective Communication Library (NCCL) Runtime" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_nccl_cu12-2.19.3-py3-none-manylinux1_x86_64.whl", hash = "sha256:a9734707a2c96443331c1e48c717024aa6678a0e2a4cb66b2c364d18cee6b48d"}, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.5.82" +description = "Nvidia JIT LTO Library" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_nvjitlink_cu12-12.5.82-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f9b37bc5c8cf7509665cb6ada5aaa0ce65618f2332b7d3e78e9790511f111212"}, + {file = "nvidia_nvjitlink_cu12-12.5.82-py3-none-win_amd64.whl", hash = "sha256:e782564d705ff0bf61ac3e1bf730166da66dd2fe9012f111ede5fc49b64ae697"}, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.1.105" +description = "NVIDIA Tools Extension" +optional = false +python-versions = ">=3" +files = [ + {file = "nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:dc21cf308ca5691e7c04d962e213f8a4aa9bbfa23d95412f452254c2caeb09e5"}, + {file = "nvidia_nvtx_cu12-12.1.105-py3-none-win_amd64.whl", hash = "sha256:65f4d98982b31b60026e0e6de73fbdfc09d08a96f4656dd3665ca616a11e1e82"}, +] + +[[package]] +name = "onnxruntime" +version = "1.18.1" +description = "ONNX Runtime is a runtime accelerator for Machine Learning models" +optional = false +python-versions = "*" +files = [ + {file = "onnxruntime-1.18.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:29ef7683312393d4ba04252f1b287d964bd67d5e6048b94d2da3643986c74d80"}, + {file = "onnxruntime-1.18.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc706eb1df06ddf55776e15a30519fb15dda7697f987a2bbda4962845e3cec05"}, + {file = "onnxruntime-1.18.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7de69f5ced2a263531923fa68bbec52a56e793b802fcd81a03487b5e292bc3a"}, + {file = "onnxruntime-1.18.1-cp310-cp310-win32.whl", hash = "sha256:221e5b16173926e6c7de2cd437764492aa12b6811f45abd37024e7cf2ae5d7e3"}, + {file = "onnxruntime-1.18.1-cp310-cp310-win_amd64.whl", hash = "sha256:75211b619275199c861ee94d317243b8a0fcde6032e5a80e1aa9ded8ab4c6060"}, + {file = "onnxruntime-1.18.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:f26582882f2dc581b809cfa41a125ba71ad9e715738ec6402418df356969774a"}, + {file = "onnxruntime-1.18.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef36f3a8b768506d02be349ac303fd95d92813ba3ba70304d40c3cd5c25d6a4c"}, + {file = "onnxruntime-1.18.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:170e711393e0618efa8ed27b59b9de0ee2383bd2a1f93622a97006a5ad48e434"}, + {file = "onnxruntime-1.18.1-cp311-cp311-win32.whl", hash = "sha256:9b6a33419b6949ea34e0dc009bc4470e550155b6da644571ecace4b198b0d88f"}, + {file = "onnxruntime-1.18.1-cp311-cp311-win_amd64.whl", hash = "sha256:5c1380a9f1b7788da742c759b6a02ba771fe1ce620519b2b07309decbd1a2fe1"}, + {file = "onnxruntime-1.18.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:31bd57a55e3f983b598675dfc7e5d6f0877b70ec9864b3cc3c3e1923d0a01919"}, + {file = "onnxruntime-1.18.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9e03c4ba9f734500691a4d7d5b381cd71ee2f3ce80a1154ac8f7aed99d1ecaa"}, + {file = "onnxruntime-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:781aa9873640f5df24524f96f6070b8c550c66cb6af35710fd9f92a20b4bfbf6"}, + {file = "onnxruntime-1.18.1-cp312-cp312-win32.whl", hash = "sha256:3a2d9ab6254ca62adbb448222e630dc6883210f718065063518c8f93a32432be"}, + {file = "onnxruntime-1.18.1-cp312-cp312-win_amd64.whl", hash = "sha256:ad93c560b1c38c27c0275ffd15cd7f45b3ad3fc96653c09ce2931179982ff204"}, + {file = "onnxruntime-1.18.1-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:3b55dc9d3c67626388958a3eb7ad87eb7c70f75cb0f7ff4908d27b8b42f2475c"}, + {file = "onnxruntime-1.18.1-cp38-cp38-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f80dbcfb6763cc0177a31168b29b4bd7662545b99a19e211de8c734b657e0669"}, + {file = "onnxruntime-1.18.1-cp38-cp38-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f1ff2c61a16d6c8631796c54139bafea41ee7736077a0fc64ee8ae59432f5c58"}, + {file = "onnxruntime-1.18.1-cp38-cp38-win32.whl", hash = "sha256:219855bd272fe0c667b850bf1a1a5a02499269a70d59c48e6f27f9c8bcb25d02"}, + {file = "onnxruntime-1.18.1-cp38-cp38-win_amd64.whl", hash = "sha256:afdf16aa607eb9a2c60d5ca2d5abf9f448e90c345b6b94c3ed14f4fb7e6a2d07"}, + {file = "onnxruntime-1.18.1-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:128df253ade673e60cea0955ec9d0e89617443a6d9ce47c2d79eb3f72a3be3de"}, + {file = "onnxruntime-1.18.1-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9839491e77e5c5a175cab3621e184d5a88925ee297ff4c311b68897197f4cde9"}, + {file = "onnxruntime-1.18.1-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ad3187c1faff3ac15f7f0e7373ef4788c582cafa655a80fdbb33eaec88976c66"}, + {file = "onnxruntime-1.18.1-cp39-cp39-win32.whl", hash = "sha256:34657c78aa4e0b5145f9188b550ded3af626651b15017bf43d280d7e23dbf195"}, + {file = "onnxruntime-1.18.1-cp39-cp39-win_amd64.whl", hash = "sha256:9c14fd97c3ddfa97da5feef595e2c73f14c2d0ec1d4ecbea99c8d96603c89589"}, +] + +[package.dependencies] +coloredlogs = "*" +flatbuffers = "*" +numpy = ">=1.21.6,<2.0" +packaging = "*" +protobuf = "*" +sympy = "*" + +[[package]] +name = "opencv-python" +version = "4.10.0.84" +description = "Wrapper package for OpenCV python bindings." +optional = false +python-versions = ">=3.6" +files = [ + {file = "opencv-python-4.10.0.84.tar.gz", hash = "sha256:72d234e4582e9658ffea8e9cae5b63d488ad06994ef12d81dc303b17472f3526"}, + {file = "opencv_python-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:fc182f8f4cda51b45f01c64e4cbedfc2f00aff799debebc305d8d0210c43f251"}, + {file = "opencv_python-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:71e575744f1d23f79741450254660442785f45a0797212852ee5199ef12eed98"}, + {file = "opencv_python-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09a332b50488e2dda866a6c5573ee192fe3583239fb26ff2f7f9ceb0bc119ea6"}, + {file = "opencv_python-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ace140fc6d647fbe1c692bcb2abce768973491222c067c131d80957c595b71f"}, + {file = "opencv_python-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:2db02bb7e50b703f0a2d50c50ced72e95c574e1e5a0bb35a8a86d0b35c98c236"}, + {file = "opencv_python-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:32dbbd94c26f611dc5cc6979e6b7aa1f55a64d6b463cc1dcd3c95505a63e48fe"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.23.5", markers = "python_version >= \"3.11\" and python_version < \"3.12\""}, + {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, +] + +[[package]] +name = "opencv-python-headless" +version = "4.10.0.84" +description = "Wrapper package for OpenCV python bindings." +optional = false +python-versions = ">=3.6" +files = [ + {file = "opencv-python-headless-4.10.0.84.tar.gz", hash = "sha256:f2017c6101d7c2ef8d7bc3b414c37ff7f54d64413a1847d89970b6b7069b4e1a"}, + {file = "opencv_python_headless-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:a4f4bcb07d8f8a7704d9c8564c224c8b064c63f430e95b61ac0bffaa374d330e"}, + {file = "opencv_python_headless-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:5ae454ebac0eb0a0b932e3406370aaf4212e6a3fdb5038cc86c7aea15a6851da"}, + {file = "opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46071015ff9ab40fccd8a163da0ee14ce9846349f06c6c8c0f2870856ffa45db"}, + {file = "opencv_python_headless-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:377d08a7e48a1405b5e84afcbe4798464ce7ee17081c1c23619c8b398ff18295"}, + {file = "opencv_python_headless-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:9092404b65458ed87ce932f613ffbb1106ed2c843577501e5768912360fc50ec"}, + {file = "opencv_python_headless-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:afcf28bd1209dd58810d33defb622b325d3cbe49dcd7a43a902982c33e5fad05"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.23.5", markers = "python_version >= \"3.11\" and python_version < \"3.12\""}, + {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, +] + +[[package]] +name = "packaging" +version = "24.1" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"}, + {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"}, +] + +[[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.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 = "parso" +version = "0.8.4" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[package.extras] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["docopt", "pytest"] + +[[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 = "pexpect" +version = "4.9.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pillow" +version = "10.4.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e"}, + {file = "pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46"}, + {file = "pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984"}, + {file = "pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141"}, + {file = "pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696"}, + {file = "pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496"}, + {file = "pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91"}, + {file = "pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9"}, + {file = "pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42"}, + {file = "pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a"}, + {file = "pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309"}, + {file = "pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060"}, + {file = "pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea"}, + {file = "pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0"}, + {file = "pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e"}, + {file = "pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df"}, + {file = "pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef"}, + {file = "pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5"}, + {file = "pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=7.3)", "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 = "pkginfo" +version = "1.11.1" +description = "Query metadata from sdists / bdists / installed packages." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pkginfo-1.11.1-py3-none-any.whl", hash = "sha256:bfa76a714fdfc18a045fcd684dbfc3816b603d9d075febef17cb6582bea29573"}, + {file = "pkginfo-1.11.1.tar.gz", hash = "sha256:2e0dca1cf4c8e39644eed32408ea9966ee15e0d324c62ba899a393b3c6b467aa"}, +] + +[package.extras] +testing = ["pytest", "pytest-cov", "wheel"] + +[[package]] +name = "platformdirs" +version = "4.2.2" +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.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"}, + {file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] +type = ["mypy (>=1.8)"] + +[[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.7.1" +description = "A framework for managing and maintaining multi-language pre-commit hooks." +optional = false +python-versions = ">=3.9" +files = [ + {file = "pre_commit-3.7.1-py2.py3-none-any.whl", hash = "sha256:fae36fd1d7ad7d6a5a1c0b0d5adb2ed1a3bda5a21bf6c3e5372073d7a11cd4c5"}, + {file = "pre_commit-3.7.1.tar.gz", hash = "sha256:8ca3ad567bc78a4972a3f1a477e94a79d4597e8140a6e0b651c5e33899c3654a"}, +] + +[package.dependencies] +cfgv = ">=2.0.0" +identify = ">=1.0.0" +nodeenv = ">=0.11.1" +pyyaml = ">=5.1" +virtualenv = ">=20.10.0" + +[[package]] +name = "prompt-toolkit" +version = "3.0.47" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "protobuf" +version = "5.27.2" +description = "" +optional = false +python-versions = ">=3.8" +files = [ + {file = "protobuf-5.27.2-cp310-abi3-win32.whl", hash = "sha256:354d84fac2b0d76062e9b3221f4abbbacdfd2a4d8af36bab0474f3a0bb30ab38"}, + {file = "protobuf-5.27.2-cp310-abi3-win_amd64.whl", hash = "sha256:0e341109c609749d501986b835f667c6e1e24531096cff9d34ae411595e26505"}, + {file = "protobuf-5.27.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:a109916aaac42bff84702fb5187f3edadbc7c97fc2c99c5ff81dd15dcce0d1e5"}, + {file = "protobuf-5.27.2-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:176c12b1f1c880bf7a76d9f7c75822b6a2bc3db2d28baa4d300e8ce4cde7409b"}, + {file = "protobuf-5.27.2-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:b848dbe1d57ed7c191dfc4ea64b8b004a3f9ece4bf4d0d80a367b76df20bf36e"}, + {file = "protobuf-5.27.2-cp38-cp38-win32.whl", hash = "sha256:4fadd8d83e1992eed0248bc50a4a6361dc31bcccc84388c54c86e530b7f58863"}, + {file = "protobuf-5.27.2-cp38-cp38-win_amd64.whl", hash = "sha256:610e700f02469c4a997e58e328cac6f305f649826853813177e6290416e846c6"}, + {file = "protobuf-5.27.2-cp39-cp39-win32.whl", hash = "sha256:9e8f199bf7f97bd7ecebffcae45ebf9527603549b2b562df0fbc6d4d688f14ca"}, + {file = "protobuf-5.27.2-cp39-cp39-win_amd64.whl", hash = "sha256:7fc3add9e6003e026da5fc9e59b131b8f22b428b991ccd53e2af8071687b4fce"}, + {file = "protobuf-5.27.2-py3-none-any.whl", hash = "sha256:54330f07e4949d09614707c48b06d1a22f8ffb5763c159efd5c0928326a91470"}, + {file = "protobuf-5.27.2.tar.gz", hash = "sha256:f3ecdef226b9af856075f28227ff2c90ce3a594d092c39bee5513573f25e2714"}, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, + {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, +] + +[package.extras] +tests = ["pytest"] + +[[package]] +name = "pycodestyle" +version = "2.11.1" +description = "Python style guide checker" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pycodestyle-2.11.1-py2.py3-none-any.whl", hash = "sha256:44fe31000b2d866f2e41841b18528a505fbd7fef9017b04eff4e2648a0fadc67"}, + {file = "pycodestyle-2.11.1.tar.gz", hash = "sha256:41ba0e7afc9752dfb53ced5489e89f8186be00e599e712660695b7a75ff2663f"}, +] + +[[package]] +name = "pycparser" +version = "2.22" +description = "C parser in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + +[[package]] +name = "pyflakes" +version = "3.1.0" +description = "passive checker of Python programs" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pyflakes-3.1.0-py2.py3-none-any.whl", hash = "sha256:4132f6d49cb4dae6819e5379898f2b8cce3c5f23994194c24b77d5da2e36f774"}, + {file = "pyflakes-3.1.0.tar.gz", hash = "sha256:a0aae034c444db0071aa077972ba4768d40c830d9539fd45bf4cd3f8f6992efc"}, +] + +[[package]] +name = "pygments" +version = "2.18.0" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, +] + +[package.extras] +windows-terminal = ["colorama (>=0.4.6)"] + +[[package]] +name = "pylint" +version = "2.17.7" +description = "python code static checker" +optional = false +python-versions = ">=3.7.2" +files = [ + {file = "pylint-2.17.7-py3-none-any.whl", hash = "sha256:27a8d4c7ddc8c2f8c18aa0050148f89ffc09838142193fdbe98f172781a3ff87"}, + {file = "pylint-2.17.7.tar.gz", hash = "sha256:f4fcac7ae74cfe36bc8451e931d8438e4a476c20314b1101c458ad0f05191fad"}, +] + +[package.dependencies] +astroid = ">=2.15.8,<=2.17.0-dev0" +colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""} +dill = {version = ">=0.3.6", markers = "python_version >= \"3.11\""} +isort = ">=4.2.5,<6" +mccabe = ">=0.6,<0.8" +platformdirs = ">=2.2.0" +tomlkit = ">=0.10.1" + +[package.extras] +spelling = ["pyenchant (>=3.2,<4.0)"] +testutils = ["gitpython (>3)"] + +[[package]] +name = "pyproject-flake8" +version = "6.1.0" +description = "pyproject-flake8 (`pflake8`), a monkey patching wrapper to connect flake8 with pyproject.toml configuration" +optional = false +python-versions = ">=3.8.1" +files = [ + {file = "pyproject_flake8-6.1.0-py3-none-any.whl", hash = "sha256:86ea5559263c098e1aa4f866776aa2cf45362fd91a576b9fd8fbbbb55db12c4e"}, + {file = "pyproject_flake8-6.1.0.tar.gz", hash = "sha256:6da8e5a264395e0148bc11844c6fb50546f1fac83ac9210f7328664135f9e70f"}, +] + +[package.dependencies] +flake8 = "6.1.0" + +[[package]] +name = "pyreadline3" +version = "3.4.1" +description = "A python implementation of GNU readline." +optional = false +python-versions = "*" +files = [ + {file = "pyreadline3-3.4.1-py3-none-any.whl", hash = "sha256:b0efb6516fd4fb07b45949053826a62fa4cb353db5be2bbb4a7aa1fdd1e345fb"}, + {file = "pyreadline3-3.4.1.tar.gz", hash = "sha256:6f3d1f7b8a31ba32b73917cefc1f28cc660562f39aea8646d30bd6eff21f7bae"}, +] + +[[package]] +name = "pytest" +version = "7.4.4" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8"}, + {file = "pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=0.12,<2.0" + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "pytest-flake8" +version = "1.1.1" +description = "pytest plugin to check FLAKE8 requirements" +optional = false +python-versions = "*" +files = [ + {file = "pytest-flake8-1.1.1.tar.gz", hash = "sha256:ba4f243de3cb4c2486ed9e70752c80dd4b636f7ccb27d4eba763c35ed0cd316e"}, + {file = "pytest_flake8-1.1.1-py2.py3-none-any.whl", hash = "sha256:e0661a786f8cbf976c185f706fdaf5d6df0b1667c3bcff8e823ba263618627e7"}, +] + +[package.dependencies] +flake8 = ">=4.0" +pytest = ">=7.0" + +[[package]] +name = "pytest-xdist" +version = "3.6.1" +description = "pytest xdist plugin for distributed testing, most importantly across multiple CPUs" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pytest_xdist-3.6.1-py3-none-any.whl", hash = "sha256:9ed4adfb68a016610848639bb7e02c9352d5d9f03d04809919e2dafc3be4cca7"}, + {file = "pytest_xdist-3.6.1.tar.gz", hash = "sha256:ead156a4db231eec769737f57668ef58a2084a34b2e55c4a8fa20d861107300d"}, +] + +[package.dependencies] +execnet = ">=2.1" +pytest = ">=7.0.0" + +[package.extras] +psutil = ["psutil (>=3.0)"] +setproctitle = ["setproctitle"] +testing = ["filelock"] + +[[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 = "python-gitlab" +version = "3.15.0" +description = "Interact with GitLab API" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "python-gitlab-3.15.0.tar.gz", hash = "sha256:c9e65eb7612a9fbb8abf0339972eca7fd7a73d4da66c9b446ffe528930aff534"}, + {file = "python_gitlab-3.15.0-py3-none-any.whl", hash = "sha256:8f8d1c0d387f642eb1ac7bf5e8e0cd8b3dd49c6f34170cee3c7deb7d384611f3"}, +] + +[package.dependencies] +requests = ">=2.25.0" +requests-toolbelt = ">=0.10.1" + +[package.extras] +autocompletion = ["argcomplete (>=1.10.0,<3)"] +yaml = ["PyYaml (>=5.2)"] + +[[package]] +name = "python-semantic-release" +version = "7.34.6" +description = "Automatic Semantic Versioning for Python projects" +optional = false +python-versions = "*" +files = [ + {file = "python-semantic-release-7.34.6.tar.gz", hash = "sha256:e9b8fb788024ae9510a924136d573588415a16eeca31cc5240f2754a80a2e831"}, + {file = "python_semantic_release-7.34.6-py3-none-any.whl", hash = "sha256:7e3969ba4663d9b2087b02bf3ac140e202551377bf045c34e09bfe19753e19ab"}, +] + +[package.dependencies] +click = ">=7,<9" +click-log = ">=0.3,<1" +dotty-dict = ">=1.3.0,<2" +gitpython = ">=3.0.8,<4" +invoke = ">=1.4.1,<3" +packaging = "*" +python-gitlab = ">=2,<4" +requests = ">=2.25,<3" +semver = ">=2.10,<3" +tomlkit = ">=0.10,<1.0" +twine = ">=3,<4" +wheel = "*" + +[package.extras] +dev = ["black", "isort", "tox"] +docs = ["Jinja2 (==3.0.3)", "Sphinx (==1.8.6)"] +mypy = ["mypy", "types-requests"] +test = ["coverage (>=5,<6)", "mock (==1.3.0)", "pytest (>=7,<8)", "pytest-mock (>=2,<3)", "pytest-xdist (>=1,<2)", "responses (==0.13.3)"] + +[[package]] +name = "pytz" +version = "2024.1" +description = "World timezone definitions, modern and historical" +optional = false +python-versions = "*" +files = [ + {file = "pytz-2024.1-py2.py3-none-any.whl", hash = "sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319"}, + {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"}, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.2" +description = "A (partial) reimplementation of pywin32 using ctypes/cffi" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pywin32-ctypes-0.2.2.tar.gz", hash = "sha256:3426e063bdd5fd4df74a14fa3cf80a0b42845a87e1d1e81f6549f9daec593a60"}, + {file = "pywin32_ctypes-0.2.2-py3-none-any.whl", hash = "sha256:bf490a1a709baf35d688fe0ecf980ed4de11d2b3e37b51e5442587a75d9957e7"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.1" +description = "YAML parser and emitter for Python" +optional = false +python-versions = ">=3.6" +files = [ + {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, + {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, + {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, + {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, + {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, + {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, + {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, + {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, + {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, + {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, + {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, + {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, + {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, + {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, + {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, + {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, + {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, + {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, + {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, + {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, + {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, +] + +[[package]] +name = "readme-renderer" +version = "44.0" +description = "readme_renderer is a library for rendering readme descriptions for Warehouse" +optional = false +python-versions = ">=3.9" +files = [ + {file = "readme_renderer-44.0-py3-none-any.whl", hash = "sha256:2fbca89b81a08526aadf1357a8c2ae889ec05fb03f5da67f9769c9a592166151"}, + {file = "readme_renderer-44.0.tar.gz", hash = "sha256:8712034eabbfa6805cacf1402b4eeb2a73028f72d1166d6f5cb7f9c047c5d1e1"}, +] + +[package.dependencies] +docutils = ">=0.21.2" +nh3 = ">=0.2.14" +Pygments = ">=2.5.1" + +[package.extras] +md = ["cmarkgfm (>=0.8.0)"] + +[[package]] +name = "requests" +version = "2.32.3" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.8" +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "requests-toolbelt" +version = "1.0.0" +description = "A utility belt for advanced users of python-requests" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"}, + {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"}, +] + +[package.dependencies] +requests = ">=2.0.1,<3.0.0" + +[[package]] +name = "rfc3986" +version = "2.0.0" +description = "Validating URI References per RFC 3986" +optional = false +python-versions = ">=3.7" +files = [ + {file = "rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd"}, + {file = "rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c"}, +] + +[package.extras] +idna2008 = ["idna"] + +[[package]] +name = "secretstorage" +version = "3.3.3" +description = "Python bindings to FreeDesktop.org Secret Service API" +optional = false +python-versions = ">=3.6" +files = [ + {file = "SecretStorage-3.3.3-py3-none-any.whl", hash = "sha256:f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99"}, + {file = "SecretStorage-3.3.3.tar.gz", hash = "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77"}, +] + +[package.dependencies] +cryptography = ">=2.0" +jeepney = ">=0.6" + +[[package]] +name = "semver" +version = "2.13.0" +description = "Python helper for Semantic Versioning (http://semver.org/)" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "semver-2.13.0-py2.py3-none-any.whl", hash = "sha256:ced8b23dceb22134307c1b8abfa523da14198793d9787ac838e70e29e77458d4"}, + {file = "semver-2.13.0.tar.gz", hash = "sha256:fa0fe2722ee1c3f57eac478820c3a5ae2f624af8264cbdf9000c980ff7f75e3f"}, +] + +[[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 = "stack-data" +version = "0.6.3" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + +[[package]] +name = "sympy" +version = "1.13.0" +description = "Computer algebra system (CAS) in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "sympy-1.13.0-py3-none-any.whl", hash = "sha256:6b0b32a4673fb91bd3cac3b55406c8e01d53ae22780be467301cc452f6680c92"}, + {file = "sympy-1.13.0.tar.gz", hash = "sha256:3b6af8f4d008b9a1a6a4268b335b984b23835f26d1d60b0526ebc71d48a25f57"}, +] + +[package.dependencies] +mpmath = ">=1.1.0,<1.4" + +[package.extras] +dev = ["hypothesis (>=6.70.0)", "pytest (>=7.1.0)"] + +[[package]] +name = "tokenize-rt" +version = "5.2.0" +description = "A wrapper around the stdlib `tokenize` which roundtrips." +optional = false +python-versions = ">=3.8" +files = [ + {file = "tokenize_rt-5.2.0-py2.py3-none-any.whl", hash = "sha256:b79d41a65cfec71285433511b50271b05da3584a1da144a0752e9c621a285289"}, + {file = "tokenize_rt-5.2.0.tar.gz", hash = "sha256:9fe80f8a5c1edad2d3ede0f37481cc0cc1538a2f442c9c2f9e4feacd2792d054"}, +] + +[[package]] +name = "tomlkit" +version = "0.13.0" +description = "Style preserving TOML library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tomlkit-0.13.0-py3-none-any.whl", hash = "sha256:7075d3042d03b80f603482d69bf0c8f345c2b30e41699fd8883227f89972b264"}, + {file = "tomlkit-0.13.0.tar.gz", hash = "sha256:08ad192699734149f5b97b45f1f18dad7eb1b6d16bc72ad0c2335772650d7b72"}, +] + +[[package]] +name = "torch" +version = "2.2.2" +description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration" +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "torch-2.2.2-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:bc889d311a855dd2dfd164daf8cc903a6b7273a747189cebafdd89106e4ad585"}, + {file = "torch-2.2.2-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:15dffa4cc3261fa73d02f0ed25f5fa49ecc9e12bf1ae0a4c1e7a88bbfaad9030"}, + {file = "torch-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:11e8fe261233aeabd67696d6b993eeb0896faa175c6b41b9a6c9f0334bdad1c5"}, + {file = "torch-2.2.2-cp310-none-macosx_10_9_x86_64.whl", hash = "sha256:b2e2200b245bd9f263a0d41b6a2dab69c4aca635a01b30cca78064b0ef5b109e"}, + {file = "torch-2.2.2-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:877b3e6593b5e00b35bbe111b7057464e76a7dd186a287280d941b564b0563c2"}, + {file = "torch-2.2.2-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:ad4c03b786e074f46606f4151c0a1e3740268bcf29fbd2fdf6666d66341c1dcb"}, + {file = "torch-2.2.2-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:32827fa1fbe5da8851686256b4cd94cc7b11be962862c2293811c94eea9457bf"}, + {file = "torch-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:f9ef0a648310435511e76905f9b89612e45ef2c8b023bee294f5e6f7e73a3e7c"}, + {file = "torch-2.2.2-cp311-none-macosx_10_9_x86_64.whl", hash = "sha256:95b9b44f3bcebd8b6cd8d37ec802048c872d9c567ba52c894bba90863a439059"}, + {file = "torch-2.2.2-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:49aa4126ede714c5aeef7ae92969b4b0bbe67f19665106463c39f22e0a1860d1"}, + {file = "torch-2.2.2-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:cf12cdb66c9c940227ad647bc9cf5dba7e8640772ae10dfe7569a0c1e2a28aca"}, + {file = "torch-2.2.2-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:89ddac2a8c1fb6569b90890955de0c34e1724f87431cacff4c1979b5f769203c"}, + {file = "torch-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:451331406b760f4b1ab298ddd536486ab3cfb1312614cfe0532133535be60bea"}, + {file = "torch-2.2.2-cp312-none-macosx_10_9_x86_64.whl", hash = "sha256:eb4d6e9d3663e26cd27dc3ad266b34445a16b54908e74725adb241aa56987533"}, + {file = "torch-2.2.2-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:bf9558da7d2bf7463390b3b2a61a6a3dbb0b45b161ee1dd5ec640bf579d479fc"}, + {file = "torch-2.2.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:cd2bf7697c9e95fb5d97cc1d525486d8cf11a084c6af1345c2c2c22a6b0029d0"}, + {file = "torch-2.2.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:b421448d194496e1114d87a8b8d6506bce949544e513742b097e2ab8f7efef32"}, + {file = "torch-2.2.2-cp38-cp38-win_amd64.whl", hash = "sha256:3dbcd563a9b792161640c0cffe17e3270d85e8f4243b1f1ed19cca43d28d235b"}, + {file = "torch-2.2.2-cp38-none-macosx_10_9_x86_64.whl", hash = "sha256:31f4310210e7dda49f1fb52b0ec9e59382cfcb938693f6d5378f25b43d7c1d29"}, + {file = "torch-2.2.2-cp38-none-macosx_11_0_arm64.whl", hash = "sha256:c795feb7e8ce2e0ef63f75f8e1ab52e7fd5e1a4d7d0c31367ade1e3de35c9e95"}, + {file = "torch-2.2.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:a6e5770d68158d07456bfcb5318b173886f579fdfbf747543901ce718ea94782"}, + {file = "torch-2.2.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:67dcd726edff108e2cd6c51ff0e416fd260c869904de95750e80051358680d24"}, + {file = "torch-2.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:539d5ef6c4ce15bd3bd47a7b4a6e7c10d49d4d21c0baaa87c7d2ef8698632dfb"}, + {file = "torch-2.2.2-cp39-none-macosx_10_9_x86_64.whl", hash = "sha256:dff696de90d6f6d1e8200e9892861fd4677306d0ef604cb18f2134186f719f82"}, + {file = "torch-2.2.2-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:3a4dd910663fd7a124c056c878a52c2b0be4a5a424188058fe97109d4436ee42"}, +] + +[package.dependencies] +filelock = "*" +fsspec = "*" +jinja2 = "*" +networkx = "*" +nvidia-cublas-cu12 = {version = "12.1.3.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cuda-cupti-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cuda-nvrtc-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cuda-runtime-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cudnn-cu12 = {version = "8.9.2.26", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cufft-cu12 = {version = "11.0.2.54", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-curand-cu12 = {version = "10.3.2.106", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cusolver-cu12 = {version = "11.4.5.107", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-cusparse-cu12 = {version = "12.1.0.106", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-nccl-cu12 = {version = "2.19.3", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +nvidia-nvtx-cu12 = {version = "12.1.105", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} +sympy = "*" +triton = {version = "2.2.0", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\" and python_version < \"3.12\""} +typing-extensions = ">=4.8.0" + +[package.extras] +opt-einsum = ["opt-einsum (>=3.3)"] +optree = ["optree (>=0.9.1)"] + +[[package]] +name = "torchvision" +version = "0.17.2" +description = "image and video datasets and models for torch deep learning" +optional = false +python-versions = ">=3.8" +files = [ + {file = "torchvision-0.17.2-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:1f2910fe3c21ad6875b2720d46fad835b2e4b336e9553d31ca364d24c90b1d4f"}, + {file = "torchvision-0.17.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ecc1c503fa8a54fbab777e06a7c228032b8ab78efebf35b28bc8f22f544f51f1"}, + {file = "torchvision-0.17.2-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:f400145fc108833e7c2fc28486a04989ca742146d7a2a2cc48878ebbb40cdbbd"}, + {file = "torchvision-0.17.2-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:e9e4bed404af33dfc92eecc2b513d21ddc4c242a7fd8708b3b09d3a26aa6f444"}, + {file = "torchvision-0.17.2-cp310-cp310-win_amd64.whl", hash = "sha256:ba2e62f233eab3d42b648c122a3a29c47cc108ca314dfd5cbb59cd3a143fd623"}, + {file = "torchvision-0.17.2-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:9b83e55ee7d0a1704f52b9c0ac87388e7a6d1d98a6bde7b0b35f9ab54d7bda54"}, + {file = "torchvision-0.17.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e031004a1bc432c980a7bd642f6c189a3efc316e423fc30b5569837166a4e28d"}, + {file = "torchvision-0.17.2-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:3bbc24b7713e8f22766992562547d8b4b10001208d372fe599255af84bfd1a69"}, + {file = "torchvision-0.17.2-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:833fd2e4216ced924c8aca0525733fe727f9a1af66dfad7c5be7257e97c39678"}, + {file = "torchvision-0.17.2-cp311-cp311-win_amd64.whl", hash = "sha256:6835897df852fad1015e6a106c167c83848114cbcc7d86112384a973404e4431"}, + {file = "torchvision-0.17.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:14fd1d4a033c325bdba2d03a69c3450cab6d3a625f85cc375781d9237ca5d04d"}, + {file = "torchvision-0.17.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9c3acbebbe379af112b62b535820174277b1f3eed30df264a4e458d58ee4e5b2"}, + {file = "torchvision-0.17.2-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:77d680adf6ce367166a186d2c7fda3a73807ab9a03b2c31a03fa8812c8c5335b"}, + {file = "torchvision-0.17.2-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:f1c9ab3152cfb27f83aca072cac93a3a4c4e4ab0261cf0f2d516b9868a4e96f3"}, + {file = "torchvision-0.17.2-cp312-cp312-win_amd64.whl", hash = "sha256:3f784381419f3ed3f2ec2aa42fb4aeec5bf4135e298d1631e41c926e6f1a0dff"}, + {file = "torchvision-0.17.2-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:b83aac8d78f48981146d582168d75b6c947cfb0a7693f76e219f1926f6e595a3"}, + {file = "torchvision-0.17.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1ece40557e122d79975860a005aa7e2a9e2e6c350a03e78a00ec1450083312fd"}, + {file = "torchvision-0.17.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:32dbeba3987e20f2dc1bce8d1504139fff582898346dfe8ad98d649f97ca78fa"}, + {file = "torchvision-0.17.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:35ba5c1600c3203549d2316422a659bd20c0cfda1b6085eec94fb9f35f55ca43"}, + {file = "torchvision-0.17.2-cp38-cp38-win_amd64.whl", hash = "sha256:2f69570f50b1d195e51bc03feffb7b7728207bc36efcfb1f0813712b2379d881"}, + {file = "torchvision-0.17.2-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:4868bbfa55758c8107e69a0e7dd5e77b89056035cd38b767ad5b98cdb71c0f0d"}, + {file = "torchvision-0.17.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:efd6d0dd0668e15d01a2cffadc74068433b32cbcf5692e0c4aa15fc5cb250ce7"}, + {file = "torchvision-0.17.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:7dc85b397f6c6d9ef12716ce0d6e11ac2b803f5cccff6fe3966db248e7774478"}, + {file = "torchvision-0.17.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:d506854c5acd69b20a8b6641f01fe841685a21c5406b56813184f1c9fc94279e"}, + {file = "torchvision-0.17.2-cp39-cp39-win_amd64.whl", hash = "sha256:067095e87a020a7a251ac1d38483aa591c5ccb81e815527c54db88a982fc9267"}, +] + +[package.dependencies] +numpy = "*" +pillow = ">=5.3.0,<8.3.dev0 || >=8.4.dev0" +torch = "2.2.2" + +[package.extras] +scipy = ["scipy"] + +[[package]] +name = "tqdm" +version = "4.66.4" +description = "Fast, Extensible Progress Meter" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tqdm-4.66.4-py3-none-any.whl", hash = "sha256:b75ca56b413b030bc3f00af51fd2c1a1a5eac6a0c1cca83cbb37a5c52abce644"}, + {file = "tqdm-4.66.4.tar.gz", hash = "sha256:e4d936c9de8727928f3be6079590e97d9abfe8d39a590be678eb5919ffc186bb"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[package.extras] +dev = ["pytest (>=6)", "pytest-cov", "pytest-timeout", "pytest-xdist"] +notebook = ["ipywidgets (>=6)"] +slack = ["slack-sdk"] +telegram = ["requests"] + +[[package]] +name = "traitlets" +version = "5.14.3" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.8" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] + +[[package]] +name = "triton" +version = "2.2.0" +description = "A language and compiler for custom Deep Learning operations" +optional = false +python-versions = "*" +files = [ + {file = "triton-2.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2294514340cfe4e8f4f9e5c66c702744c4a117d25e618bd08469d0bfed1e2e5"}, + {file = "triton-2.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da58a152bddb62cafa9a857dd2bc1f886dbf9f9c90a2b5da82157cd2b34392b0"}, + {file = "triton-2.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af58716e721460a61886668b205963dc4d1e4ac20508cc3f623aef0d70283d5"}, + {file = "triton-2.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8fe46d3ab94a8103e291bd44c741cc294b91d1d81c1a2888254cbf7ff846dab"}, + {file = "triton-2.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8ce26093e539d727e7cf6f6f0d932b1ab0574dc02567e684377630d86723ace"}, + {file = "triton-2.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:227cc6f357c5efcb357f3867ac2a8e7ecea2298cd4606a8ba1e931d1d5a947df"}, +] + +[package.dependencies] +filelock = "*" + +[package.extras] +build = ["cmake (>=3.20)", "lit"] +tests = ["autopep8", "flake8", "isort", "numpy", "pytest", "scipy (>=1.7.1)", "torch"] +tutorials = ["matplotlib", "pandas", "tabulate", "torch"] + +[[package]] +name = "twine" +version = "3.8.0" +description = "Collection of utilities for publishing packages on PyPI" +optional = false +python-versions = ">=3.6" +files = [ + {file = "twine-3.8.0-py3-none-any.whl", hash = "sha256:d0550fca9dc19f3d5e8eadfce0c227294df0a2a951251a4385797c8a6198b7c8"}, + {file = "twine-3.8.0.tar.gz", hash = "sha256:8efa52658e0ae770686a13b675569328f1fba9837e5de1867bfe5f46a9aefe19"}, +] + +[package.dependencies] +colorama = ">=0.4.3" +importlib-metadata = ">=3.6" +keyring = ">=15.1" +pkginfo = ">=1.8.1" +readme-renderer = ">=21.0" +requests = ">=2.20" +requests-toolbelt = ">=0.8.0,<0.9.0 || >0.9.0" +rfc3986 = ">=1.4.0" +tqdm = ">=4.14" +urllib3 = ">=1.26.0" + +[[package]] +name = "types-requests" +version = "2.32.0.20240712" +description = "Typing stubs for requests" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-requests-2.32.0.20240712.tar.gz", hash = "sha256:90c079ff05e549f6bf50e02e910210b98b8ff1ebdd18e19c873cd237737c1358"}, + {file = "types_requests-2.32.0.20240712-py3-none-any.whl", hash = "sha256:f754283e152c752e46e70942fa2a146b5bc70393522257bb85bd1ef7e019dcc3"}, +] + +[package.dependencies] +urllib3 = ">=2" + +[[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.1" +description = "Provider of IANA time zone data" +optional = false +python-versions = ">=2" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "urllib3" +version = "2.2.2" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, + {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "virtualenv" +version = "20.26.3" +description = "Virtual Python Environment builder" +optional = false +python-versions = ">=3.7" +files = [ + {file = "virtualenv-20.26.3-py3-none-any.whl", hash = "sha256:8cc4a31139e796e9a7de2cd5cf2489de1217193116a8fd42328f1bd65f434589"}, + {file = "virtualenv-20.26.3.tar.gz", hash = "sha256:4c43a2a236279d9ea36a0d76f98d84bd6ca94ac4e0f4a3b9d46d05e10fea542a"}, +] + +[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 = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "wheel" +version = "0.43.0" +description = "A built-package format for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "wheel-0.43.0-py3-none-any.whl", hash = "sha256:55c570405f142630c6b9f72fe09d9b67cf1477fcf543ae5b8dcb1f5b7377da81"}, + {file = "wheel-0.43.0.tar.gz", hash = "sha256:465ef92c69fa5c5da2d1cf8ac40559a8c940886afcef87dcf14b9470862f1d85"}, +] + +[package.extras] +test = ["pytest (>=6.0.0)", "setuptools (>=65)"] + +[[package]] +name = "wrapt" +version = "1.16.0" +description = "Module for decorators, wrappers and monkey patching." +optional = false +python-versions = ">=3.6" +files = [ + {file = "wrapt-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ffa565331890b90056c01db69c0fe634a776f8019c143a5ae265f9c6bc4bd6d4"}, + {file = "wrapt-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e4fdb9275308292e880dcbeb12546df7f3e0f96c6b41197e0cf37d2826359020"}, + {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb2dee3874a500de01c93d5c71415fcaef1d858370d405824783e7a8ef5db440"}, + {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a88e6010048489cda82b1326889ec075a8c856c2e6a256072b28eaee3ccf487"}, + {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac83a914ebaf589b69f7d0a1277602ff494e21f4c2f743313414378f8f50a4cf"}, + {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:73aa7d98215d39b8455f103de64391cb79dfcad601701a3aa0dddacf74911d72"}, + {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:807cc8543a477ab7422f1120a217054f958a66ef7314f76dd9e77d3f02cdccd0"}, + {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bf5703fdeb350e36885f2875d853ce13172ae281c56e509f4e6eca049bdfb136"}, + {file = "wrapt-1.16.0-cp310-cp310-win32.whl", hash = "sha256:f6b2d0c6703c988d334f297aa5df18c45e97b0af3679bb75059e0e0bd8b1069d"}, + {file = "wrapt-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:decbfa2f618fa8ed81c95ee18a387ff973143c656ef800c9f24fb7e9c16054e2"}, + {file = "wrapt-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a5db485fe2de4403f13fafdc231b0dbae5eca4359232d2efc79025527375b09"}, + {file = "wrapt-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:75ea7d0ee2a15733684badb16de6794894ed9c55aa5e9903260922f0482e687d"}, + {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a452f9ca3e3267cd4d0fcf2edd0d035b1934ac2bd7e0e57ac91ad6b95c0c6389"}, + {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43aa59eadec7890d9958748db829df269f0368521ba6dc68cc172d5d03ed8060"}, + {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72554a23c78a8e7aa02abbd699d129eead8b147a23c56e08d08dfc29cfdddca1"}, + {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d2efee35b4b0a347e0d99d28e884dfd82797852d62fcd7ebdeee26f3ceb72cf3"}, + {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:6dcfcffe73710be01d90cae08c3e548d90932d37b39ef83969ae135d36ef3956"}, + {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:eb6e651000a19c96f452c85132811d25e9264d836951022d6e81df2fff38337d"}, + {file = "wrapt-1.16.0-cp311-cp311-win32.whl", hash = "sha256:66027d667efe95cc4fa945af59f92c5a02c6f5bb6012bff9e60542c74c75c362"}, + {file = "wrapt-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:aefbc4cb0a54f91af643660a0a150ce2c090d3652cf4052a5397fb2de549cd89"}, + {file = "wrapt-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5eb404d89131ec9b4f748fa5cfb5346802e5ee8836f57d516576e61f304f3b7b"}, + {file = "wrapt-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9090c9e676d5236a6948330e83cb89969f433b1943a558968f659ead07cb3b36"}, + {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94265b00870aa407bd0cbcfd536f17ecde43b94fb8d228560a1e9d3041462d73"}, + {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2058f813d4f2b5e3a9eb2eb3faf8f1d99b81c3e51aeda4b168406443e8ba809"}, + {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b5e1f498a8ca1858a1cdbffb023bfd954da4e3fa2c0cb5853d40014557248b"}, + {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:14d7dc606219cdd7405133c713f2c218d4252f2a469003f8c46bb92d5d095d81"}, + {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:49aac49dc4782cb04f58986e81ea0b4768e4ff197b57324dcbd7699c5dfb40b9"}, + {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:418abb18146475c310d7a6dc71143d6f7adec5b004ac9ce08dc7a34e2babdc5c"}, + {file = "wrapt-1.16.0-cp312-cp312-win32.whl", hash = "sha256:685f568fa5e627e93f3b52fda002c7ed2fa1800b50ce51f6ed1d572d8ab3e7fc"}, + {file = "wrapt-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:dcdba5c86e368442528f7060039eda390cc4091bfd1dca41e8046af7c910dda8"}, + {file = "wrapt-1.16.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:d462f28826f4657968ae51d2181a074dfe03c200d6131690b7d65d55b0f360f8"}, + {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a33a747400b94b6d6b8a165e4480264a64a78c8a4c734b62136062e9a248dd39"}, + {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3646eefa23daeba62643a58aac816945cadc0afaf21800a1421eeba5f6cfb9c"}, + {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ebf019be5c09d400cf7b024aa52b1f3aeebeff51550d007e92c3c1c4afc2a40"}, + {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:0d2691979e93d06a95a26257adb7bfd0c93818e89b1406f5a28f36e0d8c1e1fc"}, + {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:1acd723ee2a8826f3d53910255643e33673e1d11db84ce5880675954183ec47e"}, + {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:bc57efac2da352a51cc4658878a68d2b1b67dbe9d33c36cb826ca449d80a8465"}, + {file = "wrapt-1.16.0-cp36-cp36m-win32.whl", hash = "sha256:da4813f751142436b075ed7aa012a8778aa43a99f7b36afe9b742d3ed8bdc95e"}, + {file = "wrapt-1.16.0-cp36-cp36m-win_amd64.whl", hash = "sha256:6f6eac2360f2d543cc875a0e5efd413b6cbd483cb3ad7ebf888884a6e0d2e966"}, + {file = "wrapt-1.16.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a0ea261ce52b5952bf669684a251a66df239ec6d441ccb59ec7afa882265d593"}, + {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bd2d7ff69a2cac767fbf7a2b206add2e9a210e57947dd7ce03e25d03d2de292"}, + {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9159485323798c8dc530a224bd3ffcf76659319ccc7bbd52e01e73bd0241a0c5"}, + {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a86373cf37cd7764f2201b76496aba58a52e76dedfaa698ef9e9688bfd9e41cf"}, + {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:73870c364c11f03ed072dda68ff7aea6d2a3a5c3fe250d917a429c7432e15228"}, + {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b935ae30c6e7400022b50f8d359c03ed233d45b725cfdd299462f41ee5ffba6f"}, + {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:db98ad84a55eb09b3c32a96c576476777e87c520a34e2519d3e59c44710c002c"}, + {file = "wrapt-1.16.0-cp37-cp37m-win32.whl", hash = "sha256:9153ed35fc5e4fa3b2fe97bddaa7cbec0ed22412b85bcdaf54aeba92ea37428c"}, + {file = "wrapt-1.16.0-cp37-cp37m-win_amd64.whl", hash = "sha256:66dfbaa7cfa3eb707bbfcd46dab2bc6207b005cbc9caa2199bcbc81d95071a00"}, + {file = "wrapt-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1dd50a2696ff89f57bd8847647a1c363b687d3d796dc30d4dd4a9d1689a706f0"}, + {file = "wrapt-1.16.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:44a2754372e32ab315734c6c73b24351d06e77ffff6ae27d2ecf14cf3d229202"}, + {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e9723528b9f787dc59168369e42ae1c3b0d3fadb2f1a71de14531d321ee05b0"}, + {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbed418ba5c3dce92619656802cc5355cb679e58d0d89b50f116e4a9d5a9603e"}, + {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:941988b89b4fd6b41c3f0bfb20e92bd23746579736b7343283297c4c8cbae68f"}, + {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6a42cd0cfa8ffc1915aef79cb4284f6383d8a3e9dcca70c445dcfdd639d51267"}, + {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1ca9b6085e4f866bd584fb135a041bfc32cab916e69f714a7d1d397f8c4891ca"}, + {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d5e49454f19ef621089e204f862388d29e6e8d8b162efce05208913dde5b9ad6"}, + {file = "wrapt-1.16.0-cp38-cp38-win32.whl", hash = "sha256:c31f72b1b6624c9d863fc095da460802f43a7c6868c5dda140f51da24fd47d7b"}, + {file = "wrapt-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:490b0ee15c1a55be9c1bd8609b8cecd60e325f0575fc98f50058eae366e01f41"}, + {file = "wrapt-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9b201ae332c3637a42f02d1045e1d0cccfdc41f1f2f801dafbaa7e9b4797bfc2"}, + {file = "wrapt-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2076fad65c6736184e77d7d4729b63a6d1ae0b70da4868adeec40989858eb3fb"}, + {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5cd603b575ebceca7da5a3a251e69561bec509e0b46e4993e1cac402b7247b8"}, + {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b47cfad9e9bbbed2339081f4e346c93ecd7ab504299403320bf85f7f85c7d46c"}, + {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8212564d49c50eb4565e502814f694e240c55551a5f1bc841d4fcaabb0a9b8a"}, + {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:5f15814a33e42b04e3de432e573aa557f9f0f56458745c2074952f564c50e664"}, + {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db2e408d983b0e61e238cf579c09ef7020560441906ca990fe8412153e3b291f"}, + {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:edfad1d29c73f9b863ebe7082ae9321374ccb10879eeabc84ba3b69f2579d537"}, + {file = "wrapt-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed867c42c268f876097248e05b6117a65bcd1e63b779e916fe2e33cd6fd0d3c3"}, + {file = "wrapt-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:eb1b046be06b0fce7249f1d025cd359b4b80fc1c3e24ad9eca33e0dcdb2e4a35"}, + {file = "wrapt-1.16.0-py3-none-any.whl", hash = "sha256:6906c4100a8fcbf2fa735f6059214bb13b97f75b1a61777fcf6432121ef12ef1"}, + {file = "wrapt-1.16.0.tar.gz", hash = "sha256:5f370f952971e7d17c7d1ead40e49f32345a7f7a5373571ef44d800d06b1899d"}, +] + +[[package]] +name = "zipp" +version = "3.19.2" +description = "Backport of pathlib-compatible object wrapper for zip files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "zipp-3.19.2-py3-none-any.whl", hash = "sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c"}, + {file = "zipp-3.19.2.tar.gz", hash = "sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19"}, +] + +[package.extras] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy", "pytest-ruff (>=0.2.1)"] + +[metadata] +lock-version = "2.0" +python-versions = "^3.11" +content-hash = "09f8c5bee30d68c7ff920530904478fc0571d8ab12f6808be5bfc149c180bc7d" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..a877eaa --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,66 @@ +[tool.poetry] +name = "docling-ibm-models" +version = "0.2.0" +description = "This package contains the AI models used by the Docling PDF conversion package" +authors = ["Nikos Livathinos ", "Maxim Lysak ", "Ahmed Nassar ", "Christoph Auer ", "Michele Dolfi ", "Peter Staar "] +license = "MIT" +readme = "README.md" +keywords= ["docling", "convert", "document", "pdf", "layout model", "segmentation", "table structure", "table former"] +classifiers = [ + "License :: OSI Approved :: MIT License", + "Operating System :: MacOS :: MacOS X", + "Operating System :: POSIX :: Linux", + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Programming Language :: Python :: 3" +] +packages = [ + { include = "docling_ibm_models" }, +] + +[tool.poetry.dependencies] +python = "^3.11" +torch = "2.2.2" +torchvision = "0.17.2" +onnxruntime = "^1.16.2" +numpy = "^1.24.4" +lxml = "^4.9.1" +jsonlines = "^3.1.0" +Pillow = "^10.0.0" +tqdm = "^4.64.0" +apted = "^1.0.3" +Distance = "^0.1.3" +mean_average_precision = "^2021.4.26.0" +opencv-python-headless = { version = "^4.9.0.80", markers = 'sys_platform=="linux"'} +opencv-python = { version = "^4.9.0.80", markers = 'sys_platform!="linux"'} + +[tool.poetry.dev-dependencies] +black = {extras = ["jupyter"], version = "^24.4.2"} +pytest = "^7.2.2" +pre-commit = "^3.7.1" +mypy = "^1.10.1" +isort = "^5.10.1" +python-semantic-release = "^7.32.2" +flake8 = "^6.0.0" +pyproject-flake8 = "^6.0.0" +pytest-xdist = "^3.3.1" +pytest-flake8 = "^1.1.0" +types-requests = "^2.31.0.2" +flake8-pyproject = "^1.2.3" +pylint = "^2.17.5" + +[build-system] +requires = ["poetry-core>=1.0.0"] +build-backend = "poetry.core.masonry.api" + +[tool.black] +line-length = 88 +target-version = ["py311"] +include = '\.pyi?$' + +[tool.isort] +profile = "black" +line_length = 88 +py_version=311 diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_common.py b/tests/test_common.py new file mode 100644 index 0000000..7f02f76 --- /dev/null +++ b/tests/test_common.py @@ -0,0 +1,72 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import docling_ibm_models.tableformer.common as c + +test_config_a = { + "base_dir": "./tests/test_data/", + "curr_dir": "./tests/test_data/test_common/", + "data_top_dir": "./tests/test_data/", + "dataset": { + "name": ["PhysRevB"], + "limit": 10, + "split": {"test": 0.2, "train": 0.5, "evaluate": 0.3}, + }, + "features": { + "name": "Data2Features03b", + "parameters": { + "normalize_features": True, + "normalize_features_method": "Z-Score", + }, + }, +} + + +test_config_b = {"preparation": {"max_tag_len": 300}, "model": {"seq_len": 30}} + +test_config_c = {"preparation": {"max_tag_len": 300}, "model": {"seq_len": 302}} + +test_config_d = {"preparation": {"max_tag_len": 300}, "model": {"seq_len": 303}} + + +def test_safe_get_parameters(): + val = c.safe_get_parameter(None, None, 10) + assert val == 10, "Failed with null objects" + + index_path = ["features", "parameters", "normalize_features_method"] + val = c.safe_get_parameter(test_config_a, index_path, None) + assert val == "Z-Score", "Cannot find existing parameter" + + index_path = ["features", "parameters", "wrong"] + val = c.safe_get_parameter(test_config_a, index_path, "hello") + assert val == "hello", "Default value should be here" + + index_path = ["features", "wrong", "normalize_features_method"] + val = c.safe_get_parameter(test_config_a, index_path, 10) + assert val == 10, "Default value should be here" + + index_path = ["model", "parameters", "normalize_features_method"] + val = c.safe_get_parameter(test_config_a, index_path, "hello") + assert val == "hello", "Default value should be here" + + # Test exception throwing + exRaised = False + try: + index_path = ["missing"] + val = c.safe_get_parameter(test_config_a, index_path, required=True) + except ValueError: + exRaised = True + assert exRaised, "Exception should had been raised here" + + +def test_config_validation(): + configs = [test_config_b, test_config_c, test_config_d] + + for i, config in enumerate(configs): + try: + val = c.validate_config(config) + if i == 0 or i == 1: + assert val, "Valid configuration didn't pass the validation test" + except AssertionError: + assert i == 2, "Configuration validation error" diff --git a/tests/test_data/model_artifacts/put_model_check_here.txt b/tests/test_data/model_artifacts/put_model_check_here.txt new file mode 100644 index 0000000..c6a89df --- /dev/null +++ b/tests/test_data/model_artifacts/put_model_check_here.txt @@ -0,0 +1 @@ +Put model check: "otslp_all_fast_clean.check" in this directory \ No newline at end of file diff --git a/tests/test_data/samples/ADS.2007.page_123.png b/tests/test_data/samples/ADS.2007.page_123.png new file mode 100644 index 0000000000000000000000000000000000000000..b250d934cc3105645d461129aaa2eceecf4478cc GIT binary patch literal 397878 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

VX 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

%F%zwi{QXQBX61w2 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

L&Rddi+lKG=8Xi zmj$UcasL~``yamG^l$#bZ8lajhMK1T&1d_ce6qmk$20`mV%iFl|LO06z5pBlhWOxG z!~aQRT#p0L>I)9bJ(7n1zX&t{oJ)Sd&D7>4$;#60xV)DS+yC0nn)+e%EDQMG9(s9c zbiZu4ZAX=%`X0@do&kKT%Xz(GWEq6CWKYzo(nt6$gT-7?awG}n2|!m@;THAuTD~YL zdH@j98W40;%HDx|1)Mx*-2ews)$wHE(+4Jpt(gp_u_J1I_TmVm<{tu#fr;=0hP$uA z06ouxclR5hiP9_vj2Z?en0dNSwP zl@`e`gts_0B7%7@s&G}RT-iNJYNSi{B!}rOf~^|R{4+D)iIy!>(=;~1P1~OSx(ob# zVDd^;=Mxp}v7-7=YeAgQB3IPpEzoLoh~axGX#?g9iFrr;dri&Iz8Kd66C!>hxd9T) zd=)hvR<6_f*}QD(Dx3z}MY`6laO$5Mw$MljJb(SnTIh7V{#3Q>rI(?a_XI-o#SmuL zXg2UH3-&}ED#gfUF*)34z z3U6GuCCdYGlbpfF^qqrKN~NMOV7StxD0S7%`{^2VGmc2d{UuT0 zr&_9vZ~`zw8p4xfDX5|NK+<3S)hKtkKPwDihUnT5+2Rn<== zg)I*i4TR}2IeS+-FLehntn5S1{js@2&JB<3ow1u6CpF));_~MWmHA_3r*=-j20~>C zi>=DJe^SRi{^R@N5m&?dO_xD=)w=mx=R;B2vzKdQ6YAiv*eaJ-nZVQ0=arFD8HYs>i?)43$?(|g^~T9y6ehO5}O3e4w-HHykeEY4b`*P7l`#w5V8$=>lK z8RsFPXHifIL!HL!>0&ZtUaX>u$5h||46|4Bd0yF2-5X0o;oGAJgCdwx{H$3f0&SA) zSg7Z98N_`$r?mEA(U0bTb8|h7@!3h%FvV;-AOa`_xTit>x6O3`WVgVZU=t~0Z{cI)ypVbuU;K~lkmD8Wg#RU%do&pkJ1(|3p1PsWL@hYD0MP5@ zU>6+Q((fQ&Aas&#I28zp}k@{dLQhUrBT2X}iltzL>QBrkbTib}fJIYdR|)3#E~T4m0f z2E!XK_IqO^2h;hU-qcuY#kE(tZTS}VvlYn}%Ll-evyH0!KeY3$FkZlG=;_6|xKK0M z-1WNq-U8<3)YkVJGy{OuyGM}=pi;x{OnN?^=M8GkPk^@XsQ9$z`E1_Y!yb^?J_4h% zofMs);>7R{i^o$L^SNZ`=fag}x7GpBZUj(rD*rL-g`-9rI$()e=Xu;oczbT0)k{un znrt%km0hF+aX=&$YKQODq3$ZP(0f~ViXQi?KgzwsC&rl0C%JdstFKhvnp*p|FfK;B&(Wv&Uzp*5dO+Ae2>!>J<+>rZidT8zgE zs~Y~se%o_Iq`Br~J1)O3Fvf2U&-3gMXd5c7wY%?UE#f-w#J#=ZqZnS_Gu;2U_+i$>Hhx_4 zx*l)yT2Lc5KD`Dl<&-LUbc)sIWqM?fx=EQ8=td@uwr_l|I~u9j@T{<2^tf*1H_g_p zIUB49S}HBhS}<237LBw6ymXy8Xh+p~xAC3I^_8>jTrQb_matQo`~BtmLpfPIO!5U$ zfS~pF?*mQ(aBp1!9di2C1EPC}!C!B{tHU$r1Ma(7+K!tUVA2O# z>quF7>vlBv#N_pT*ZZ1G3otyBM?1i=+;gRI!PpCUlt4Dm011B@pa)PlIc*E+_U~^s zgR9mHQ4-*>XVu%$of?lPT`&Ewz-Uj`1*~4$#wEiuw__}o@{Co|BU2OfI7$Axy-gSP zaqq$8hUo!pwZ(FD7qz9=fmW5*;;(Sd3LZUS|ub(XXz> z*$2iXo+WELNaVomYRT***}Btxq&|R1q&;^G_Wlfcr-xYpUB$dMKw21%(yno2$nCag zIJ3^WSn80cKK=xTGm>Tbco<5xbyleD-QH0;+e;O7ssBMA4*3cD5qtAohVTOrp~p2o z05tCerUj~@&#%>1&=G70tx?`0oK`d1t%8~6JABMJTwQgXTr;{@cXjRUbJSYa_0nf8&o=kmD|@9% z#ZL))At$bEL#=ptfWcYECm`$BiOl+wXR9`-SoiJr!cT9dM$8;o+uT35L3mcuLL%eTCeNyR6nae7yM3+XPlbZ7>HP^%uJE!BG zv|i#Gq#3|7!2e=oWXNcD)6G51X$&5(?fPM2DXinVOwTg0UA*8r zA6HBGh#l|WwfDFRi*)s6(gCdPj@=@A@BOFhch-ulGu%?TweaiHFj}X%C3&?*&MpMl zWOP|Bp2$2&lQrUvdl7Y#0i6PT#*}m(}=)u?pO+D=*!&PcpiCq_D2oeyT}kDDy7w z<0@a1E2|e5xzJ1dQXDv4^SKjeA{h%l0r8@o5Aqu!cniLfG@>?VG76}kW75ak!2&(* zN7S`jdM05UI@qw(J>2lgx2@SHw{S19)3=?V@8O!WEQI)Ku9^*T9Ydq-4kLXf2QHSYnr(TL)FdM5XgcH>skn{s&7~z(XyjGf z^P}vDZ2q)#PKRe<&XZCwJ&fS*qW6Yy?0aX(e_>e$er3LxE~HLPT%R0 zpEtzXtCFY#AW<4d%3FqT7wS-G+R(DNkFFSEYr{`pyikpCMhqxbPW&NnDEY#$gz5P> z^cug?sFX-|A9(J;ihibREMh)p_!@&mZ<(+0RC_c>t3A+UVm6sov$o+?1w%w_(-MxZ zZ!V4W`^*QI(eLr_wW!62Z!MHTk@95`7<4wv?yRXeALlB+{&j)#)uhMW!Cyf#;}#!F zZjbAD^K-5Y>9FsJ^7c2XUG zwyxu*HMl#k@%(so;2Noy(oNd(AKNLk8-NunNhK~*U#7R5!R7pAAgAnG|1_B_)*i+R zt1XU*rGg7lYFtgavNMQf)mykCgXIcyCAEk!r#rR9cq!Zd5$lt3DMPOB*f4Wwz+DiR zBOf@YC~7}RHaGD~PM=81cER*lMN(Zk?rl1KwifmsF)FYu|D?KbfAhHCy{7`%87t?I zSqAV-g~M<+Jatp0mYy0l;WD@lK41O9tFXT+jdHOdm(L&fa;Mg1?B@hD z^UcRI)Ve`_WeTOs353Ywlsjc{W-f^WhN%qD>w0N@spB}B;n?Ri?fj%QtK=oVQRfbj z1XN+?Ax?7nk2L3e9;-sz^0mpIzwB;d z2f1^keIb$VYozzY7Sy+`Q3~QukGxz6=FeVSL|xy^bboqoQ-__=4H#+9HjKJi(6=v(MaHKJ>zj_w;8mZ=i_S zv$`)NC4SX2aCOnIuc&2SmZ!uwZKdlt?%XR}gi!JtUi+^>*Mg!W49;G+!tpa6`X>sIkFAr8 zfeRKMWN%(sFtxhP&=%2JK)|t<%k+jvy?7h`;)o>4i_#F2<^EdqO zyi&1|RCawvss23_03)mgCZ>Dx;XDB+6pf1dTY1TgDiZDa60vt&o=&YCquO*9Ecb*9 zhPN3>+4bL7qpqU1G-|t7mSYKw&prl=qost7b5bd@47C;M(#R>0j4Zt6{=5q+AE~ZJ z%er_Vr4CVCMB>!w%)y)*nFmr%i$&G>sGJlFW8GJK8|!yRfScbB!}pKacT$aWuX^WT z{RtXK+1_J8eIb)jsoF{7@}f&^*+YBvrOS-@cjURuR(4-pg=@gMZ?aS3R}HIeWkNl? zpJ!O{Ua=;-GbkUIOYYs_B_idM107;(%3@UNYx02F=SgvxMZfVC3b_xdLs5@S_FJf; z`lD}9>pw*&&Y_4{L`hMxCRLM%8148xyLNsSqj`#;p#j&40LmVZhv+Q!Bh@rUc%z9e z`4VoWVUwZc!W~UodRCE2c=qj%nvY)x5)mV53~=Vst(%HC%{&pilX0)M3yLJD53-A5 zhox3MzPx+dpM&UpICWCFn&_9$S4IpCbtkwK*H$cAX3e6OZPd-SKFHK>>g<-VTE4~_ z(g&WH%Z#6wBW{K+X79S&L9rCz7B53Nz@FK3W2k<2-a%_&-|S+@#%#@1{fZUX2IY;% zFe}0|v+PqPhJo2#dO|I);RQ6h?r)8zIoX>zxzoO6akuLg-&7*CCea5OtCTr!N!d%%7S2NG%@aA!$ z9{A6fFZc1yLl2rWa#wBmrmww5FuFpsb!8?Nl#rF`SW6G(ybWJx1NM5HkNZ&mvihRb zaNzCrk3xK|s&a@>a&>0MTzH?>tCb5>V!V8^N-^z_-@TBnIL?f;v-?-eU6A;SB%UtV zE1$M~$Bw8l1sSvL1p{AhwaH!mDB&S*$nV6q(w@c-y?pzJjqPz4TJWl~{V+jfS+{_v%gQM~(B@S-Nb7`}06f zD--7XHT*r|vnYSA4Gr}-14a(<4_Ku}~*fIy%;h!EI+nV(?R(DMQC(DJ4ALm4Hk177v+%lt>BE!*>d` z40BRlzFV@ra~|(i%hONbnbLre)YQo(?XbggE;MbldN^5Z_Fi@~>a@Mhb7zIR1f*uNnomTS z;t+2f0_~e}od1pwmCee@Un}cK!Z(l0I|TwMa@4WsW<oKU5>B73S zwpmXtH;=hxbq^K%bH33#(qnI$&Fh+)Cpo7RVBUj*w0nl4feSRKNBlxLx2F47eJ#+}ap#`CxE~{|y_Z-SVntXdynBu@&+Lp;Yf-^6u&xJr1+h}#LsZP<3 z9!-7T6tk^653L?A?9iS@vfmX?O|8y5)nK}BPQZ4b#();R?m*W73ExL-A)b=uJgH^~5&0nr6{)%YyqYM#B&Qj8z@RQHi zpGrVDMR2MlL#z|Q7IEOqDXinA(E^Zk4h1}FUPGL2KG-er>Hcu0Mjh+R@O@temC_H6 zT$O(h^FUQUlgp~-r7`aEBQ;JWDBQ+I6Xq$3U~eD9AbM*)K&uyk!|GI))Bx4HRWb{n z)@u+oMwMj<=-#U_rq0t-$;4765@!cvV|*O5dTy(eHafxVH`5OxH>JtvIsTaNKFh|F z@+BP^>H@S*o0}ou1vpWGrq_25k2_^r0?Kq(PkAiF%=g^h=JPK7&8vetU_bgw#~bB=7jsg~3H_+;x1!yz|PW zikZ9=l(;oLSX34fHK2y(aF#A$AXLK-;%KV?1_UkAz&Rw3Ea97%Gev=WSfWvvYyUEU z#*L4RGm;c9nTpv1GS#8Tg4b;kx?0kHj*mPPQ8k=6D=x!jX8cH@yr*MSLi~U|giA(r zZF1GC^is$6(*DG;ku_BmTy3nth>&cGOS{qsGlFm2;AjvUhjtm1Ly8G0eOn4uU1RU$3DQVc0HG&=E0#d%Z0iDip9(Y#@07p9Cd_r&AtFX3smv2fBJ*QEy(Da9gj)}?i z2582KOY~mk@b$|CSVtM$O)~F|PXD5J4cka2;aV%6Ys`6!-_^eqVXk#37Jgzv#9xMC zLP5vInRx?&P^x<_HxUuKmZKvLWfKgkxeBX*-Ifbk%g%AAg%&HjBwxg}KHzJ^oZy0p zET(llC9g%`!G`)SP05)C5TzjuJg8syK%y0w&HaN&FX{0PmNZQuU;gnf-;RNmW_|pk zsf!vu+A#I@#7gdAhq|R337xwEqrp4um3djVa!#)$@vrscza(b^hM!_ul5>Y{B-R~M zT+zoeTBxJ6&`> z*H6mEie6=uhley&4`K-|VERKy4Lv z_(J%6I)@8(at2HXU`7@WCRN<2bBXZ}ixV6Sscv5F;YViemU0;TvBaB?5X-4Ts=Twr zTqBvraJPGQX7%`qe%7#-|?AhI$@ADQqryuY}E6toz?IOR5x7hn9{#foXK&hlaEE*%r2=*>zthnw776gBhJh* zEdvZ}&diG}HH#4|8@5&9lL(s^dGb#MZry(!?t8%x8EaTzo@GAw#b`n_FUxf7TX%QD zw-gqwQ%~%DY0>h-&Bxg_c-c|8AFJ8|I^D#~3)WP{A37!h9^hy{^}pqU~%{cxLb*k1b&6jztS@G8M7B5%JQN zf=Nm15AeGoDT}!Hzo@F==L*l%yQh!3u4SShO|(RA`1XF&ZaU?NNxl|9dN@brhW5J|po!WmwX@P{+D=FF$@efm8blwpDLFkzit%)0GchdK8O z$nx8m$<;ncZG8*zB;3L0;cgRbHn-~gA2!XEE1eNX3zJnFhkO#*(4(^y&0Y)ra!r8!OH!Vc+uO)!+5ThRkJ>E!JcSew6L zatPl_uV#h!#X8q;rsJNOYK-J_oWW1_4jyR_11FTvJAca(;hL{&5qK(%M9U6Az}>Q2 zt|>nFH$7@e$)(=W6xjvfJmskwaVtBlt6+|0X`y;ydBQck3{~gZw)mq7cUU#IlkPFd)w;4+(jihD!nE=3|KXL+8;act`F_QD~>?d{z^U8iB zZN@(B`Zm2-G<_B=*thIelCA)DfdA>$o4wG;UMJd6z?4KTj#+)rix@2sWlAkNN`01- z`ka^~`XX) z(Q)j|yc9WCvg-a4uhjd{d|2kC6f2!uL2rXkhjf!GbYuq?R^l}zelaONUdXP%_%EH1T zVT9tjAox^+2lu@A!;IqC$rSfyXM8?6YFH)$3jhANMs)EJ&f@L$JJu*NBK8$}1z&+5 z^Z1OJ+sHFkLcxmK5iNF#j7>>-NazHiV%A9BezvkGz_JB`pNdIJ&d%jAkgIT#d|Mcx zL_1LukMAuYjCD(TuunP3ule<#q56u!b7u0w*zLJx54c_Sf0$--8%6Q0KjgbwzF??T zUI1DuN-YzZ`o=-)D%y~97yVum(I2FFiTbi;zR1VoFi3zDv9{h=h%(2e8BVbW=c4tJ z`-BXU+3tp;9>{d}qvB@@!2#@S5lx-MIJn z#2iJkjOS;%C&_*8tK>@a)6Jk6v*KcGv5&=4d)v2jR`T6n8O%*uN3){pT;L5}!5J}H zocmuxi05RxQ&o4|iAn}qyjWK!G`!(S<}q*VUlNtMG4BgA<=+tQg; zBhO0>RVG2zf%+yLt0V=a-kX+%>aE6^C#FYiA{Yn!QwLdshIz0@#9NaNM+>hMGz7!O z#Xc2;U1gP{W?RYo`UKsbmgSHzMyki7Ipla~4>QNxTfEC| z15EKv_+iIV!U|15fAz^}1#yO}no6wQ#_D(Ek%@j= zSNKgr%~aHQd%A}@PxW)jg?^pqEup=9!vMTeo*~}1a?zM#LYy-R_dblp$oW#i8LCJH z7wz@!AXnenvILDS!|Q^rbog-`*E9EKF8FDXp`=g+8K^I?A%Yza5UA ztP^Axe&mdYJzu+-s8rQP-BF;e4N$yXoZ@1yep_CMKW$*MyoR-C?rbX{vtuS(qZZ^i3iIqtJj5y-?cF9c-U&Fe?I-l_ky2di*Cd|r(@!a~%_2bU3Jib~wQ94sf$ zx$iTH)Lg$<;)A2Qw2`ms3&Z9rIHNw~4lg;NLYcMCFh30_Kzz9GnWz`9>*7%lSDL^Z zaEDx|%e?@kl!1>o(x&eXw_F{KRe;=vX>z`gNOyN-Vi_3Nb)g#m&z-bnKN7Y_nh0mbqdDz*EsSJ62N z5F~8M^IM$%x5atbbzH~hmo$Uw#4fs!C1w29U1j{gFF{Ujuf{;-YN2(nTpE~U9D7nH zg)Pth(wSS_2?ck>zR=C2f2vAP@qQ)x%sB!OigzFLokng@Fc{CgQ{O!jnH*=uZPf z-zY8&+E9SJ(s{C}O*q)Rc1b9#5-4Cv=O)teDa0M=)9(?FE25`V|AH$#_D6M)Kr|1G#{t?tw1dy_x=<(sy zkG@g`Icfl)VfW?9wuN;k(q0DEyi!?FvRVugy;r=;4gWPxt^Te5KimKv1riCvQq4Gj z$ZS@Kw;M@M}wW69lq=i=R4`f_%v_SFE&RCrpR&~`)7Ih!VVnDSzyQ!Kh@gnPu&4%mR`nf zUW^QpOom5inH6Dtk*2YjNUA_N5N z?<~yBG#+!Yx10ZEX4c+wmxILBQ{&~!HyURCpPIimw>7skcQi*Q7#U5|UY-6zaN!;u zwQpT(^Q8~G*r4vuF>RzZ8X95Ifji7By(&EHoaSa`-2~;aT}mXjv$O$eS` zKgW2<()nE3;LR0EGsx9F#!}>478{nM^KX0NFIWo%uFNQfmJ&%jXLz?YdLFx$;JtmR9-)x%!Fd zRfg0zPi(F}xfF0U>DH&_>86;#z&VNs-I?)$=7Hqr&!1^MPe9&09~>Zg{!621N7f@N zH4ECrH#cZ6ZJz6*VLgiFJ?w(df{nj=Bn-8j0$V*v4<&r3zHp|Dk@RV{2ko_ z^4?xb5zh$-FR=vt_A8O7wLLld&7Uq^V!3+ZQohUIfB4oVmbaP#=>{tI%5VLC%S$ZM zYT<4K=Pq28{_kIb$%Gfsu0ih@|8((O5G?up9|!W2iX}IW^3BR0FJ9G}W%%tu`1`Zu z5XhjC%`D~rdldMK0qJxLzZv7#{Y8l`<iDf>T5<$tH_ z-wXDCz3l(24g9D7^|F73k^c>h|Bl7~o6G*4KL0nD{X3KYzq|YhEOVW|;}cFe>9arS zvtBDa&6m?g)H zszzb&=h0wvBhQQMx;dXsc<5F)6OumvjFM9Hmb7etd#?zgIbDjWJlPw&s1#e#N@pL# zU3?A8Q^#-eTU{6!N6C_lnU*bPO9|sDe@V~x9n=u^g+_PwfGZ@hn@ci_kcSXvAMH%9EDu~qqXYahG91$srCTBvmk z^{gc@6OT(?)Axn_JKce@wm*-^_H?BA%l2Hn>Bn&4$?thf3wAjv^B5zyo+$ey_W=c2 zQwz5~3D1sUEM)uBMP~Oic_NQAi#%Hym$uIlZ9Pc}l4wV&0+wGxogI!09By`}e;+hb2Hd=Q=P!vux#*-%;)U zl>bzZ=t8oBK)Y)}-E9~zPZ=`gy|=PdIi9PY@nA!#M|HP)Z`3|? zPCJ#DQSIKnY}nX)U%r6Y;&*#(%>Fe#Yqf1q;R$!AN%%r|3u|Q4*=e1osY6NAsWHa8-cpW9NtF}PJe84_BpEp$wy*+L_O=twagdjJI;v%; z()Q4w&g%(UTbHb4lj65p-at0}-s?fSqw$yqEpAjn@kh==CC2@nVDl^?mI+IZ5>wyJ z78RMyv!kXnH}Ltz*t0Rmi6>#)^Nqk9r3X!?yS&vq14?y=^GUq*+4FDjBtH$pPBk@+ zxwJ7(uq8P}70OvnfbXn@GW$K%RFyz!M$7eRUR8o>dVV(#?N8R|QCmo~VX7XnPI~d} zafO4tk;0YyEc;BmpQ@sn3oXa{6P{^Fj#VS$kFFd4q%t~clREtoXXsShuO&Etc({-@ z5kl`oyZ30$_Te{){c(Z%Wb( zEO6W_CHD8@ji2f7uU1cew1^OG?STv%-P}mz>b~$>(^VM~uwFz-e~27Lwf}hBJsJ>WM}lq!x~uLq_U%DHph#<70|m1ye|h z#P|eiNb(WELMs-D5JUJ&ZRp;qERiMl3e6B0AM#F^W?e=WAaB6k4LA#BN zlrvPVA>13u)%GVN5J1p$RQI(76j@10YCGC*Gb%f+Q>)$yy`i~1g3k*RUbEpHeCpALkdq;-bN!|qyA+Sf)tf+%KRI$l7U77^T@ws`~nu(sRGT2gFC$<8|+;1pZBSFFpG$rSd(Q z;#IY)DjXBt+tI3$F3Y5jd0BC;I;33n#r`l@zT_ym$aFw|p$CZap25UqBi&g{Iq2BSx{`M&Lb+D(o^|EQ6M?s$$(az9*GI~a7?pg8os^oZF$RNRG*n@mm z{0ixJ7=rau$Fx!Y_Hv7-0QjJDe}fKe7ywB&8V=w$4zrBLK^i@?z@Rz7g8&VNn_A~; zj@Fx`x(8pTB98XR21#N#HsaPqq=*{^AoW8s{#WuDUA|uHNGImJ-S>>Wsq-7lx5!>!xf76<0n15~ox#U!Xux5~FLhIH1Jqp{dOGh_>4tgn-Bj_``pffYJnk zH2B<=e!jSOC00vT8G`I&#oq5W_CMMEVHF;fR|%qbNZWyGV3mDwEt|M@5f3ZmL@S(^ zjH`6asqO{5EF><-H5w|UpOE9v=M_hupLfeYwjhvvh)N)3%OP|ZOC#50WS137LTvF8 zt2}HnnEOF7$+@vsb8v7W&3_Wa6@4N|n;=WzR$j;yC|8)b?q13Xye^pj39O7X!E0o^ zaR<7viMc(6TOT+Ns!ws)(14WJVO=>5Pbv%@2U+8d{=($T&a}8eT|7) zEe!eqU;bo1OOQipFl&HX1uJVbrP zb!%e#-{hHJc)$!RRUnC4+=8rVVoi-6L9|Gif($qP_fKT>LR@yQZyc#>GSLe*BTjaQ zZ`NTl9GNA&-Hqy})sGBe6Qg&~ua)+la|~c4Z|q{wl&a!*cxejL?)+XB(EVDY$=aIACrKkOn1^AaQOrW{bvsODI3HdQ^QpzbsPk(hMekh0_6RM4Z-VN-vy68*RA-Pms#q1BR|^^mL`nr4!1t_1B; zUz|eRs+wQy`;&n^@b#Scm#}Bt-4&zej(h4yA5Mn(afa^S9yRO+#+jh12|iR$e;D2p zDh;eQOQ>ecFgYrn^v1$TU8#SnN^w*>+0$Vi`!6`7E}qEIJO0c;!Z@3H#jsxVn*t3r zymJuuMKx#CN<9(Bms10l0Yk?J&Zr%dxVg)}C))^Viq(7~;m2e&YEyR0@k%{3XfBN& z5sQkR8EtSWTBIz0mT!}3c7_1`=N)Uic3rPYcc5duE1 z{tXxWDsk21K`Qh3n#um#`U0Wz|2A3~l-Lsus^8`YRLl04u4>tb&vu*qR!D;}45@=x zVdUc=`O}*~04j`Xb+P9Ct?vTHTxJKa5|Kdl;ty}qkBpxz~y!1m0v&j z?0M#{lMxs}pZLGi`TwWs zT==*?*C%zhg0HZY{hN-rl=RM&cpHA=+i%ZR)G!9&qey+wdw;!VP*rNev8;t=t-OoJ zZOV5Wn&-f}(6I5D)T#aL&9zo~XJwN!kj%$huA8n1eK!lXG!eLy>a!*)Y}?PWKcuM& zaYJ={JU#65|9GBUgazLF5PNxOD;1WlBj2Q(R9oU=EOoLI4Z5)-scH~^Yfb%6AieW^ zq0)I+zlfHx6x2|I*8cakghnt#Pk@Hh89y7z`r^5s5h>~FIfbak7qMu^ZwsL|sqk!A zBi9Xg2W^b8=fvD305I~yd=Gwvt~H&Vlni@V75EmyLzRlsbLLu(oZW zzh+66Qk6Wk%(fWRPaYx1dsiUwC9l5-SFa|3X01LYBJmV-^3W#Sa={U3Oay*P{d_As zTGr|t_Wh!q)Le`vuA)zJtfah?)4ZXgSFE6#z!V*%V*G5pwfK z72{iJRnSUz_zVRJ_DnwKX=>CMKCxaI0v*%pu)YnWRIkYF?Ka*?Lx}ToUe4Zm;wu{< zb;dIbIp_%p<(XqemNKJ{zf!6)?75}F=k30G=Tjd8FzCoCPM@u|uWQWj;oaKrx~7OZ z3W*&xsgB#x&#e@#JNdQ)FEVWibl;QxREEa}PC#jf$&LZm`dU&m^V;vjD>f2rs#(zG z<5*pj5wUgUYZLeN&p;u$&fTnA-fi964Q%~bo^<{Y7?h1~=ulw9GWrlS zcpnoj3rX<-Hl6ZvjY=iAgW~nS`Y)bzeL@F8$GgMh*oHiO2}=Hxrozc_#Q* z-iDn4zuLLD?Y*wtDKMhXp>O3bqU9o)7$v7yKwB%LWqJ?Ah?CA=&5x@r(#ha)u)mUT zm%4X%%>uFTHRXRaHbv5j zeR&67Y|gk^13;n|`yV8Am)m-2Z=;X!z|_hmNzAVV-2VyWDX{|rcQhIsoG5vrg-VJY z8^7y5P?7@*V7&wnu*yOxo`#d>PXL6`Tmtj;_6U_@L1U&Rw2jfzi2W8Zdd3wr<0h9F zS{KCs?k6GK^-_h5oAzfRbDfFuluFKwCY9mJ|to6#ER;$K(ubal(KTzT}TKkyR z8D-DkC+ZH`$WV(M7DbnV6Q!d=#x;nA|Y zPpxbO%gZ8xA@34o?sBT>=4TsmRVPO311l}%n%R_?G}N!X;#;a&^o^UtLo_zqFY&3p z{{i7np0%fphTpjY)Xx>&+I-T{lJd3mU~-Z}fK(RdA7bDA0Deu;q8Gr+p)w}+<2fZ; zUjbB46CI`B*~6Qdn0U#ZGSIs|2MJa0^3g`@I@E8r8W%g4TN_&>A-HC7P9K-pJik4< z-jd_tUpSY{F_}=mpqAx?N#KvGNRwnLA#5EWaCQQ^aDl=~BiV zcHR_6`;1t%>fA3s7A5R?8X+OU4<4el!(GP$H7rYL>V9WAciKq6feo?JjL}P%yKg0=-4W7Skn+{JJH~J&nP5UqC3~_+$xCnPjzHjeolb=nF6_W<*=eY zN0HiS^<-n+|Li_IZMj~vS=tWlD0q^{v9~yu{7j!U;Xo}k{p7W3_%H&n!ln=aO zKbea4?W;(GPxXoE79ARhJOiC9g7)jf$SjR4dpjQlipN8wWIr+@u~5Kl96H$`d zD#M_M-Y|{FXmLG;_g#fwMsk%sfQ;NQ%r@+Ou(jvRwmVG2qV~|kFCOX(3iaePO{z18 z>Z`t7-_3k9mg_lsHJ45dml*O{y>6a24t6hIWO4zy{!Wti5^bBZencXghhm>R-d@5_N>yD=GrPjHeY<~Nwb!k|a zs75i%{c7P5R)1j$XUqu&f%S)<)Y0 z{`ERXS@(`bmYd08d1JgqA_%)KHzb~AW=Li*0N`n<=kg$*UZP}(w@jM32V*%~buaRu zNEX~fms(3x%g@ah3W}->^db=>Bz3-9dsqW=witMuq77+@4$&t!mbuyUKO%YQ&4Jk~%K5xt2i7A(rii-v zrM@8eBw9gJb)X^hV#AO_Vh3Uf7s}Om{yVm1@Wx z7L?ty9IB8C%BTi>xLASgF<#BfKG~QFryqfMah13Kt-vgap47}D>D}^E({v~( zyN1cxmsQ?-#J}U2c`|UAuhk*bR&S&skhfQ_>%oKdPR9oIdP1?PP+!gz|E#K8eSY(B zsRE;2B1jikg%>I8g=7s^I-|H%ywj=vs=+9eDQUUSk?T^t-jmDDGT8p%514}NFq&pX z_WTqJnzyRO++sFpitIJAk30q9kc!uB-{pjM=^ZQ86P#})hgdwh^|y|MRC#iwOK_L* z{w#L0Z1kvlK$NPB-A_x(BhPH6502NP99+Hh|kneJo6k#?si5myG1j^Z9Hg*xdJU?mzt=`K)6rmMuSJ z8$Q`(pqgs0m$jsa)RrAZ=oZuC*xq?AVtzvDE_Mtcb7ef)53;aMBRGEp{mCH z>}%nwmf9ochXW_=;$ScJ$Cu2;!j{Zt{`=p;;{in1ADa#L|Q{Pot0hELus`J zeG!QRlKR|)&ZyG|I*1O8xJN2|w4^kaH0*fhx)YIUj4DD^TL8V~s(2Bt6%k}X()u-X zS{ap&Jn5vz*f&MAwL}HzjEDYwG4wEQ_fZD8+!$jp44I>DX7N_T^k=Mm2Tbv~ z=#GD}qZJ=yns`})2LOzx`Z7IePxd%PD5vN3F z_V65O!8hHvj{b7ws zCSKlp(Dv^Rb1BM1U=?Ud6%nOffvoFy9sM!e>T@x5Ygm+fC+?J6 zGIYR-O4WuepJTCT))GoAdrd#mCC7yISgO(IqkDrC>D9q|k0Onwm0pzx>8XT5<=OQ2%%s^hdWg_ms?gOZ zgp#6}+;&AqY>Jhl5-;GS&StYEa)H<#LSyzH(`(3=L`d3(1_J3(8O^$`m#L zgJhCyQA_EAZY%{^*=lV(s={56IiE785x1*ocimN z%v{kd^j}xDxkM)=g;m{zg4=9h+JpMOu76#aZ!72pMT4%H-(5&AmRcXB5y=k5%nKH)FSz zHj13=1ej!!hfgQtQBA6Ai)M|6cDZK92+shbKIVQDnMRPI{)Ga-(GkIMIR18 z(d3_fJ**4;8U{Fs{RXyQOEoV+VzW-2wW>~IhA85$ullulkfms4ucU znWPOEY;4u)+R`U`a_=5v{Y&hy3nu;nD-m(*j@6^8YSMXON_l8 zlWBp=H68k+@2|(w13vb)9hh{uMZ}J-9|Q*xTA(#*S4(yi;ticK`_8p<_KD0TQ=5_r zbF?<1)|~PkNDSM)@q|D6PS#oj$|V_My`^#`C^j{R zd1xptp;y~@zcLNeU8c1c(yb{K?#+vpuXNXVtKI?g%d)xN9d_bV)$!Im#4n&?jrsE_ zr(U)ecW&HnGOvddRTF;7`BzjH*UN7)pd4`w8O?>0%oqmAuKB2oznUR>fXd=CS;4Bt zu^L0QAqul&t^wiG$|ySEJ$=BuZ37?T-BnzUsTRp=jnl}Z2yTIgr7dvlrnDMP8L4D& z7z}E9ejyWn{;rz5Ld79g3oBispJt;F9=Y)#(Z3Ayz?Un!Coj(EnA)T%n=>GfHyOV_ zyqG+Rq>44Hobg4kX)cU#nx@cVgFj*@gW*{;7<&@jB5Ana`{DS9=;E%Z(TYabIk}1h zJs#8ALzi0ozj=o!+RQG^B55Mw!df-joiE6c5Z-K3-ukCvhDl4V3q_OX%f8H6*E5eg z=$*HT8M7(k$3oIm7fkbv!xuDsxnkvmOW3vZ(Kq7lzoN8Ky6$Qh$msOe4T)x-6jk=Q z_-{$ZjSMRyiMb&6UD|2A>dR^aCFjTlZZqE1=r{>suwOLRz-*t3L z9WGRGX)h+wOLYWXWtxAiBxK>a;eb*Fdzu{Nm4H7c8fyKl>)@UT@$%J>U7Nk-f4`CQ$obqlR;TXQCHHarc+^2Ho;4| zGL7*1Pr(;MO*;VOiEQjRDA zVvrLBE8s9QD2hXFwQlR28=uMC4~B_bk-2BbN6uNp)3n8OI4dUG?)Ft>?Q^Kuh@L%} z+_7lb7r;DGmlnsYK}%EzH;VS<8&0*kwEQjmW)keb(OOY^zx?<9`Q=Hif_V?|6)8EP=DJj z7a2D4AdLrXUix-WyjNgL>JMei+PSWR{yI=HjYI3oWC5V+OmSKMZgvg#CZB|q1g~=~ zr#u3^7#0lk8d;2ae>pSU>pIMFsq0OUDW>+Bk<}LMFg^3`gB_JVC7RM#JH7}G4Q^40 zv${V7_aToU6_#kFzY(fza1j6R9SChl-W*;&bfJa&Cg!S1M7M2a2K(@BN^1~AuTnOyhUyK z8&kTl$asu;$4w_$UoHJ5i)foMt&kvdgET_i9c1`htUOo3F9E9CXQL4UeJrx`u)6q`72sb_b!%rh-#6LnwA^LBipDXZ5S$Us$ zg4E$^N`Il$D6B5z%8e*NEL!MM+CeUS^B`+M8(A_upa4k;rC?qIK>6HLiLMF>&YXkq zIbFpgCkt zMCI^&EP-{rPWy}TglJ}b_>Fu=o9=kOA%v{LxetmQSkbh(hU5i09j7F*0rfV+o=mh< zQSqlGx+IY7QYtSC`^fLF zysdXKJ*`KGUfSkvr<}KcD0-A7)Lp^LYOZxJ{E9WR(Pwt;j?Y$XGnYc>6nIhuUngUn z&!t<&lw7+d=Y?JTK2}n?RM^4(7SDtPv?p?Ncw4I8P8g?oEp>Pb` zw_9f;SDh2(WN-bpdw9>z#QVNg{yRp96ms<9-o4MMXooG#yBdHG_cVC8udgbVNv&26 z)+64kc5*@912Wzzml<`r?G1@)znG|R0+81UyXWRsWi9ibd=@W=y&hM=TW@|_$x)Td za0~^uwPTEgx^OeOc6&-S)f9D;eljX@YeQm%*%{U3FTU&<^s^TZBVV#&2VYin=4^AP zIGDY-Cl#RwGmSuSciBK*-ueYNHi$ZAdz`}RR=b>&h827I7vJt>p?dhm;^@%d8mDQv zbk-!a-!A#9Zq+lpliSu+e}6*i3}N{4GLpuYbel_Wx=6@^9a11Wp6Xq%%YF4)l`I?G zi+-H3Vk-9Fu9fIiEHBp28X;x4A?6S^Y43doqnh<1Z{Nm4t+#@$8{+17QOx3>aVQ?F zQV;fc2-O0kg&X_Fl&4yJjLT;@(GSlpEj(pJ?0hpf@xE<9`tUhir|!;5wVaAhe&q?g zw@n1+jPs_`QQP6g9#tPOl=q&7DdMnsWCwrk^$;4G+{zh^y!1&ngRb?RT2X6a_2?&m zZcEKyjZQY!P@IPDoe!RqcuQ$4QgSk=#=HSkpIjTvnD_70i?Y?(H5XnJ#eDv_BA<3o z^{gD<@T5`2Ap0exhdsl^^LIxnh<_ZHN&cuu=PS=0+iPU3bhhApkL;~soDpw7&b+>x zJztelY4GDm<9mxjY|?2ZHzr2Fmt1k`2xTnvRE742#HjskL(&1Cf*+Wwr%9T2_ls() zhA+i_#I&9az5L|Ot1nE*+NIRj?b^El=e21F$*R7o;+dH-887rwON3c)04^SZM^vks zNxmF=nb`XjJ(5naG4}o1vvBP{Wz6F6Bd{Mv(;v@**wERy>qk2r|D>QyO)a}I^XqhC z<0a0gTkW?Zy%1Mlb?LhiJ2!QP%oRpIaqeM`8m3Ykyt=Yy?=DljbjN^=G5s6=sL&Cs zP>1!cH*iEk^|kKLq524gvUxY6FCAE=%0?Dg9hJzp>%v4&R)*1*K9xl{v+J61t`;T| z%U$m!zhciDD31yQjHIA&CUaWXJ84CCrF4R?)S@XNgtv;WQNnSw#8j$;*Gkd82&Geg z@=aXQ0D8xihZc}oBWYIZ8VMG|jIX#Zea9-rHxlSkM%})uQBSd1+o(6nyJ~LeuENfK zwMmV$Uz4H#RhN~1+KI+`QHXMR8mFqMnnyjgGP+EA8ftnv+t}3(hAeQzC~YrZ`;ZXaI}MJoH{~ZAKQK`?v>dB)mb= zY&miYYJog#;~q+@bL$lC+OnXQS6;Z}Tk}jVcqd~`+gp|M>Iddag?oB=f9EqpMv4z8d!Uy}3$Y!feR9pAB9_R*^~=8ugXf2ZU-s>WHQ@u&{+ zJQq89yUS(E(c6!vN|3BbUAk*lbI*zwj7h?!vA8eV4QxMW_ zIvIsLW46p*4=4p7cA5egj`*i`T+vq^_lygY=!)50P&?XSKvHKe42u=9Jp&spl@+7R zDzfzjd9O}~##J+P_3z!<>9Gpz>Mn@N5R29U^`o;|w7}74?S85c8s-LaP{)-pX!{;e z47_NZJ;;#xd&nq5Agi8uuF4qtYBemiLfWI2%W45TuI6U! z;cHy7pP&=Bi?B8=9tS8fWkf78cv+&vts^MKs=5|)z1%5jl6miuh#;!V?KF0@QEnv% zxx8!?AB(IugvRz?kDiQf$-6eJVJtgjgOuAJTnwMnkm%z>SgH#whaOV9#&z7SC@(_GYT58j(@h&^@60gd5TusIvi zg@V|3eiD5Ut_CBYZ0uZu&4ic}-RcnRHfFWLI(0Yt`hPZ>E})UK-3C_|)dB(MUc}wY z0i~np6nfIRT9};}c2X15{k2<#Bb`@~06Fa2P0GoLCAD&b?>caBiS`n)I zyWxe8$pIdn49H=C;PN!4o-BLH2MR)N zBs(`ACVP}8H{FX{R6EDm<$r=T?Iq@aDzqrSxL+VE{4)06ieqj(d5MTZtnSSp*h^|j z1U*vr+ZJ|zq9D-#@)9QKVv6x^gfcK+xlq8Sa`fZ+1%dn*N2xyu&xzVduju*{Ckk~L zFq?WJv;M@iGEf6|C1rAdb_2g8{);q~E(8cusKYYBKe3+v)9v;CGU$Ilc8CqwKu9X? zPcLFC1MbT0)jwkO`x6NQM*%MkJ>NF)-*?38WBzZJl|hXj>(Tw`MTqbX(X@+DNaY*PW^c~smq{8KDIPH101Y*?hk8+^5JxI zfJS>_ndHvJr8b}Dy_^??El*F90`(hWeX`+1OB1TiuZl?oDxHs}mhT>sU>b%rl;A}f zBKj;neUe8jew`dSJ10l``!odGKp^wLrRwM5$^O*3uAw7JZ4c0IlDbt@7wgM;IXZCM z?Mt3O{NvE;5ANyz0IWSq76 zKh8zRz5%ErI6Ud8=o$cjYrK>HS`FL-98%q zCWA`zKdptT-SysI9UC@ud~?AHFdh6rtGBCjpKIjQAPANrAGrs3TJ{<`MkP$w4Q$_A zHXut!|MvStbo~mv1Zd!#QIC!*2UW1t7l1JAD5@TGs}_@b)_LipWWwXq)HUJofynE| z?&=zBlwcZ13CARGA@{*1h4s~*_&B=og~U$`;2rfF@pg<8-5GKytH=any{lKS zl!2ymqv=-`f?WYD9$ zuHFX12~RwOY*5Je^l+h<(8UR;1{JmpxvMRam%&Uro&)pfd2G1Ll*L0zF8cH8F9sig zJw~`24`w=K`VoD82MVbIfdqs-*Fa)mu)zfVg1=SH5h*CL?lQXq-V-Y?N2%+8!X4JW zK}uYDo}W{G78iWTStV7gxLad8?7X-^WRwG6b`Bp7oubGWd@y9R-C&pVPMRz~K%gd5046N5cj`qZGVencSB2lWL zu%-Nh;@8m%Y4*`7Vs;5OsOu8|;JliRYLI92h#3P5Yn-d1JBmxQJ_Yy+s)9|h7e*Fx zI!mQI4k%sG$8No%HvBz!T~V{dYacCvb#*|A%cK{yRjc7$zL*Ytu73Jr(ay;`&pU*d z1m!`Ja!b}H{RK0gzo28}(h`JpxNhS0zTy-e1>wkjf(Uvs{SroBRMtwT0`^;i*p;}- zo>!bIJXoy;t~C|TAX?5c2AD+ag-tv;0Rup`xPs?z|J=pX;Q(F4wIdCtt510aC}Fl= zkgr|5LOZ?Iuy111qy3<#U@1F^XULCEgH>^qXu zy!!NzQ5cc<3v$uFP$TaWnZGZgxG#0`Jw|282flf7Hzg7uF5U(pq}l!x_Uwqb(qncQ z%RAVTDo0f8aR7{|Ry+gZ&Jb~o__wjgu|H4%SQ#|+obWIog>k{{XX0Zlg3Uq?_vYFP z+jUd3fz`dgWVcPq!__%3?W4Yb_u6EhhI2yv#as)GxRe}Q$SE8Qd( z{h#`;k`UckS_l-Y9ia+DiiQ5DQeI4(L4q@+;q%LIx|@O##W&hM_Xm?+vy|Td|i~ zorI(GE7fHn_94iXFMy4fR;X*rR4IWQWVhu5gvDnaz6B|?Hg_WJ`dnooMD!j!nHRZe zfkL+d9irT6P6&#k$EM6mCmUZRmiv4@tbNK_`!b#}>KUonv^_&04wzZe+02~-UHqWD zM3MF%4@$oJ$1op@rCp>fVK`x+x#>UF@X1o~MN=S8pO_j(O5$w4o0I0=hSE8HZNH}q zl|p|zajILTLB^T5v`{NVYs6Zis>bn@*{ytzIY3hT0`@s`@6fO-5vxC@s7(JvRoSov zU;a{{g#@g^=n=r|Q06}Yq~{k)g-3ehQ;~acpkun+BgYHkVdl6iC7o}x+@3pL)lqIs zKlHFdUjb?tTLnm%{mH_`y1^u0VVA<@k=$;&<%vV_`lO z6HB}y*l)gV6k4)cQ}^G4-&hA`0C_rA1d-qC4R~28xSOl!0$p0YHoxP%k5_I0Vr?U+ z@|Lj*cE2h@C{2HE#8PI&?i7fGmKgujZD!#wR|K9*6(Fc^ca8u9<_ngOCHqbp!|qhp zH8#L3-FbV*IF68uQ|Xqo{_69M>+z(CO2*(@ff4%qsM*k&5<~Nma;^ zn;Eze$MqAQF=RWa8|E&wa_$pu|5G6^k`Urzg|b01`=)=UtCDiumdSe$!>i+Ku#r1z z!l$pPmV>lx;V{Nz#hWZ+0JC|9i_AZj{BzzdMAptT?a{WK)-3r3<-R`tBC~Oj4dx3~ zYt)YJ60=osjZKQ@zY_A=n7&821QIYKag>@q3Hx%Fthc{b7+1D?y2h<|3{tCN9nYo1 zj0;j(LH+Exqvozjr#}LYT>F%a*OOT#jd;o4+uJX0NvB@k_~|Di^Q*TdoN9iA1S;&` z!KU8ar?Az3(-BNSm_?MEr!)GZ_SfVYOH0dkzb`A6{wB zlxoILDG%eDSEQL;8fL61Lz#lcvYaOdMT1MO{(uRWDMEyb85q;HV~!?r{5#@FVrsmN z0jlN6+fHKf+!|Z&qrn^KpKZ7#r9RI4j)+E42$=@7{=54=o+$+7*N#@c^%3?^g_SW( zPnKH}cFN$^{XVojZ~PezZ|Pi|AzOtY@-BX=a@m?CmQ`=AsqZ$)<3)Dv>gn&KA!0RA zYY0HFa~?QpNy8n>69meUg6+1-dvm|qmZ95k$-SvAHaIi~WIABehgU%!|4~aQRo0P- z^c`*2Q;;O`zyQJBhPcE|y<~bTTbj2zlw+vd`4wy2<2Y@9OFouNiV|!|Q)5NowW#6Q zhhn+Wlcyq5lAQjy-I{tP)C6Ax5Y@X3j9f}L7sEI4vPt~zWGdoI2Yh3SmAkGr&q(%=3x^0Khl|LpXA zUJ>jjtZA@EayI@l^$yUBhHTAb5JoOj7K><)_TtmCzRhee@k4gKZaHzXK96pTfD)GT zs=zNLh zeJZ*tEJ<@i&yKl>#yH8N2&gTrg7wSH3LJmv8rWq8IpW0#4dF04LI*xm-+FM)MSW+i zv3FBpb^=~?U?Jo`q%Qx$%&=R)^=JD}l*oJD^O(Yl^yCEK6JBvDKvJ6u`lQ2#aKHH? zQ%0%NgW03)J}Ie`7DK2&6F9#BZog%yRu$y0WASYYoLq6UsW)e*tnwZ1fte>z?QaTc z*vlk>+9VJ|Ji=&Yq84mMt{u{1`bG$18jWcF&*Pl6&)%CX?irKPF=&0~u`)-q1g^ z2Q2ThBtzTjD33W56I!-VZ7YpCo&A|N-%Q6Y6KtBhF0s2Rhj*l9?zg+R9*O)S--5}E zQN??JyCJ3lYIgbM3a5YiPy=P@U>^3xEOo8H6EYO-`MR)Qt;}Vj8hMY;!JpY~_ICh? z#$)UJ*ZKcctHu`u7n_Oc9i|JHiYwTX-)qjTl{>Fo{M7;s(@Zm=QIX7sk<#)2+`_WM zF~9B?ARTtuR5iTr4079om26;1$5MKjR~{nE_*H{P{P z^5z>{IGkJdzb^dxZ@L?vi;~>-qUcZJ!o{zI79KN>7K8W)juYbTiI?82&FTH~WfYM$ z(vD3SkfsHx0)4b(;T#Mg)-P5O_5ceQ))TMOBJv@$2{Rze)e;6@q<99V3ht)cIr^(S z{aD|OPqgk7c9t_t=*PyLcwh}s@C4S>Cv;27eB_|0R-A?yC~5VjQCDz#t7AV=ff$_P%)td=6+u+b%pHrFM{w35I)GcMD5>ByaA7K=LNT&zp#Y=37mVe>J z40R2Aqg~up-=7rgmYDoH?+84_N3%M|8sIf-qi zrhkJHc$KgY94^w1j{!gQj9oieiAp@;?i9K5aF|sAL)GDZVzvyg5yT&_0|lyfr{daq zSJ3cPfCCU##{tn2T`4Q@LBV4C1H&%?^z|*pcdJ9?(^ru*uveUKw_D_T zI`mx2{D-wk2B(AEgy~FuyWD8^Y@Y<@7~fK^(RhZp7{E0=_B<+fM@wG+N(q5tmy;2D zBa=bUNhfN*A20qN!rnS8%Wm5n1q3Cf8wrsRK|;DkLK-BbySqfXr9(QT8|m&wx>Jzu zknTS7e%IdLx7RsqU*}IQcpmPYbBtdN{EIBnFk~uqG)Abb3b=N$tQ=xLg&Ynk({oLF zz$p`LKvqQt&^)D6m&8rj1)d@aO)HXpS`pEM89>7ta9*|fn*bFl(Pe8J&DW9=hIXCkg?ffmA9V@=9` za%)P^*ng8JwgPN!vgzT#<6#n2G1tpTJFDM9wA095OEK5-;utK@*G>-Wh4Wb&bu>^j zSy^^l^yf>OrYws;hne8hwhiPHXCKUYRgI1w!asNq@A=a(DiijSe^y@bo zV0f^vxQCxYj!>zLcm(@-Gh2o^wjvZ%bq`?@#r5R?FwH~ZsKDmi8{QfRhq+U{V|k)g zKKGMq1KbT;Yw3LVN*^<2Uv>)xN?$W@=PfIicGBkntdKHTDkfLVlO{kV8^=9pal!WU z`H$pA#Nm(=gCYKh`K*4jkZ_N0u9Io7Y~T*LQ#+=ePuxu`N<;T3T^Uv>4VHvQrAH>!^ z9Nvmb@`RvR-FOhB;Q{$ z!)bOs)$?~Msia(<<3#5vR+DT$r;Cdm!hcoNi-`nX2(a&7#q)T)u#KRrWiVwcVfHk$ ziI7Oc^^^f6jCn`$U(nT6s7GRhrH=NE%>YAf9b{y6cCVgNmdu^NhLU;|Y^24>4vJoj zCM?=?qAdWsRQz3W!|u<6Aez*VsXa45m9tv(vq9Z3R;j}rxoG~&j3&bMbN(xxuORQr zFMMR`F!2QMvN0z%6%-2p6uW7Zg|q7r@KnaIqHW)v#4$W zMe!~69=t;rc&w5qg-dVGXY%y(S{mZCTz1y0p+q>Y)ZLLcq_P{IPYqB?zBTO{(@>*K zgIwrijqxmm3*_Mu(C)l4y5yFnPr&Q12mRJPc%<-i0RV85z0{`69S=H;_%3ZnDE3J& z)=&>bVId9tS$?|6-+K#?h_sdZ5?r$iY=!B|CWJNQ8~aIiQ`M9w4F{maM(=Y@pK$~a zSvFx~s`Im7nY}UrA_TN(K=H{gEpi>$N){F9KbDYckZqhW-c&)wTL#fOBvufd) zM6Q#eMhq}i6P9lEdqS32 zXFAyt+@p{`SzhY&3InvN3~>gjT9o;CD#&oEc73jQxV%BrE=>Ty7HS8Cks-@c66Qla z%WWFzS*BCE&)Kt02RX}}SY>2GRqTLQoWvtsDd;;7Gr2#k8Vs7%;-jYWB{qKvhHR=U zY%yuW@|c$pJm`7-PU52rvCgsYGb^B$;f@0vfdy0ViER6o6De(7PWGirvT-$PwBAY6 zR`vIAS9+SKTl%`(wX5bXRr31HQ*q}2mzA#5qSc;0rLmR^JEbB0*3EAhVOC^q%-B4= zwv>1v?_BDxp^rQwb0B{W(ryL5ZK01ypoHp@rGEUU&|yOc3oIuBmEtZ+9~^^4^oO;J z0$CcAntHH6aW)yT=_Vuibu|6YxRJU%fi$;-}dWLA~V7(L_Q zXS`I=h&zEY?G6MUuVq!bo{k}I1*EFLun$gLr{{Vx=Zxh2j!_*F(61QY?#vFe`oSta zRiE7wafW~Tb0>Yc6g-lcr^gB-#Dbe?tU+x_GL$3 zai5P2ujGhvfpI@F1vPJ*{z9#tpWa0LC&k!50T~UbzD1j)^hHqaV<@5axmClOQvN+E zZ`UO#kUkoff-JLtLXtq34R6w@fi!!F<- zjHI{Q$%*GSN8SXqW#v)6={;OA5gl{&R*17kjS}hJm%EVWGZBjEPvhp!W_&pVpN!9$ z!KR~PTcL9%XKs`*IKmytA3r(UGMsjHot>mq?D+QAr5S70gWIaXRFCM3yq|Am3==?t z!l#jkWQ$2h+lQ(QtKXq6nqZw_`-{O=we0fZaW!n6REd84I?XIx z?oo9fLAUf44%w~1Uq%X)U)IU=PKx%N2;DK0ek*NH(CM8t+bamp%3$H6s8c~tC38}6 z5g}?~VO{ZjJz9j!Y1!LA4cn|CZ@-eiI_g?Y+trs#oMOQ(Q>&*nL0p0DqeGdD-66)u{`3h$YKdO{Mi|(*zk))+= zbGWDN?0iykQUV=58jv?GK7b z%ELLOFYm(g94>p@O8J@^BHb7Rs)3oWW_pn6vktIC^y?FD#QV%rP@E=kg{I^ENh3Mu ze!%2-`es}j-NLVOJ)x_u@T8{+3ZzuwB{k*?n)oME%&aJ;Br@)~&#zM%=T*C;@GW^4 ztz_l0U!o6+H8viHpsmqWd&Ci}2|rgq(D;=01>|x>SGE)Rd|T8OBXf6HjY=IYS8?8m zO+kalGV1XNK6^E7GNtd9Rv_C+&=k=l=)A@p3{D_sSf8@@fotMnFL|u|vnR8}uYqrg z1)k2}Y2#KBb|WR5IOX*G)Qgr{G{Xi+MqhMA-{8`j=f8FVb6SO7aHhIT6bd4SBR79skgZ3{`y$l?l)akTw?7?r{DqiygLWvsm zbPqswBcGnnL1AP2A$EP$bIb4)z+c7i`RE43U1DvTXAc9_)a$%ghU%>xD;q$^{OYty zX7A7I!CJ=gmam74eda{fwqPGWMq#M>E*tUI2{bxX&h+26tm{^uTHjZ^I#t|+f+nl2 zvjq_5T<;j#(v)s8h>K(7{U?mhKz@{GjBs}`2H<8~1){hwG%JX*A@pK6v}%h~#R zLngj?2(6t>Pr64#ZE}Bp!Fxiz`J3++Nr4%rNC2l zBn^b8u)UVt>I4ab1QO+BPou7%JbNxBv3Vy>o5V7_jAkg;Xm7OKq=cX1~ zsOrU?xd7Qb&bL%!+EBB6ZNbWKT|INx8%YV$(iA4jNZq}s(oRS`u2vS4kg2ux*gQcH z*y;2nJ-vDBTYUK5qWYv->YT+J8Hs*n8$%H0qouv6U$0EeC}o}sXMub}>m+s~naKX9X5s*0!p<+O3(s-F z_W|%FXEP7lziR{MVr}mHP-*sY`n8o)BG3GqHkp0(E{G+}*lFZ0K@p4y)xoyj@gVu<{Ml$m(70WAcXsDNVY zCo>^K?;t62XVB!Ph^hg}X4Us3uL8o{DV+gD(Kso*bbAO`t!&eNA8@r}IJGqasS0Yu zr0@OFh&NfIR2r7@9XxU$v3gzZpkCUz`dKu>RLllw0&I!6D#pvp8Ea+S=d#7lq>x{~ z%c$6wR5E$`bGVSL!JIFuW&?^6xs@+jDplr-pA^VUk}=1478aM+attzgRUC=iRZG@rw^Llb1@L2!Ip^6bgt{3SO>?JS!@wu<&Z4Ui?#Pn{t&||N7OxLw4s_ z>DR{1uU`M-)Ps)af53?8hETrSV1|*{e^T7-QVFJ+okwMpfOEis+8&U@Gu-kwNi2eNzv!p@WV@`;y{&Rk+F_FqCmA!Mb*UYKX7I$NFOMuR8vQZ1_R=+SVq z34HmC7WJVske!*69bQ=QUFKipS1+;m1;DyUzh7Y#I*Bc9$?R0qs%)2)t&W3AbVB`!&VDveg_{Wt_)V zI+rzF9pC4w1t6!no<=_P5x$>%X2rFGP&5>En%l|rpX0Y>&>610f0;jxgpT~<|2$?TZ zL?ck}6e>`L6sJj9XC-lH^|;?vev1IOJ4aYej#akIEBTz5Mxz+DP5_Cm95kKE zaDeo#I&td6Z0R@vQ;qW7pH0a4{@gw!dbC9?dTH3$eLdp zY(fVhux!ue@<8*LPpjlR{hoX(P$RWNk?iN&W1Z3fOWp`Znc+wg+u8fUvQ=Lb%aDwp z^fG-U8v-d@0rHz7+BG<_;^?(umw0E@A=p#?3A()A zO!=w>O3NNxhTuKpwgh z;NkB1sUF!5ClB07&|{YlRU3oDLytuY9$0t2MF5tr%9fsxTG6Gn88vf;S`b#>2%_EQ z_8ay}R#H`VNaN4l#vAC|H(xK}rG91f?pD^_)lz;@!vShWxhp{)hwafLk&oJ5fI0|~ zi-rbz+w|BFUjM?X?Dfp21KIYU|LH!)Jj`$-t5dQfi`7qh;uFUAU`YI4s_oU6VJ%qgS3FctTX;R z>Wz+3Cp^yJcs$B|MTy`Xh{W&UTL*eHM-V3Cju`qgSFV0C)n4in8NuO83-8(J2TLe0<*+yvd%!tI*w?caQb!(qf%LCe z^a=;_{r1w=o)^P#8cC}vooE7h^AwzZ%U10SobZTPKCV7I@IE~4R8C$P^AvTBAHKu1 zr=++0QZa!5`r3=(;lzcM*@a5uuaBjvTgizjJ39y04S5ZX4SquitfXU(_IfYar&aW? zWnZWZrw?ALoDq){j)Qp;MoASWe;acj*#B7Q`*^_TSis~Jn0T%xirS|-v~V8^z(1t% zoGmq;FAy_SjSA`ZQN>qX>aB!0@I`>l#O{YvE=`*APE!2^DB2S-hSChZObvuqO?ljT zfgr&GYjMX;DHUV;6`VBMX zcoN}wv4obDWGCtp`9Z4Y3<5lLsCt#BV>0bT8aJZC5*`~kprmCS>1vm*Os`+GZZO_N zRp8YM09z^_2?znaD4ua`G2ya!cyC_X>`2uJHrMGY8t6WIA-N=l^PYVC;Y#jw+6qvP zF~92_2kt|Dcmgu$&YLS(TT40C`x9alGoHgY8#>Pbb*J&&P*1X2AkKbaH9)&BUdq*^ zoJ#cEqY1HAVFNDyuAyTtlXn9oexd?#vj4Hj79Yu29Zog6H_MX#m^H6D&vY4h=u}j! z>NkFF)?2)y*cPK?mNvXm$l{Xa)=s&kfy4TFuF{w(?j=gpCA0z7SF)q0hz;Y7ub*JC zI>S!wfNEvlttO{(Tl9}r0&$3FB*ykvc+m8_Pssfmq}o$QJe3|KCc2Kc4FxN*;HkZ@ zsZ87=$Qymfs15YdbhQ}smCODK4&3F~bpvl3uVi`jkddW9-|aZrI{dONGj?IYflN2= z#RPxgMX`wCEdfts0@6Eiez1=g_MfrzpV4@V_Do~;VkhL;8~*jHSmJ_XygQ<3V-yPO zw=Moyr840MgOA;QMzRT_!&%6}6HqF8G0*Yf=nXJ8v+8-L6cv={Mh@#YlLo3@R))+< zWIB!0ADT@*YYxra;cX80^%bn#Pc9h(>y!~3+a_6w-}jcoEkh?{H8T^&DHh2~-Y*vD zaE2{CET#o15j=I3ZRmB_YtPqDDO$Cv1aK2iol?0k7@=#Z^CvT-2K2{jL$fPyxclxw z?KPCG2a?^H1+cG}+nXq*euw;p2jyb&cK zT32t~#|yA8zXlUO4#0UgNbqz=PLwZUKp#JNo$Ss!OUSwuQr^!O265+ilz7c7tB(xkHRW|T5Njq zm07ib;nIiJ5Q^`3${T#%M^A(T zR)Y*jwv@YQ@HU;W8Rc3fdK!t1*Z((`D6|I zMHP6qBe^2B3iTgfl4k%FI)f3<-y>%6cCzP280Uxz#EO~BV;x2MKoo@XcQT!Cl}OX1 zdbtTR)&y@IRpQD-U$7mMOAXB=r~QcOx?ke#_^XdH>hu0Y0?2R?_qjpq*$ap7NNtE# zUZxl$ZNJC)XMYp6m2-vgCS&LuN1#6+{FMCB*NlVTS;q*h@Y>axkVG)vlD(>yBTCw< zA|n!n<^${?ub(qJ3EUCr(GZYnNa>Ab(^u5XXA8uZu+i=h=!Fk8KRvx#24(Bk8U=zoC2Q&BPwK^)~f!H6!qDxH|$snw>!sqYWLu z6|*DI1sisHM8&!+a!?JE3U{73-7m6cmv$~qE#>r#I{4=oQt*CkWQ;$VL6mEI87p@w z4WeFB>gBCx7 zXzMQLzJ|h0f6NU89V_F>GEvdI%xoLP2t1~L5`Bng8@2#GnBYI(V5x%U6(0i*oll{1LA2+D*lnZu5n+JAH8!wtv!??x`69GiO4tM);&c`I$wM(4gUfTwzn8l&S=e17eJ+F_|l( zlUFs`kE^-?@7m=xTv&cZ|2!S(PBo-AFWmYnuDiH5ya>|w!O#;TZXHFt3B)o-2mY>v zfM0lc(z9W|GVl8)fe-1DS zR;W+N@MIFsKr6y>5o+#Dkz;)FBqMleoyd4gRRLp!(p^~p`MF78Q_%LhtWLx2*Td*=YuEuQ zrAzWpxMLZyC-X3&#LH23{yb(EV`YL#J270BX^X8V#Wt(agB2i6bVYb6N7ws_Fm+YF zh;ZUJ;`bUgyrISGA&r>xVr#r&U;^^~xGe+Lr8oAZjIuosf`UTTq}F1Nj_%BZ@YwHF z;zse_m&I+#8Uw>s^?J*PA#`|k4D1YL#A=VHq-mj)S08i&WI3hSuRnb7aXH=E%udLy zARcl(_As^N*zGhRdit@&WHckz-{$$LVk8CzT>BkP=6>ILDJdoc4g;H`t?FndS_c^% z_I9FiYWb4MJ42*OM5($6&egy&FtW?Q`j7RX2gba9Zde<9J8@*ltT-MT16&pHS_h=U zRumciG_a>%+H?}Uu@ynh*n*NFDV zeNKQ-A|}&4@UC&A91>5}$3~BmD}GVTeC5n^*tzQ+hUd3Gc!-fC7>a^;8S)7{<0f1Z z997UWo@raL=*62ryk#P&R}PoM7W`LeS6e>S2LU~fxhSH`^%Km+=xaQML2>!BHqT42 zhFI;1--UtEYxj>aTh1+X8hP?!Q1xu;nF}f8G zOrfLA;l2r>yO$$$(yo|-_K8ST#CS)eM)}HQr`sh~W^2xs-fQ|oj`U`^0?sYmHR!M$ zp1R4R%SqJuMUcH^XFxh_;t^vvtG(;)3EDK!-%p=VGDV>ro8h*J!uaI|<#S-@6t!J* zpnT43@c>#LWm~snmnHKv>iuQSu>R5e46$?zp1fky3jGM{8^fNIzv_4!uPq45R~Q$g zMaphHv%-crD*-I8=4a0SC1IdU)i2Y(G;QE44=fW45iw@JQNhy9=BtL!@9Uq$^QwpS zrSvdKLa#yAmj(=EifNtb!plYm*9P7}PSs`o=R#%hcrNsRCuAnv@q=NpA8kw;%1_rf z4NPPp@70dQm$&f#Jn*CN`tfLD%VB{!wHU#YIA9-i5S9iqdskG%Z-_5tEO@+yEpU!OZ-Z`_>aR%tTT7crKhotgln`HbS3D2K&f&yxyF!5Li z9p3CR(Y3~ntW!Xc|8#(q0hZ=2jpc#T00fao*xbU@KTf)sekr}hXd^+le=`_#?5^ZD z*WMT$lg0WWMDX4IU{d=G%50nE+cFW!3ewn>*V(v-1p!817xni)c8xex+24dW3ff_h zvfLN^P0r&12_bXd;6d9LEcbP8>(#`FdmERcl_2C&zIqwt)j5nDg74@xvF?jL##tHj zIsEn=B`4e`_XmyN8)73po{hn+=z{t8S$2EE+47UNm=BnLy^zkcqh-{_Dvn`LwaDOo z69VkInox0VziNf*JnuIX{+{;{5fvS=Y|o!^vB^3~v!MzJK3dub+u(6C*eVL6eVdm$BnN0(yE8F%XYVM;GH|_#AUtaJ;2#z@p6K5d?!!z^eAiYP9 zSu~;VR~Y?$?y>G%F|0%SONGu%0Pf+%O}Q4*BD=HcsZ&q{&%v{yQ==^W8KE89JQGj4 zcU#9N4u55#{Vl^$B;T(WPhJ9j?qgJta&2wd#fK zgH#U_ysf5s@{4UVUU)~(#u=<(42fd4tIyzg$*M;AeUH51I`!gV(oC*?uSC%DO~NXf z;T?}YLFd)s=dgkAe@UvBM}kHOZ%sdJqw<$Way_Kr2YQm0tYha`m3$17uiT^m6L{X2 z`l&lxpf#{=G1tH@MkRqqZePcyX*+t3SG6AS9iD>3$1)T71LFKu%~;a6JaV@H<2LpA zX9kHCu{B@dZBS)y$MCL-v-eFXGg~SqBzTzp$*+X%3AI9zJU|JeZxPt`W7bLBoJ9*z zOYH2JY-n^7X@6nw%~9a2?6!I=azpnLx^=J)Ofll#J+}2VH3pk>N#3an7!BB>+5749 ze_jsMKL$d^-#4#DmOWA033o8hbh(G!yoWeh=S7;o!T308#4)w{(WECPCW~K8#6W8UtxgHLv-kJLv=Am;yeLfT#AxLm=;g1IEXC@4Qe{8ybh2It( zGw)7+K+Mv#OsIR2_R;P3UTiolYckIIQU=*xb4^~~ZTG1YlDpT%D?4+S4*`hfMd}ki z_2M?vjJr7Q4Elwf4n{CfV{P2v2F+#mD+FAmoTkFJ>?CjB6 zdkkA2hXnu|N`+rb|A<=#?M<5O^d%tKy@F^_!+*U%ad5LL`}haQ!lXC@ zL`fTyIVlV;lf9$uR51iiYL8J5JBB%;ITpoU!QT+V!l9&R_-i9xYR7qKx47OByuT7J zG<@#O^n*4mA@)@Bz1tyh1l6Q$-GBH##4+*}$yz7@tsUQHcR=WcF3M6-ekEcVrmugx zwa|KOxR(zaD!UPenjq*3H@yU(hTSA=g)L#h7eMnK+Uno^U^G!^ED%n7Sa;t2O#~-A zZ{)p0tZP!f7J>5^VyZWROu+?5?|8wykkg#N$T_t}B{I+spQuA4^>%Pg*lJoEEjH=<&0`AZ7W^IcYp_hSEyEv7a~p*O1NT7Rlb4EM$@?}|KH z`tuPV&DNmb3NH0is93;g3xG)Si8VZ~9-l&~h?n5j1W&F@m(otH?KaR&(-S(SL z&e-tytWu-jhPV!z{w9d7HzrD4v3dNIqz1{}!t2xn!gn(c_K~lI?D(C!d zwL-*v?do8iM}bo2pO1g)UReK*Xc88xc03Dh@6%7G>s*e>()i{DYEL1ZK+HA+MI6#9USX*NxC$_ zx|ZFHEADlOng?7P|JU)gVNiOZBe8xrE2u}eJy&$YCl`zXiiqC95)>dbDJ0h#{}ndT zsie@lyVAWUH^nCU1#z2{F<09;h;^!=Rv(=1H%m%zw(P;s+5U5gf{2K)6y*Q)gAO9b zcR5Q$K}MDJK!l0ciO@Ox+aLVTA07k1e!q+SzyE&eqk=l|hi{@1rPpu-|fHIzy# zQvRRI{BQpU{NVjo40J*NzlTHMD42av7-y!4?hVK>7D&mvV(odWPGCRC+zDI|FMv)W z;0Oem`Mu6f$Xv|wwL1h}XID-z=BEQxilhLUu6h6ZLn5;G$_v;Q#+GWJE-IqNv2MM0 z1S+g&9bj;5DHE_z1pql(z0urR*yF=x>k6O&&`3@nM2SqZnK}?Dv&oPkisCo}u!2=a zT>tpY{qs^?`o}{-D2S5tcF*X`wmMtDZ1~BG5>kZ%=HnZkLT-dRFi)(2o)Zmn7yyA5 z($ljHHH7in?H(4&w70zO^f0~^BA zyoRO}`h&T(zpsd!{5;<5lEMd{y_vfO4gwUAh|+Ql-yO$tHsbm44&oc8FTe~!nS(6A zYkoQ4?Ed`}I5~?>lDqSfaWw76C4R)1x@vJ+A9S8Okga@;>p$uIdwQcu=KZqi)sGMF zEI(x@v)Ge{$Vg~yk|eG_b@JOX-q8bGRgV&O;jfx}O|ZLq~kvH+ag#fuY$lV@plU=o%6 zgfZjW>d8+^BQB&Kp(yM9lt6-^RWZmi@CwA^pA+hbGDiU+cdOl!EMQuP4Sp8n{_Ot> z()y&wot@QQ1U&Ty0T}ahTj-uwA3Bj^cJyu6Xfle|sAVgFsCtfo8Qe2!C{=gJZdH$# z3(V4qqRp1x1nlej*VbFj6JUm%k}4(Mz@+Vv9It1epf;R)0KC_`7EvpNAwAgZXkpoAhYaHJ2g2?loz5r?QwD)>)dcxT@4g5p^QnvdC^zy!RN)DYgD zaU+sZ7{(z#s^#nf3WOI&f5Fw!tUp})d{YPFP83te2$Z}t&1KX~qggBu8Jj>Kj=IfQ zJVM-LHagDO?M^8ehB#h0Cz%&1GHOX}e1->;>SqJ^?3`a4)9X5WPD$RJHU zT=fVjdxbQH_W`Mok?*Hs@BFB`P8x_&hKBh#)+yrBz|RH1z|rC*gA9y3cl~NVGeq)b zG>AZ}0Lm>TKUIy!y^_XV<-lLTjNBL|QUIin6)1u9?6F&k2Evw#>I5RvPa0dmA5qJP zFw}#Hfj2v=;ksCCY4i)=MT;u}($!cNj9wA60tvMgR5UpG39g`|(CN1#er6)K1eTHl z$p%s4QTfcKjL@v|A39+z=a5I)X{8R^!lw#iP`Ch4_H2IU+cYL^zhqOk(OkCFpCv#V zPt#<^HR2MoiAw1_9qGI9{)VU4dj*F7x~)!0vd@`NVt0(y3V#R?9P{`BLVjo_WOyvG z!oYmXuSjGc6CTQP73HkND?2jxlDjXVVmr{8$Ny4fyg2(L1xL>z#Rx zba0%4!|(@pR#E3d)Fm;bDVO|vFrdov2afR6^-r~Tks|5SNEvg$ln%x0Rb%k-k1SA-U|3U%> z5AIH(0U+N?=q-qmruxsyfmdyQ&KW!%B`)t~vZXF*upm!zAK=D~g;oH^U%g9sZz2H3 zKLy24Tl~PWbiL{V-f`Xgb)Ydm)r*E=li-_8-a(AFV+z+ZUVUFQ_WbO%b>I=J-Fq8T z*ibA@o!onpDc5hAJE2OrWFn>=Gh;x0pVY!iyA|2z2Y^SKE~HON4~Fh~ihR5u1xkRU z<|t3#-t@cO=Nh5(O2lP>e7s+{Sij4C&zj`*4Fp16Qrt=@ z3Ei8ZK$jnX^q3DoL7r$7w4{gA2;iO|M~Yw z+QV61>;Q;OvZ@0MsE~u?C$@|4Ud&d&m{fT6cLFR}#s9Tnji4+6YI3tS`XO3#!T{DZ zj?CzE>`)JJa*ZnW1J7Kx7MI~BFHu&Ll0!_c8ak3P^Iov#^knR;X8YMVQllMfcLh$$ zO_DXy-P7f@r(y6*1)Z1T8lf~GmL&SVo)Cc_?QRa@$W$wQo51*Fwd+amTi%ekez5%- z%uq&4YPp|Jt#hbr2gttfWnHD zaws4xG)FrsOjrVt1~A(W1wwLDLO_HR$y^<0l*DV;iBFy0P{6w&!Ll}99h|UEnKeHn zD(0>Hg{M9#@#&I#iF!#kX%vopq{s-i>D%6smy6#H&CWOx%K7-7)-7h+I+YAHw&Ujr z?p<2*2+<_7YO~0h9z0b8%z;xz&uhskeUn#X7YTpL22h!&buxJYhrSVxt3RP9 zFluJd5UC60jHN5l&NQaCazvOOf3^io@e!(_4F)AKqj6E<$E2C72F@tWmHwSBUne)6 zWbsj_h1QKGs<&uUwx;EHesa^?=8*HpJZ3ud;+4ZB)~T0b`?zy}5w$RmFkzF|!OiRo z6?vceARma6d6d7aWCgZy45fqp#OR zq8S7V3`Yj!LHZHeK$J1Jo|jjcxB*QSJYB++VbNwGtKVV-kRLig+=hx$9^^sYCH$sK zaWjo5{~do+C(x%%g4>ZCP<>1wQ0E&oxLdgTplnK6{TonS*3(I|(xBK18L0?U6TkGW zy8Y|cEz*)Aw$-EjIWsuOukFYWCQ>Ma*5U2_++PAn8Lgyd23UCIW$s2hVLa(*^B=6^ zf>|<9#~j-&lh{uWO7n@Azo%`a5j_j7i-&hCS^qNpr#v5yfRXOy=?S0eBNh{e?= z$R_&Y^P$W`IonOV7QpF=w=#ycqb-JMk|P~l)12p}?ZB ztxoaO2zd-mM9{TZt4b~v_X`=EJgwO&f7K8aBQuWM1f)Q4_HzW=FNM87c5aPneIO3^ zm%(-t4IAUt|N8c#pSk|}$}M6~-`M>%l`7(8-+?tlun@PamReRd2GQN#)q(~P>byay{#g(= z(_3{7qWRyu)fwSQEqJ2iDCN0qlRsIe z{$!$a*PtgTa(T}>QQxwa>Z+`1Oe(mvLh3o@R=C^Zfyw|Eb`v}Ee8~vDD+6szjcT>@ zcJ++4Ivkzv?7J#W`a=Jy3J-=!9%jbab{y*YxLN4WfZ@@3^J;0LYQ6`NF&BpxEQC@e z#yMnxqW+Hp$dsdj@l}P=M6uDISDFACF+s5L5w%q;(epy*Pu4-WX^xncK9k_@SVzT! z=s&c4r7oRNyvS2@>O9U1KMa{jF}3{eFDHzYiUUa=6qEWVYksP<8)f;OJ4~KX){`OA zhwZ1#iH^q8h_g)h>s*=SLJ6f&wLJ1-Fo-F(-Gq+oX?|w7v<~CX5My54t;w{ww_XB0 ziGuZGi1uBFRNVwR<e&6>=u?zo^5>(3Nv_2;;$t;i`@jF% z*D{~U=PP-bByMY)f&w7Qu|~Yv?u1U$e0a^2O_U3(^H6>>&9-WvO=#hTz4)XYbF^P( zIs;U-tzGJX>CbwYRzY5PD~P@9jD$p9zzykhOiv_!p?9yaivwR|mEz zTizKDV^^E891)-9pq9XE22!1RO)UvLBWtZ;gSO00rgzYTGR=TA_M*y z9EPV>pG!RgOJ7Gu0=Z;W4bnjIMfx zF;+aGthk)8x(i_0VlC2$*r zxu-MEdx)qaKUkAaO+w9@HE*c`%nHO>o0QU8p2;|4vKj_0;F6&}fN8kDEsc3w)}lO~ zijA4LVs69Ot>Dj@s|rmNY5M8Q(I(kH?>z~m3@;19)h&nS)Y;PwH0HAHH+e{9XBC(S zj=2bhN|>RrSG{=KeD(>O<$13LzF(V-7tE4K=uhIzL_* z4T@ezy*a1ta}hQd9wW9XmAlMHiP0F4p|m)@t-XaQ$g>WHP>~%49N`M3ce|5en@yF? z@^9W_uFOFV#4M!_RU3laLJtFDe9O~}U$1sa;C#oZoh{QYMaMXl1IGw0|6Uq@?CB;7 z@7n2KqOCZAWL&zc(lHmZ=p7dZ6z7+#i*Pq%m^EJxMWv@ozOGJ}-RJHt~F4qC6t>y0{tF zJr%x6A`m%P2koUAHIDo2??}%C{}T;mN(5MvC+N`{gWT7rH&6Si@ zui^M;q(16n;7+JWXm8#A^6P1pmMvXdrtq2`0nL`cGWu7TQElOjnaOMzASYKS#fYl!52%%WPCkG9p;3@_H*W9hbS5! zQ+q`n;vqyfPjBfn$)$oP{Brp*-#3rs9_}=qBC_s&c4q5H#@Bn-Tkx^ULP2_qmiG4P%yjrk6pbnli{Cj!bKWfE@9TT{IN0$Rcajx%pBZ_`dvKD! z(=;K1Do~RjtgBRE{VUfmPtC&Qr8&Ml@)6*hW|F=qXK}T!BO(muvd^894^HiB@66Q0 zWC+Vw!x)=d&7K&y24SL(VV)p3(HzTt`qkL0JiDQ+8_dX{wx_l$(ZbRkuIv|AugoH; z;5ohK>*=qHK<|tcF330f{%lsE?;Y|Q-B>fP5BZl6Y@GoPnI2og;o80P6;~Rf*Yb~<>}FKO zGXBrKn*==$c(f>Q9g^Z?nnr8dW*jDZWBq}V55T=mi zE*SpfC&;HIgemeT8U+K%@kqlB=*lP_*f{8`?gt4U+`xsLK z(!@L)+4-*z&*b$LiNX#z8Rw{-^%XDBcB|dbri@O>eR45HIIX(X1y%^rmp89*Hv&?% zfXFkyN3yrskbE2~TuB_VjsFz{L2*j#Md!~N`J$rO``OAX3}wFgrOA)oRgV!)YlYYp z*dl)RR!F|`<0hA%+88QZJt$@@u?E>5GR0M}*wBll@MMI|Ph2N00gU%iM?yx}Q7=*? zDPKOG7ubXFxWY}cg$YB6-a1Agu|>A2tc#sL{@hN>&d@mVDi^gR8qop;uL5Ej#&O`+ zvn`V(Qy)XmAO}vT$C7ce7WWq0-ftH3Utz1ZIx$IoF^Wh<1j1?%MG?_U1;59KFFq|@ zR+pZka2@thVLd~vlMBmIn8f*6wE)Bu#_HQP==W;?!YeovV5D>pHS%Pq zW(sHW5axho-xMBNcVJ1Wg$3_bR|xGmwKI6V{!G-!^YG~|c97_Uu?*6gZ=NxFv|+Xr zV+JKMk|$F{G4V2+tvvr&h>{|fF5epL{fSW9Gl$@|mrEXB| zbzdUPy!87TgJ1me>8mjUHkc@iR=Hg1lkWU8lu2{fagj^r*pF#vk@ z3S5jG=x>6)jAOxtIRzPOWlNtp1qm$WLzvCUB*8}S^Q9h4r~6(-VNi}3sVD3Ra=Le; zqZx%KXimNJCRc$qisZaV0ob`&%j;|1VZ!RMLDVPM$(-J7*db>h67=vlZWjQ#?@H$YyA1#!P2eDnN*46`~xCt z03yZ$vy7HkCBdj@jZ`2VAP5+7xY>{*gcR`!-nN=8<)iL&?3rtFasl89_& zugE4Nqp~;ILg>7&`}_U<&-wk&?|UAd2j|?+?)&C5F4uU!UsFs#;oyN6!Prz-G9Gz( zcMUn}>%F3osFKT=!2X=z1+1Wj-&cNB=1X6zaJ64vm-FK{g|c+^$0Wo3&k`RvFam{V zusOYrkxT#az@P&H(RT`Th*+k7;FQ05GT1{EFnuYy*%Vf>3iVf8(yb3!d}=7`s(V zk(R6xq8)jF@gn$Ak$4$FN3+*YVS6P&6w^Q68$lL`<3?HMb6AHZdjV2(8D7hWcOOM> zpPip=`4J+4D-_mwFIxeq(#~L5{x*GnSc7;XpTmm_EI-*)K?oFgh(BvXc9+E{zHU|l z(!anX;3eDwvhH8Bp@=*A){7;>YjlEkx_y?;xlZUo!6>r*vMj)i@h_jB|Jk~5`WIsK zE`d+X_lLxo-PCXmoyWpUp1CmQ=fDQkm}VqoQ=rV&BRlNSUzW{Oi<8H@+yYkR&jntf zZJ8r*9E8f^Yvd*AGTEKP9|3`GMb?KTJ&V**XgLdp7y{Avpz)l|jg{#3ses_58}9+T z?_ke_+2cFE$JJ?%<&15>I+!@XS2^2ynHvu=a-{$W--dihhTD;^AsmF611x?lm5L@= z$^G=eo{_Pib{&5M)@ifGg@y?W2)yuS;TDBXdcZ%LnevH|+$~e&v%!&d90$N#4ebVC z@~HQF)hR!4QqBTHa~bL+oW`wkqftItxYY&X=!DtpmKiQODUgZWiZF3zr%aI?B)$hl z#;K(ZTJ~cPo%%4R>->JxAf@j3UvlnDA-QX_z+ndMyaDH;n-pCw4?j9#^}+TTeE-iK zX<)kO@2Jk1A8Gn~=0N?2A{VHWE7X3za9JQOD6i(oWZK*>*_6J**(Qcopig;N^u9bI zT4kGNi4lTm6<58fcM|xVGRxtz-`#YE`Mknk>wQ(i1=ynu+?818z8e7A*S;23-QPGq=&|7AdCK>Em%1Cd-@P z>`^N~nmwL}v!t<>Hiyucrq{z}{ea9FNjZB^AW)Bx$Cj?f*sTBjQ#=2#Dk(HLyl{lm z5l8S6@h*}c#Bzr-?kRERUFUvn*YE6iCErknNl_Z@0>3oDCuL>}VQR&_L6kR$8kyZ4 z0`>cO2wj zTuYP|r%DYS^D_DkNP7eZl^Oi4LsLaE;2N5RJ?Ao@NP#T@3|JLw{2-5WO~NjYz$Gou!P4tjDa zJyXS@YRg_3hR}{~2w>n2m}KDhp)`61<`sSX`i$ci_t>NjpulW=vUSMxHkuWQd`$!+ zR%!hp1@EmrK`D>A_E5DVQ6~#3%_irUbhcHKjBacG0A%1h)Q5gzrY<3p8P`wycAgJs zLUF2hPU@1y7b_lkK~GH6O{Bm@Nli+}BFg4Dz0Rd!B?IE-U316>D;Jde*m1P5mkJO1 zT1`Fqe{RCJ=8aw}vkhTjMeLIBXAIHR0gb1oLWZwRZ#n*+7Q70Va7U^7G}5g9D0mRK zTN|#3A|jkJmg42Qu#DMC3w`4BUG;k3nvq=6twO$FsX8L5J1sKT&d#zk*3OBC)cbNP zO*poE57YkSNxwNqY|YSLj)27es*~P~ z$NIPgR`)i^GLBVv9vvQ}HFPxCN-2)c{HCm*UOZ4Rl6h2HX+-K#hq?D<;OfX){05Prd; zD$RHWCqk1rb55*e=+)bej}P*EmE&Wjw2T5Bo?z{Ml}K0o=^gx$++Xe-c^M- z?s-Nt!X9Ribq7-vU#WbMat#RJrfOVg5##;|0TUCsi^=;b3FhG$JqTdw$_Zp*m;aUk z%RCc|qvuyK8#TO%%)6@Y?|39APJ}BMrR@uJ`#a2-1uJa=sB6u(kKWJE^t72L&ZKL( z)IN7x?Z`d&=r98vhiZ}4joO0SFQ(*;oY%4#@kZX-v&zkXv|diu1DT)1Q560~ev+KY zF#tJJRTe=#UY<>rLLPyQ6TnyBu4d`p5wZZECj3)M_Vh?DXf4Ftq=P)@)8x^n8E`Ur zqQnOtboMi9<{O*ahPYC3;is^VT@Gt=syd3@qpQsJna}T~80C=cZH)9Kq(eoq_iE|B z<pr2nmf+Y z$k4gC2~n33PLe7Fo`|-VFa`VLk=Zicm`%5b)@D9TYEhXZjsTuBlfWpGXi4v7!~#!# zWCB-f^>j+$ z*5tbO$c=~H+>P*OY3n6+tXI)yU%N`0woVwGozw({T6Vr0df{r*pj+@!w^fC<8^W>) z=spK#c*|ud`aea{5e&r~HOZ!QcPKLtQ#ouo({F=Ui_z8fHJ^R#bKF3YN=Bp_i3fn( zlxa@yW8wfE{*UN|9g<4F@y$*lGSt(_z&>78?j5fON#h%Br?=|HwWgBg%iX>%9~3!n zQWElvG6@r$OH;qx%X;5)VOhM_XWDB^oZ28FMhm!Eg@e(vLk9mPVwTq_C#GZH!n(H; zn4IXg+~hkN6kLYSmJq&J?1A8u6=n~VkVaeC$|;CsuJ+wBB>cCX*Q$=rc~IIEKBGXE z%8^LRZ8PFWcaioL-F*qB(>|bVm#k_?}Q=}f%IHwtS5Rh z44qi7tU|2blosUU?W&XNJ1zv>#A$SP^p8>^3BFW(2R2P_EZtYT8D!B<60&-lizNR{ z46vo;9LcoWk>c!Ix6poLRCOtzbo|E$=hSj($ym~7TFGyWNdqgcOnSLweZ&!zMu ziK1H&=2uYhBY~vl?A^%mM8z)=&!6h#jtl8HN@65hdwn2PkJw3W|0vjkMXGB!ek5JW zOhtob1BbiCkvTw$Cg8?dAa4U@0F{8-u!hj+UX9k2D9M@2`_T`loT+ACv(Q}rO02|w zd;BKi;)<0tjHeMK3(Z{~giXB6oVOG_{?1R7pT4k^3kt=MFxpw|t`FeFp)cuWrg~Xp z{cpwXj`Rhe{=W>Xl%l-k&M;Hb4 zVU@Ur>L>Q;EE!tQe(8@v;74vPb9B*kX|^%pA^1@6EAW{eDYCltRO#TmeI z0T8jiB%0%U23EQuJdPA*`|6yd^)^a(l7G?L{Na~5bNX3eyps>btx351mYE(F6(!rO zu?L#tfL+-?l<{%_xp732R5qVvh_R4TU*pu^XbN`zfnOl_` z>pwsN>DuMPaO~rXGW^qif8&QAF4ZNy-OAPVSh3x(GiPm{rsNv*H0VF=uC76BciHbd zqG<=q&R0+}Gk=M}5y#xS#TdBnN}5k}WZpi4G7g2iZ{2Z$bkPAk_iN@Jjwg*>+4ejV zQ0=lMCZ!WPfL390f6ai@y&7j zPb2FOj2?853x*Jn%-LYHQsvN{DJ~8 zs80ZgkLpu$yxDfN3voR-{DU@HdYN}0_si-PM|oAP6|P4kqDQf-f=^1lALW)(cBf~( z&|tSWW*@Lvdu!>51L|GRx5aB?37-kr3Zlb6CyOnnhNrKZ^I9xGPsG01$=Lf3s!m6w zq@u$AM1YjNa=D=CU$+DOLZI|wE;sSfwY!>@!G zfL=ORZOz6lXHC*4wcHAogljLkeZ6__aToup0{kj7N#I?3w7*04*8Yf+^_CBMl5p^dfDDzdY;j%xoZ6d?lJ-cQ-)`&qvoFeN{AjAvF9GY$7%Y$13y0P zwE0+GOc(2dgoT(msjhp#W#NyFkn1zP33Y)}@u^DKjY`{12_@!zl)^pEXN!!ULABx?s3hxO3Tid&CWAXtINxssO-Qa&4 zE>AeJCU-kydE3`0A=#b2S8M8e8Lf#~uY~?C#ZuhqAhx8bjO^)%TzmA8g)FpLM=Rz{V@>BUG zu~nfb{J-7|uhom8`nE}y2z0GEAzbsqrT3pzBKkGHQVQDqvDj5z{;>Bi+p&$JYRUJv z{^|N-MSx2+In)f{IWeUXM4FE*g`Y14A77t*f`k?s7h-WZ(%U9d@3gPanmZES_kH!5 z#5WCsrfgH(=KOHxUVV8gaoZ1YgkEk!(U^^3*$pZr5qzoVGZ$j*Rwr&IM*0dISW=D{ z+8vnAKZJF6a)}0cXLi-3FU*eIR#^zxD%xklo{l=Y=MCGQj3=Yoh$Pl5`ry@eNKh*4 z5M~37cNrsIXFx-G%w8X}uxum-CXEHPaFriSDQ%!H-p?-$8UG6#RF^4K_nvYQ4)l|tJ|O`VOrLf+s8p@lh7SQfdYei~dNc!xZdG;^21JFk zFJ3j?w4sHGIoN?*2IJS|i!pZX#4}$6ym#G|YV%WY+9Yjo71FJ}mT&v2CcoY5XV$DV z=DqP))(z4tFToTTbwA+~oyF&1T7tD;|?YaoTJ#f2^)+=2qaKP zx6NW?HJO)$>`F+(@bUG$-9<(Lp=;QLLvmF6Qim#>DDMBd!S?~OH^Q9X` zI=R&jEE;f!JC`vD{y3k!|Be0Nd}@L7Ij(4bYa6puxw|0{ylt>LKe?Q}VXy^fvfxdY zG?sXRjlLhRB2V>LD;%W_>2PAL@|r2OKU{bn(j5Fb_vu~ofq6|TQ<~R(;to00yc9CR zf(ool`UJu;=87*ailo`055gECZd0QKS$=TLxMwO|y(|&zRG$nM)DP%-IHuLN3^bU@ zW)m*wwuEC`*v935$?)oo3&MR4izh>l2xlqJ;~0W}KJjhKGX-3RUsCUg$CM;;-V@7W zLY`M&&ASubJ-+kV`^DC1hI+gZ+o>F(%e3v0bz2wzwD_vLY$(QMJ#sdX=LOm4mGYt- z+)TTG*Vhd1tw%yuf~_krj-NK~$NumkuS9?xM>o`J&CRJpD;kC`vtORv(vRIw1gxTT zZk;ouslSJD5RbcMRq>4mM{-q4JKQAVe$3qc{3Ao zzR7T%>{=2u%8$vA%~oxaDd?~u+7m@HO3af6a1VY|*9J**-3h>qmA-ef9>14aF=7{f z@RGN?$F7}FJR>G3wi!$xw584gL~%p`FV(~ZgT6Q5{od_hEs>S?P=1MEu3LU8-~L(< z0iyKvm^s_B-#`1u*{?TS%R6y7d*BE#<{xnWp?`b1?u&jxRa{o4Jw2f7RfIj&iwQUG z*%~apiyGhjEX~pXIr8MOin!6<6={si%wZu^@g_fSZsvw~Jv1BI#3bRdo}X|X3wb67 zxcw|YpN8K{aQcIbii0~)m z$!m^qOtn8VFL{{jRx$~jX@>~5*T>tYSPUi!2lq#!HwTfb_^EXN$7g`mzn+j%zx#Mesx(Q_ z<1B(V(&L(pcW%cu0y}9 zgn37UGp)145juOcpNhOi|K}^l*ksKjroH%bd*f>Zu8d5t_3K{P`ANW`qaRLk+5qv# zVg%a-Sjs&KFk{~*9GHzdapznjq(Y_qG+~LdAfaMmVtf(m@2*70Ry)RqT6<8;H2!zM zHfrs!;FC`3LuPK6_Grb;9Crs@w`XPw|K)fy48>SV-l)$68NA^Gq5B1*L=0)<`K~GR zD%oSS_Fto`h`3ifbXLzq-WebGQWG3fTSZaX1^;38+lf23>NN7aY+dMLYOADOe3@GQ zJ_*XlALBfFP^!>!Yy#)Qy9ZX7m^lF?7_uyNoc_WzVr)iyH2k|n^*JY_ME*a`Zv6~tXvg__t^i(S3-U)fD2m9s<@ue+*kXLOjNcgvF82&mt8W_Rd7wIw$!39 z4%V9gdYAvpM;uhbQlKymRwsX3uFQ}vb@6)h-MjzstuYxfP<(&yN&b(o^zUzeofzh@ zYbMHE{}12t+C6Rh|1Z48b6O%L9%o4uVi-F@Djofx8b!vBIhy}2924T&zn|~P!oj%2 zxD9}2D1zUc!d_pLdJa`u1cYMSQb*sK&dE9;oRSBS({HNjZWknwVB6=wsc<1mP7kFG zs#SPYG;YJw-$3L@jnfkh&TU|%vU8z={KYob+^D5cGUKzNWUKtJ5Nr97X>DR5P9TS1OZ>3cGqMc}>wRj9Z~KWB>bS0$C-Q<$l%GKN?Y z+a!EPFbv@I3c=GZXIi{|0m*jeuHTkPL2eC@(WhVWOMdTtYQPgbHkACyeRi`eVp!*x z^snjpGWnU@yMeGO_8mnRaMewBQzZJ3b&xN~M?C=5iqYsMpV%8RU)}o!zWj19%QD96 zOhV*>MCmb?8PVPkPunH9p}HPUJ!iNn{hRScm?tXWGS^3j@P@bB(@35M>DC)%U`I9S z17ao5g(qNtjQ{9=ha6(JzPCRudx==q?w>MV8jXWIU>+f#pPxYv!I=s$cRV6+Pkj_| zGY%XA9IrPxXuY>vlKPK_613G*7k1MBmv0QIz}ADsI4;#9?dEHBp!j?RRnC49p|l)L zeOS4;*nG^vA;$Ue1nf+9n^4i>#DZ`f@k0vKoO-}g#l!I|u%LUYmHvJBl#!(A<+;IWundi@`N-AASPUdW{D+VcHfw*ai&-V}g;4oQH2 zk0>!Br@=tMgy1p6A4I$H447|F0$s%UB(qJO;EFWt#edE&t zIhWs95aB+FfL0uksFN&sNOtBKv=JxAOM?7SkhcLGY0qU7_Pb@Wn}|$WnzLhxg5>2m zUsI7PU|mPI!kS#yJr`sv599u3?p!%0h1-;>dpTI{t^v6tdvOGic#%}7C?Wm22@DYn z>uVzw&Z>LYqq8_*no;^rrVf#oq)iESl|u?0SvmRIi)rd2LCtV|&>K8t7?*L}0Y12% ziT@MiN>J;}0k2iQk3;8fa-Gvm{re9AOoPQoYwexPr)7>tP-PKM;0+w?i~{70dINyzN~}q^;MM5xmCKtz5Tkkl4U8t@yK%Y6ofdmx*c^v zjE~-Z)giGWy05V@3^0sV@hP;3QmBmYPuNxT#lc|P&{{|I7E=uCrYfK<9I}1%_F+FD-Q;&|PtQ zSL88k{iE8|d=nilKZ0|)n(xEM zxl3M|;cXE8n#N=5B4eURiPlLWy4?U7KdwGNKyItJ)}Nn5Xu96|uPlJ|&06lfq9<#e z*-VZ|fhv(BT{EdcmOi!MI99f!C-s{M8aO5Wz_Y^c`6ss1*F2;WK|*T+mbI zfL$@iE2cO`t6s_3@FhYZR(H9t7uPH`KK$oeSt2iq#7CrXr?VDQ3vjInHI_lxpO=oS zvq~)7r|X|J0N_h|R(-cX-IEIQB3l^qGj7ch9o(VdLe2Z&%v#cF}i1jC8>wRpPa=+j&&c@#{;#^gY?;%LOEK=t|;k^{3NkUo10Y)dzxWOJS|NRntraV_~Z?_(f8T4f}w!ccQ-yO*g8KoKhA#S zO6jv)e+ju^x;i8N0c92uN)oKKgCd>I0#*}zxR0un(T7vnwsgMKH+$Fs;}^b?&^rUG zBC{*0x3qKOV}@=&{_!grpUz!n zR9-vN3A^iI@S=isc`KMy9W5NTKTR|L>*;mz_*|q6>pk!jjD;GZuyNd+S-GVqti61j zd=X9uqp(S~0HtaKRa+t|xSqgJLurx1$kPJZRZT~~)`_Rt6P74X5v|DW6w;l7Hx|ni zeh?~d8YaObGh$P8Ns8!<`Qnl0zQI4*gOHUrCb{U3j^N_KA@7F})VqT0XLKkm2oLtK zwInZyX0=f;h_mV-dpPa_w82I4%AtjiYdcm;wr7vPZcM0kxqQv&L@~GVH`r?O;@9i( z5wG84`YKNjG_DM1por=XE2y1%5#vB-=lf)lFRu@fah7^ zDDN8ldZq6RA4bASZQH1#2R9CiIMRL`*Y#462`tN2uHg>ZiEn_rRKU1Eb*iS7&{juE zXpKp8t8TFcygg&%^YaAjhFM$He3CbZ9o7S1r;CTcBr87paFM;IIdF#kWB_-FFizfH zmdOv`FI@|(CV6^$#*^_fN!N3V7rLxaiLz=6SXzlyes*6g)*nE^ssn7n4aJX1t?xXf z+P=%YX0qS*c;NNxW|<5#eSv?s0D<&sH@UMal_>+~TZTvPlS0fy&BMd6W;q?jznP=4U8uxm#i{d_Na;N z8zyav^scO}Fo?-H4VHo-Ja{FEA)9uyz2kDcQ5Zgzpz)&@f!h^XXB-bbSKnmzcF^)` z4pK4PwNI#htDW zwlNlKw#mcd-8Sb`5eGt4abc;Ver5=*)znjnh24rsBdd-+e)pxP86I zs|Srq8Umpq1-4IH;y~mg;Cu5Eps&4|Vtg-x(X2$i366K@yvpS*+bl^4BDiZ;a=M*f z$=Oq=kXB8wecLf?c6vHz|81^)$~&h${MmJUt+|EyVpOPlu#`2{Hf5Vz(z153js=uy zgdN{k`SZF`{HNG7EC<% zzfmvhCF)9w#DFksF_9gnqmzB&EaiQA7_}p)F_Ty>9ot?n`}A&)WfvT^q=hj*tX!kg zV3sUy2w$V9D(L%Qc@MADR*rrk=DxXya>Z$>S@VICw7I*|gdpP=^66u^i=@nGjNhzf zE?wV7F?9;wlC-X#_M~;*@Bwuec~gn+^-7{gR|Wd`D!Y%&+^{25nW3KYZ>dwI0?)j3 zBo=4o#}{Q885Gz1fBliHBt-;C5v%0BPA}GEOWu*=aB63KR*c!gYQO02*mq$-MG;PZ zY(h+LX%msqYHQ~EC#?5sA`lte1-2_0=aW@P&ixvl#gCL%{h+VwxUfA+cBA0F^-;j| zHSgk2xC|CqzlI-4Ju+NDqmDEpwP^Yt-x3KCnl}H4!z!~eGq-hV*ogH~FDk7&E@n(pwE+AH3N_EH*iq(F zSUsFexkr}`p?9&@Z5fiCb#|0!gd+P|b5f6$Zk<&Zo3K_u@(pL^;eN^{|1&R9J0e>@#sUe^hyW>o74f|D`ET zL;jlW9#=8ou~Z}RIRjYzHM~28FKvU58U1maSYUWD(|#!ou0jh78?ra753pC`L( zRf-coxBjbeZ>cU+QNE?VkCGfF*K2844C;n&3~N2_S(qsBt(6o;gly)W1$NQDVNAMq zBBdO5TbXQP~fozsP8F>7ZM5p4N(rms^RH>SdIuR$2D5Pl?ssZG`L>*YbEk z6&Y@+pRbnlVHzvis&bTKSn!AQaD;*@o`{KFwTR@+Nr#4WkwYBN97n#YHpW#Fqr#FK zZxzx%B{RxlFAN!DiB_z4ULQh5VY(}-E_^6> z1a(agdtM1415I8K&3Gy1Ug^s%uAVH^ymwLgJD7Aqht$60^0KiQ#Kz(nEwC|b*T`5&%r9TUXRf5jRc|KX zzM@vjHrY+L-C9K>uI*j;X>0+qEJ*67hb)I2)#HDQ)5m}P?flaND{L;pLF~7vb`iFD zlb8FINv5L`#!I}74;kH4{&caWTNc-@db%+T_5v*SFOS>B)EMCmb?t?RXN72G*{u8( ziq9gQH$@L$;Ix0dP&Iid4=iE6AFXt@YC6yF<}J#A>TS$O4HNGIX$glXF1~jwr(LmV z$iDI-`XY*v4DK&|H@s)#OQgTQ!CjT->Ae`w)$0O)pV%!NHAUP-y`09ESJ_5{^JCJi z5;=(5rH2}Su(YLIoXvg}K;ZQHV}-6#5h>h3CSx&3l~k+4uRI)4jntp`GGn?sP-sR`Ik`t#ZVWSn)>aoGeU{wctBLuwMIVH?KZ$d zn?Ji9&i~iu`ao^sXkQHT;0DDaSx6`39B|Eon30aCcyjoPc%dZ=sXKll?Pd;OoH%HFQtYgq)M?F%Q{12 zNM-m~3wutkPnj;^xR|sC@Bf7)pvpg1Qjk(3j@cxxl~}zSr4BF|YbeGv>q6`L#_&e{ zoMf<7`jJ``3sK@Vq?vOZXzdN5)or0T7JiK#-ltH9dfyuF_;(|SX!GI;g*$}^5)NBd zsIaVx^TSIQM}}^ETJ;jy5<~5?2b)Kcaol-j1jGHzz>cA^wcA1G0YkACQ_bkdN-iWJV0k|kLVy9ky zW2v5(yuDQ~zH%FUP+xmsomcz&l^}z;YD-j-jEJ^W6h!l4zOGJmcfMt%pYX2tpY*LDpi zJ!ll@8<>m{{goo8RueIBE$8!R%wF#|?mrQQy(U2b0Bci?RTON#%|YH~a;6KS*QmG~ z!;jM8ZogT#SYQmZwM$WhN;(RKOEPc4o~M!EYKTD=;?UvEXf#a_0!fGira4aQpw}AEQzjzKyg<^ z2gln_VL19)8vT?@X3JZh5rubo!%BaMVEx?I3egy`I*B7%OfM+aVs+RHgBGunLK5&4 zrEbv~3vV+o;SRlXzfXB;#WH}Iy3(4>{IBJg_zf@i2;Ap4=BevB(n8axO^!6^S_~-u z?lJ`z8ZR;mR(=BnB8TYn36{^rzx_mwGCNaUC!gP0O(oBUX4b^~vjHYR;sHq4>p+4l z8P0_t_mMH9)Tp1tDG$*7oHN1nCg0!mC@YCDPq3Fv<&!Y@<6iI^npPrlGsCXOz0d>M zxn|aPI+?C658$zBMh#m0rf|;raH)=5Kqrm@^Uba*|7e-~)fg#U6*Y;xSmL@k*z7xe z=lKOE^KYO>b1c$0U*)QK$b_v^m|ph)Sc1dh4D1ovG$?dg4vXHRms~;gOq(@ii@p2q z$W_v~QRZ||g!uw*HN-Va%MObt)HGT~N??hVchUtl zprrj0d2A1Rtk-)WX$*Y!aY736(d)q`SnthK9gx_m#N($%#gV-l5roPzRc5B`{S8<5w7oj&OtNil=F5>c0}oo>8Hxu zs;siOYKlBsf-sickGPl;+^;y^OFh++c~v^@)BAyExR<1{Vs7r6Y6I^8HAt4qm9S4) zM#N_~W-n|>AgE}Z@>dU+2RL?)8NTD$o zQ+8bNRJ-4qN)k~{yx)9!qEc|;DL38zFsMupTwh|4+Z5nH`vz&FL=T^E-lNV`#0vM)#DkH8bd#(XEg4@X;9q#)+T)M=VeV3E%>!JLS zY4NFxk0a4P=Dpwpb|;2YA5y#<4g?7g<`wqhna%{cjSbhik*D*A!;z_fd`oLgGeg5U zN>)FdYj2-2`8!5hWgK-z<==1PCi2{?MTaGigeVH7%SoLTD$P94?c`U$SB(DAS`?97 ziIGXi87*bM|%Tskd>;J zqc!Cr(rlu_yZ47(BUltF>9i$SEbF(hcY7^gd%MYpTemfb(8QwPtM z+n=?~{|i0D@ZVV+Y|H>+97YZEoB#bk|F>T_p#lo)q}Jo$+5bQ{{rmNTkRa!vfWlpv z{r>l;LQFWz;00G~k)yu8G}`l@ZDx4bC}w;XFJ&(i zQ~2x;A?(NG-quhoHzb!{tzJV~#6qg>CjPgt@ZbK01~b)9t`fGJN^wXFUNGY5 zI_&HNPVoMl9s0aK5MrpU^ylpNbSOl$erNaqE{%ss`am1hpb%Sts_;Vu;z6q<4uI+# zvF+kBuzEd7S^qE77CAv3zQZxlX6)W=9?|r(j9{UXdGl~>7eWg|{9p@q^#S8y(f6Lr zg+;YAeKC$dAeko&sIT4@TuQNDu8*VC&IEvH8``TvKw#4JguaJ8R;9JwgNdNcrfN=9K79c*!LioNL2r@H%0{FKGuMP zXP(}(^(&{04i6azHco?W)uY{&Zk=}Rae301Cum{&7#de{DL+6wAB8(B-NwLwxg$=d zRv@q_^HUy0@IcM$MHUu4Ae+v~s(*T}Z-bR)j&QhcG58Sw0+pw9?-nFA>*#KjPx&fRMmkksujeI z^aK(|Go|oblQ~F1X^)D{H^}I@oQkA;0R%`h7McWIrp+H+-~~o{wT03YfoHin)xS!W zxN5c?02Zt30Ms_2!RYib1*+7Xj&)MShFyj{Ea4vfLH}$FI99(<(0)q(<1K?@g9}Wc z&sPB!?g3$Wl8G4uq^wu!cpic1;hg9TGvvfUk?)%V`OoDDCZS{)3q4r5h8L>pO84$J*6+XTR*RupflHt0`Me zn;ZasVHTF0iXT_7DY29B1;-iwF<&W4o@l+vBvs{+76zca6`BYs|7B3R-vN7m_nB)3 zgVfZcNKTGA5GJ!`Z@7c#s)pTbkr^wv`7dL0O@B@AudAYN2Vo)22zLzC)wLT9NJ0(E ztA|A@(Ahtl8~BuP`qjS;c=CE8X5%AN+ENvqt& zpUX^6lSoisN9aGkvdI~NTf@=$#8NN9F`{mx%=%!Vf3*GzzR}H7z*fupl9+2c1RMxL7Wn7-t*ivFy|1mAvL4e`<6%<-u$-iIT;uS3W$sc?PDYhYgzLL894 zyufX@P#vbm{n&|A@aYcFG<=L{l9z6=KZ;peb%AGHwlE4^F*qr$T}+Jlv=HwWJ7<_l z4LK(~+QCg!e~dV^ ztWfcV!6&>cQ0B30XP&~(w2|%8u*v&!hHA+Z8tuPeymrW~R&=^p-1%P>ZDXB7EGamhHW`Mcoo!wm{x9B2$`B~kB+@%CoB+m-IJzNp2*2qDe-eClB=jy99}=U+ubL1bt(d5 z@(4XOEKxitmInD`#Wa(Z#I&yCrYxFM;KyZCMo(C7Pagy1nQo!4-}bT$uhs6#zmM;~ z@-F?8r~+M7`FiexeMn>gQer626Z(yp&w>!PXFSQOVAc#vMi%4#BGW#!6{UHMLFf4+ ziRA6@_L(>q@2b~iZ7~cNXd1C~^sTRx&b+pW^%HV+;5nW(8oL%9G6-k1oz3xgOT{}# z{<$qWFXVpoGi8lC)Nd9g0(bY@zh<>yMJinmB)xGuA!U^$JPj^p6;yl-XU+Go@e?nV z2!jPNQ9?(UzUp$aLCBqIY#R}is#x)vhgXN7AI{v%+w_Q$cSw4ujWzu`=MbSZ6YQ7m zHuYD{tlpab`uvDOu~)r#VbxO-f>DGg7B0 zQAtrZc#i}+d3xEmSJSRLq$`-A^h^FJNyDne))(aVt&qlIEY%?OEn?&d_g@gdOV8)di!t;&0j*5biQc;;FeVQgpcyz68zhR~bWmqgHVY9*O6xwa@Z^sqYM*aw z$F;10RL82+oVgzC0Etuoi|R%%$o$kh`KUuj%?DHO7@FmC9ZT8M5ChMxuqN|nMM_)M`YcRIx`}^wm%rtS9u6l1Q zOi{PemrtrTUfy17`2Ev1dDa?BiSf%-XJ_rt$@K^VNeH?Ez=l_ z-LC-{$(BfyJe2iwafPlD4Veuu=#MYFyo!;_k)^y`ym!dhEEb$i(m1P!KO|vcywJ$Z^J&(jvfr^W zjG>pd(Np*lHVrmC)3nLk7|obx#D!1$jVB$bTWjE+Dr{o>D?U!F>Qvul#0BmawHGjj z&YbtCK9EhHgBHZPm5(LUdrNLZ*~*%2->!D~!;hM{MBS8$`DR zN9>@qXZb(sE?< z)d<@l_!~VU#}KZtV6WVK;k`Y9$O?l~vaG?Qr)?Gt3o-&%pSw3k8J1LSrOWw#pp;k~ zSQ|IO0{Yz0py|==5M%Y=VygsNqM#*l=wEfY%zjJqX17ZB_S@RT;l4~HJD%=|42pz- zqU|2)K$``%F>a1)Y$aD4u=DY87JqR04NsB*qBHa(si%KQ3m!4^o8jCpVzCdu^>^G< zf$S=i15@j)trBwiJ23jM-e|!Y6zn0P!sM_R9}OLJH#CbDKrw#aLraUT9a?p@8mC;V zs9>e?#9FIzs&(CdmXjxa^j>0_lMy+GBjeS&52vU7tM5$j$t@+38lQ)1z@XC@!P`rHx` z7;O^fWmW8RcJR&OP-#0-&oZOxS5G-ZsNhd`v*F5);Hc%&1%EM~$g{yFMrjOb+)e*O zlUz0O$_GC#Vp;^qMSdp1Y2mcJ_UrXMj8D`Nm8qYavM>KEC%%?GtDX5a28?bm+i)MX z{O++(CAJs%pw@7#L}_$4LDJ*XzpE_Wr^?&BV0a!kDAkoGN_vBMwi$GL_U`k5SWExe z^rzX-sft@IPeM`_nip)2S*)%*h_l0BIK!YhP#HmM#!_?CPz!~fe zvE_V2l0tm-sl=`-Bhlr>Aa0GyB;K}`@5xU?)3t?bj*3L!S=nTD4)a+0#qx?@jbZNDIljZW$1s{o=yv_FcF8#dJsZPT)<3q^sy@ zy(_X-jMBRIX8bepEi3cR2pKOqnfT7TU1pjTSfF}x2+R$MV0#BKOAa_{{mcAaW!FoI zXCDj*JQPo%9>|v7#6&-g$7ke781q~ZI&0tiQd@Jg=j|5_AQVaqMPO!CeVLp3$^7SO z9v=72?ktg@=LqhvK-JxP-_?t#xrUe&zY+&gjCFHGE&o!#Qg(eH?(!tIEPHc^(*)mv z0SG#N$fq0p)}zkxA`9uIfQgtafW$>A0!C8`v82dRBoG2$xzqXPRvx+HW$ zx8licy#??+lzkq>D5b%iTppK|aQ)%;eyXNa{`S`{_Ux{$A>&Q;2lqCJGY(Oh!Sk%C z45be3*Z!a9GjUiqLlaS{uYe+0(os?y2`bDgIbUX6{{L#mf) zO~3mE^B#H7GX9hcJGqHs8oY{IT6yV0Q#Gm1D@@vlG!@lLrN!>BRA3uKSYeKOCPCW z0S_d?2}r~JIrrP;=N{I$RN#+R;`fVv7diy?^-4oJI_&c^6m0BUJJ+tV1Yi@;P+(Q; z)RdJsE7(=N3ehggEIg?Hb%2L?LJ@t)8Gjbf-TKeZuczhpElE;&AuVn`05_OVa`Og=sdUfxSJ&3`v;U4$ zVgLA?mc{~W7|Zp0@;WW*U^lhz`g1(WxKxVnA!ve}u_7E4Q=QcAN&g)jq)BeC=sLk9 z=7iQ5^iHtl!YsPFq07FnfBgMN?KMuLih&bSns*N8+}vRDS*XW9N9e3I{=GQpdCKY3v_>&iP74hd0Y4;}Z%7K(5WSkEXD%PN%gaPI&bEHL zF2{p9H{6kKOV?o;r_^Y+Ql~^`JSpDWQhyvlb8F78hzGx-Q*yMwnFAZ^1zRGD!MsA)n8yZoyR7mqlxoR`T~M(iW4$CtFI4> zpQSGufAfs>PrM=8VaByv{Ehv=17jbTaaI45K*OcssJ_nmevvGQbZf;HLEFqzm5*3k zO`n5!uG{n8H?J^^^yxts9zDN7X`GNljK1Hn;q&ZsQe^S;ciH5EFEFdri9g@5cLQHE zfa#uD(B&kYIik`WrC`VBN{lpuhvO4zzIf>*GgQTITiZ^)@n9CoZcq@SXW0&atuP}T zgsE5$)_2$osW(o(I`AgzBrj}c=~BqY_7!GDbg=(jWZ+3i#`^ZNuAXLfL;KwwYP^c; z{BSl0hyF^88odcPi3oUF`MZjc;f6>@Pa7Nl;Q{gF*Fs5r2su0SGC7Ww4JUyNDm71KlHGjAN?u|f8N#+#%abwXodg!^}QZV zVHG|eR*m6+|AW1^jH;^r`v(CL4oZj8N=qXxAtfM!gwiF5lyrMQkw%b%A|)v)NK1n> z3QB`?N*oCRrBj{nzMp62zt%kWZ`Qn;7qk9romVV4=dky+ulS@;x^Hmb`MFv;l+6)A z8e_^?8>=%>8WlOgSTXlv4sG5yNv{=fB27S?75rPqL`vDb!h!kBB!oiE+=kfN)_bS- zW*hQ;Bh@U6FZ9zy0+kpj$IJ`2GcJV^4Hv3ME_wK@Q666yBu<>C!&GXq+y%a23{%?60Olpp!zywPK9$-zy|SNu4n?l1Kp8ik}55m;G`Q zM@CfPfU(kH$0HPO;l}BNovgL};CsnHUoWCLIfnDv7r)W^ln(>ac0h8(^x|r%7jW-i_S+Kn93t-qnO)Ts)vXo1ae>oiZwSJBaD+r%q% zY(Uy7fYBIwI_W~(D*W~9%#6ac_mp^u%d5^pe&3~YQ_(@JN2d5J~j$kfV+6di%-<74aF zH}3Ld8#M1^MJB%`$QUE`LOqEAZnj?dWwCOReqHfi>L#?gSGp^wgqEFWxz0(jeeUaa zlUSRXBO&YOnlzT3>%31JwJsN9BJ+Yk;PThsP*|#+SVY&!nEasg+7r5MW-5Z$EH~>_ z*4{m!J)U`t7iDFn7y3(@f9@Gvpn2bl6E0aZxtQ;@vD*Ba*`~|TUd1b?_%NA8mv`QQ zTMgzPj>{Gw9&&6%$6dC+rKpA~>mis@vb&U}!_I|gkFT4Uqcd2wNvU18CeYgV)Z9sT zdD%^5wv6frCDBN-j<7E$@y4GC5mTB1)UyCoTr^I%;Gkqd)q06%gnp23d<#t5w2o$$ zJGbzv%$4W#W8Mka7p^}{`B-3Dbz8rRFY{rxaadC^tG?Ng{=^7HMEqN0q6(elha5fB z9BTMd0XWq|1M;^fFRTU_eB~95!1*v|No=g{oq}Jf6s%)5lu0+WFm|Wzp&LP^!tTTD z$;+{~UVhXpR)-j~ptkrJe4-KImdfq&kcY)NrM2)7-uS=0GGt(o@M@W}-xc=U4)T8< zfcz8x`Wohh1;FWgJue*zy3M$!-3EMah{c+ zoV|5oC?x&xqb>fm9YegfCZ z86sxZVkD{aQM-D0;ABbhgGF%$ko<4Qdq0*tAp1*$8pIump#5B)hTOr;4mw*#2>_UF zkBhy6kC#C5k1k{AlE~?@VChi3zE%u;_?uaQKbWdyI)xrJ2TuHMg%h+*CvF}k<9G_Az&`S zcuc>0HFA^#nybS6fPI~YwUcIzZ|#++K~CQtvsWr*jAOoqrV~@**_xTZv#x7YTkZRe zTZZfTS+|(DKG0}Aybn^4hm!loPP((zLdB(4)*&Gz;G-qU(<1Zccv&NG1fMev-lq$b zuK`jnbZySO$*>2)>{^6W+qHamaji~f?{1@zXEO=W4Rxr`f4E2@a?rL?mYrJNB7)JNP8gF~?I_M0wO| zojBG6#0{&U>+=M2-_>8lULV2rH2vvb`gv6*FWqN9Ad*9E50NYAQ5~%wFh~u;Ja=y^J9d^sJ4a?jeFAs~x}#Q2QBXaO?$D3$XuWx|Z&W#a zM_t+6m5Lu$*i1$eM#(bg*W21r0T(L?o0Q08J+V_W0P%{PLGpjI5ewI0Bd|5Xzd2mM z$3-{@_7nOeqGr3|s?kU|tkn zpH0H~HslWR>MlehngGC_vz6;++yF^#W}E%R%t@$lqCx)2c%Oj?R9sBJ*mOigf}!02 z$bc&BkX9ejbrj2~h9SoUIR8}1o&7L_uD$(PVYvKfLU#J3OBV$DBgO(S4IM_$c-8a8 z=N|7UBQ(g$F6-w-7l#n+m=02!NhK#RU;czdh%Pmf4{h$vzv9xQGCW4u)uJIeyM z2&+bcN7ZE@n`vCUePemtK_Xmu(>744GLEgZmv#oO0s0k-+%*)u%cVikyD=dVY6=5Q z0J`e0Q4(O(;M;YE9(Qo|M50EJ{x)rwC$J%ow}76#MIqdqOcnwzX}R?upT++iPr>s1 z+3(H2OWTry)9cWwQmMY*xd(ejS?1h6zX+Tl4Nd}(=ZwCTo1rMMuF_GSY(uEMoOXvb z72qV%xluy)^4GTLe>dKETanFuCvhF%LQ6i4OCAt#maicra@`+^P7LarQkj7aLze#E zK}~kRP(^hB-}rJFwdhc1ymuF%ozmY#Fx#u3Yk{B$Cz~wH)Xz=UQ9>{t^jspuiLM07IC<;pj?FBj{e{h3EeA zRrFAnG=pR3yO=LHGlE^CjH+SWmbf>Leu3wg5viey?^8skna^~2A z5$fIceJY%ug)e&ofel!0tpY^cV+RZfG1^o;U%ylaN$+Ecdi3NJ+@u6fVg!0|PIa49 zl2FO^p%VQzRA1c$a~xjJS*nfsgZl?cr`ii{%mL>zUr+S=`LI!edVzMrnyO2D;i0-j zq2>heNm=pw#@vd$Je%YMC%Ih;AH@C5mK)W-Wrj1K^HRxHtomn)`UTI>vs22WXUDv= zWWo4~7b*+I6vk8CV`>B}Sph|BxSiGCvc%{_wzy<0;KC64(gkR)$WzL%w_H){&w|yO z`S?eD_wI5CrFpXBI_Z9Ee(CMzKcRb*XFq;{ltCG4-sBb&eU}(d&VWs@WGDW%-XVH4 z(Li>f?b6u2r;XAO>uvHHPnjR@2=z$e^#=%JELit?gb|Z~T~r880}emqyNjTUR7O%x z>yi3M%Gx(xKK^yNJDBF3ZZY05hqObw7K`V-4(F|Xr2(u|s`a;5etW6ZntBtBsppYv zYNzr)A$1w?`n`h2LwDb8j62kPHwA_)CiF_;>FBO`sSMCMUh`3idL?O_?0 zdUQ*EK>17Zj zrS7G6)@oG~mWWUH8jQToZRB1Y_kK@@B;eEm<2h4Y(I>TK=QZ1nA2}+!wKU?8y76zN}}_M;;|KY!lt0kNVn zDWK0wP3$0K!w88wVVj+JZ`ug#T1>a2J_b}T= zo0OeN{yxFFqQjl;&eX9IHz)#f#?o`aZ2oSC{#>7+kq6@9t6diRmHOr?YT5Hq33v~~ zw{)7TXVAB4m-QOjW&a!*1r3awfeB~6v0>)gvhCG2oB;>rTI3{X8XoZ`)ZLuKFfH$# zY+77I3rxHz$&69^+fF@jG@fs|*T)#W&(wJ-8N8)4ko~)fU{r_L;T`Fp4PVhI7|Xl( zQm^d$`bnjTs}~xIC6*IEOExo3Bj~5zY{k$GUsv7sh^<5UBj1T%kOtrCUL#X^@!nN zW|P7d1zAP8d2svsppNKL7s}TNH#vS3@iiByXXsrYqr!I0mM3{d)`VKO>N9ayXsGCz zV~tfa>}IUEd%vn+ozBzA{Yv!or~6=4B{PM1|5Dx#bbj;|Ub7_0jds~U&azZaIC zoTSyj;cbh}N~LsS4Jr968`L^wUPiCwEr}e@7~%h6i&-u5SsSmJ0Q*ExT&kIE!&*H8 zxU~tGH~d1eMSUZ${={@ivh9lZw9-v6U>BrvR&GuWnk#e%2+^_o1%Fqt=-fe#u9UeW z`hoKbzBIPWiO!)jdUormZksfI&E{ws)J8+`xlTts#UdrrYwXjU8ZIxTLL#)IM1}4? z(|#TnQ9Drn-e?C9k87wi6x2g%ok;x8JQKy`W3kQXFp}OxDosh2>E%m`ip@6!LWtNx zBK(s~Yx~!OB(|CR-Wj3^y>G@*1$wgvTn>s3^Oz ziGK|$W18osaluLPrGd_AU|G{Pdid3Q58|{AJ^wyXqm45ksRmlgf zeNpPUysE&%jc>TGwtg+CUH`1Z{6xG^6EoA|mj0M>et#m#&<1!gqkh7Ep?^wy8Shx*fYdhqd+)kCf{zq#9h&n>ctUZ3J(io7g*M67 zQAb2@Gn_2A{G}_Q)Q4|`LvQ8QQMN>vp35+|f2h)xQh#d|?rR6RH!MXG>f5y@vHlyZ zPP)PatWGQp#_SuPINQJe>_AZ$tMgrGKF2$*r#{(Kaq`8gQJiP<(h1tpMiKqs)EBbk zz26@s=lMs5zuW0!zkFNlZ+vB}710$+bY+?2YTP9YX_uU;{RGQn?Q z;H?OPZb~{IA=>W`l_!*eS{wR*q-3wad=Is^ymp12Y}`-DgXH$P1-`ubP}1d&X{30c{_tYcDmMp$ls<>B|UhmQwj z-f9+Ow-dN3-?+_Qd6f9A$2srK$5nT&i}YLpoRY9$M%!op4VaM<)Nqk$iQ;;{^^B9y z3n$w8jST~4PI(RP4moelk5%^(6R&ghH~kY$4GJ6id^C4whH31xU&TdMh8BHpWsI(* zi=|H4`4Ced;xF))6*8|=1*(6R-_a|@M9MAu1dym}(v1n1e7w$WJo|lnRO|b_PEyW+ zr1G|=Eq(t+G-8)0T&)w#in+&0afGFw$2!@T!X)(J9KoH(>>Gzq;SAC)3r&LL&ENuUnZ5JDAFCzQE?>1u)H7_-l||N ze&~+|L&ww?)I52@JwnR2f+-J4qpXL{Gr z+xB^?@!TBVoZn-@?86FwBfF3KTjrOU-*>0~&aCQ?_~^ZDdIHhxi!b!jJjh6NMePLSDru_}jxAQRs;XnQQ*VG=4GSJj|rLwGBj>1LrWJq(&F&@qt_0t@gq_PMiL#EuRGO1WdJvMv$Nta;@?$1tIxUJ~q}T zC>-rPEK=)Bhu%p1?2xbLWQi#YIPrY^@S5Brb!!BN^5JrS{}sKqSCAShJHyM1TUtlA zC5vVVu8Xz9$ORSig`aD9!c`T`S5<;-s5V}5x-_~?88UxC^)ZoUZ@6cLDvFw4i!ZaL zp5K!?MH0tFYjxc0up#55kL-WSZ1ZF8#H8|-~ zx(rqixD-%vqGIP)eEP}r^%52Ybc8Dp6L1P2M*AGc1MGwWT;8<5y&4Zw`_&3LTc}Q_9yFWbaTH6y&fktmWT8tlo{6>u6=nW zDQ;kK{((0q7VYw!gVx-Zn@>IQ)$}@=Njakjf7~$`JL@R(YMSFJ?~LPxHh10xi%*Hx zoWCpX4z&cHiA`+Z))A++w4DJ-Q}G=G&#l9`^N%amS4_H%qzpODU5G4;T|GY%O72d^F4B z#6G|%hV|ZAkS^09)JZJ!44e62l$8#%fRRjLJv+t%T_RRt3X@6w-Mq40svRExp*oq% z@vo-wVcc%vJg*LY{lP-w{>Cv~-gw2bkynJlsOv1V&x(hk-%Boz8T)M1+~h6k3-8`+ z=Vkdg=ylLJz7pzxcHUv#b|q*gmKT3Vd@*BjNiVMPlyRCicy zXVDA({-v4Pj(d05Iz=a5p9KJIig!>36kiIw8=#nrek765(or?xcx?qJe~R?2{kMvT zj(q`EZ!rp(p&LAQeFEK3=L*( zo_?Op4{(`iGVlwzt!CKPNo=05BQB`udz!&<42RP4hE-oOs?R3rLgqhx97cRyDF38FES?4NLG>f6R+>vPi;{`l-|*FCRLXVq50%a8v$sQMD~GD@yXR{h;!^-vSlddmCVb0*L1 zF->pu&ST}8WOz4bzDnVvw#R>8RFDmNBvs|_E%!JP1Zj7Sh31pTOwR=+A|W()gW&P!yXKT(=g+ZIAA+1$!=^#;MRsi~}j|r0W`K$m?B_Z+-0a zcqcHZu8UA^hwTgZM%^$rYs0aH6_)rng}0lCYIBgcbg|4xVFe#?bbwglkD+;gWnO2cF!ftqW@ z@0Dz-HS+VxI~qaLZJCWH+Dv}OXdKl#Alxo=1V=}POd^{$kq`sBl&dDU&#D@p9&yN+ z+0;`w4`${CiK>P(nmin@zUg6C+6%JwcvrL_vC))9DACADgH`P-+(3gtOrPw*^exvz z7TKKV=MDhQdN=(QaKBKTIR=K%afvwZ2N{u8;y(dmB}z&7)mY9VKXkdaG0{s3)sNrn zE$ClKimU1|OeOyLJG$url65cF!-2U+9s7(ty%$Bkd-sjdht3`MVg%7MgJPX{_f8d> zDpQ?I;|3X{T00ZgCF?uk<%+7;n$$2yU*Ego`4jfuO5dKjqcxCN_NDH@XVlU~qX#iv zA^<&mU*xYSs>f%cOWvvMC%#oyrRo=jGi!>V7ZEzVbMGa(^|m+Qe(v0@)Xa40{bpLi zh)@1N+t#p|kmR7&Y;3aSxoC%z;W-Ql|P{%rx~Uqb>UUJes7`;^d>xGbV@rCwb#X)(m?6k1#aLgr|LE`2{5xj}&Ca zd$)p$3pyJH=Pelc>1?N|ri@O`3Fe6Wx!%O;W&U#Ilu~E;EJ2?`_gV7>^=X|YfavZn zpMA8|Ep;)lnq3~fZ!DWBW98wL6Qk1g_yvnnn55%HH2>Ysn(scJdv{a3+Rsm?jWLpV z50*FGZIWxc>L|Vcb8e2KxwWXwt8owiikA7y`7-5IE|%0wExWg}uB7;*-|wU?m`9YB zDlZVm&Zq1$q)R%+c^{+{86+NZc=i3%-aOrG&P>lNyZ*eNq$xxS@Ic+H>Uzue*UG~WH5#^mHO#!)qS<>uG^J*we8hvqOh zaVzy}6!}OXl(DC$7Q*vLMYRB`Jq<9|vd|DOLKTubA7O)9FIU{NN&T)ocBAE;fDX$F z5gw0$tU^^qn=WK6A5GkK$*#}I`^+;fibq+Kr!xqQD=x)~Jf1&y%})14M(MOK5%To7 z-jY*bR7sT}`o^xU&X(gqu5Fg(K0t-9TjCq^&^Gj)ctOQ>Mc%B6mzq|LUab-2Vk9W5 zj3NA9Mmy@!nZ~}K$x93B@1@ph_M~Rmzd3c*!Xxz+?Z-YttoFi37Y7#JX$9)W-OYj>0-475db}Dd{+$SXCSQX(?RR&q2^wtwPjnXRfDb|j z`fMA!@cakfZGau9J29f1Ac}uu_>hYtjbC|UJNLz*@f~WH2oIWoJ}}5Ua((m2pmFIb zim&-}8{xdVFpEHz_#k0O&VRSZ|KLNrif0XMduV(qMmR!Uy+W3=ywunPi`_?1Rr~&L z?dt9@jLaU*+*})h>ha>AvUe*5R{cVZ4>}-3Gx~{557aO@e3zYpFOYxRVjx4o`CCh1 zmF%js>OZ|?(?}EJNg8J!*yEl@u)Gj;=H18yk&@bQ(et1!zY1DAS1F%#-Q&`ciK>eY}#>WrHC(`Dd z!oSq`hTFJgSf$FxU*eT-l@3PxhhM)2$RD2k%$-`oghw_w#8&PnJ@5zh<&*Dbds+W_ z4=3!4CBUu7+t3XR2iExcZ&ktGyeb zY+2jR_D6#!dAeJ$c|Bhasqv}rmjVBpbDWOKm+6T77@;33JY?_ium3r;LipQj-Y=NJ z%wt+C^ArNFrV#_&>8pNVSxq0lw!irNBh}ONa-m1RzG-*7O?B@&EEZUP^LRVrAC4Dn zc1*Lm&k49Wi0 z@)xS6DX=XLBL0ocK8WkFN#AGZ?{}!una*xVz7$>iz-0dtJ?3{_^QfKQv|*Glk07pn z0hVLr{!@gONC7U!Mkfi6%;8+%D0wp=q zpe|m$U}%9`1Eg6!1V&zoZ-vdk*WBpWHp%wW;3<8%HYac$yo1g_aC<|%VVnt24l_{A z#=P(w*z8{Qku9KQ+!3X}3839GaQp9h_4`wkd`IpTw5(flJ<#Uq3lPFIq=1G&(FkZ}YsHzDdue0pGr)b& zZ|?vbTd;i$iJ)HZ3KyQF!cnAjp;;PRP5Dgo9M$K$C8%9+X_I2H0cS{Ek?&vv-oY7| z9;Y~(HWLaPwhTX_*W$7)jmM=fz#dS>=rekXbf|`x-o154Dv+k&1~E~2fiS^a zpbb40%jy)Tj5yYP?8ovCmW~MmJKi#%5Tx8`#DWlD1<@F&62=o)!NTv3@KiG(S6KI+ zd*V|A4!whHg!|0%K!$_?!|^3=+i zB1mE^AqljoQY5e)DrSW0%e&ibA|-XnR(6N4r+~1W0Zs5jxetsK?w3DWbkN|=0s%uM zst&(IiYy9e=QT`4NLxPx)8;VHfV%6hI5 zK6$gKqOZVr1$M5J0&$r?^j`cdYbR|b z6KOFjv3qSazvAnJXZPZ&$P3OLxR3NUGlRd9o$FT_6^%BNPJmCGfvm-i0U6;y`hx+! z%)4D0j}v$)Uxd1WPc}qBJXRn_(80bJ;4ccPRy)Oi)D_|5ZDU(<_{m4I<+`D`cjhq6@qwXQbFK8&$(`Up7s3gzMBU#Q`_kKt1wB&hNjkR z2>tbLfKIqJZag!OsOJL>2u04MKG>U?6Cf^;{BX}S`$?hi{C@liJhWQr1ErQh;SH6K zZR|P5XsN)NJueoT^Iy*^b`j2EKmK6(9~#Z2EP{!ZV(rFGwv{b%=)1k`0|}PrC%MtD zx})SCzE@_%&<3xnn2C%%mq;d%<-$w5@eLkQ;?fFWk@Xu#fkdVE&sL!H>B(XBR5$rf zevl|*n~)IbdCH*j!3nw~NzCOS0A`78-e=NcLPnhat!$~)b-X1K<1WNxjK#H4OA2UZ zc`Rm2&&Fr}Opx&H&a;YB@xNPEF^?XR@>3+_45?j*y|8lJj4o5>nZQFM*Px(B>O2v#=)lXUo4ax!2SVAV`|flBv6MagX$m zA!ipQeM#>XhItIeUD*W(H7ZV7!zOG}_-}-ynVJ6cFeyIxb1z*g*Y5R& z>gX9Z?Lrv}_n2z7B+5eGqMr{A>=$XNK8YP}m^bczD;;c#|CG7-6t!fD={NpE9(fg4 z2K9QD;sZ?2hPZoxgkvGV?$tx*pd=MJ>Do zH@cpymxHj~O%4-AN2avAN2GmWAC$5J%(r>@(tVb;VE@9D5LSMQyJ0JuOp&iCwVIRp zWQB47rp$y#tc-i*KH6$G^QE5Tf zqi0}7<2ap@d*06pkrO3eR5YQ$b$;BQy%{$pK(V4|iD!Rg8z@x!DU*cS2SRz(4!>;Q zbI4vexF&d~B=TcyjV3pxjqt|tjAWoOHbNU_HG6KM4gKRwe6k%nWIA~R7jo-F6-=h@ z`5fzSxq7D089ptR`LcGgeeAfy(ex#DyP8XR^2&nZuShEnqSclrc5x=`@de1tkdkR$ zoi2fdQcEZ-jMXCT4zhCvM`f;sdcc@!3eJ?BBoAW(>DBfqs}8coG2%X<>YJ+IgCCcE zNd@PVYk1X5B6X+kArva8nDPf?Ct{M0c9x9E6H<)g6^EFX9G%XLV56Ga(OcP;6CSb@ zZ$pb0|DwhN++vh39L*^|?I<@Fy=8YXe+Oy?doA9?eu=Ant2Uw}=AZMa9f!c=jil(p zxFoJ6bF7rOk(EN0Q^Wu*e;o)Z#2kIwInUck(2Udq>ffW4F?;arTRir)qq8NI%bp_F zoZ)8s9a^fAVZV+|s|rl+8?``_itgf1c~%FgvJb3%$ImY$+rRwfl;>1%x6+g*g3BfC z4!ee*Ad_E$JPdJu4!f;vY-Al?2ty^Com0ifSQ;5jZTgCd*eg=molAJ5f}Hmj=ntl= znyyYdR+;)t##V|)65ZhByc(fMpFbzmAM`TOvulqDj(1+J<|4Fn(6Tv0?@&bHjZOit zER*!K#S)|6#Uh1H7SZ;XT%>zOQ8z?rt$L5?Y*Q(8-RiT>2wP_mI<=!VFQlOm^+-E}K^>)%vo{>-xA9nbB>;CN;)|rkHVJo=) z^a$MRKCc-g98PhpA@sG_j$S1H0TFfb7tA@$uM3$@S35QMlRarEz8^zE+Gbg{b>C_E z`?J+&AWc(S0w^3pISqoVlCOTy;q5i49uuykdcv;o5m|HJyW=3vZ*5n3wN}Va!rs5U zP@g>F=Srqq^7 zP_7y|?4vu(Fp8t@`nbsLK1*eJA);CE$U68u0T)VPC}9%W|Fw!=z!KKL`XuG;%fD8> zpiuU_T^ENQFHWh4(4v7+bs|f~!lysMzRWS{3zKL*#W0KR{4DUGl<9-b-zh)u$d*8x zvchF4K-|MId_p*Bm3na+G{%Z?jfheKUAXDueY>5&LO<2 z2T5G-gUU2BBehT!TJGLM;-ok)4Vkx%~_Qyv&b7<@;BOh-MxLs+hII6v`Gn33Nf+GpPoQ;UB#Zp!xo zoECX8#qk^m{kq#>g>y47bdPE|#aLL&%3Y-EaBmH|D?j@0D;s-=^$nMwt!CpD8|Fu0 z-*a~zhWnCYaVnisa=qr#n)LMRy&7q8sg;COL(r6*o3w9)bwaEhyF*<0$L##>6k=|5 zs9qC|B~m{5_N8q1!xID$xQ^D7%=Hvvyue(1f>&CxJ`8Ht%|=O(-+MFW1z&U4>BJlyi7qxEIqCDp zqXay0$_f7aKgLRV4sGJ63gq{)x$*7ZxT>9mb4n^(h2$FB3%JxROf+m!zq`8~mXzRa z1~UqJD!OPK;!uYy+R1Knc8KpL+U>Z)x%f#u9i~WV+tek;C7#Rl=!;gse&}tr*TfIX z!+Skl$A=58`?91r)bttR;~%CR3JekUpHm;3LPqFDj220*uydsh9ga$$&V&ReVCji} zwhAWjKEar0)FQo$`1z#$)DjS}?-Jvhbg9`=FhuMzdUN%d-~xQ?9?Q*Gm-XY2xyp7a57Pf%Lm8<^c)nlY?6Z}0Ibb?#m3NP}3My}D8Xq2mi;P0Kypbqwq^owSmgNImG zXKN0vx{d8J0nZfqVs~h?RS(Tgatu>qco3b7l{{(M@ZEl$XS$^k^N6p{*Xve{Q0(gH z&koouYbj4gSBiJ7MFKQa&l5PB7g6K(z4choyYh#3&s2@@Unv`^{P=^dJU+p7+U7)= zJf{0K_Q$fw_Ap+y>H)*23VoHxYOY}}BPZ&4&cqfE5{A!qg%e9GV@pygFod0wn^8lK zh3?Xv_s*Kw5x+JR=pc3cZrB!K763U4BLaHEKay50#gmxSSMV2Mc70!F!^BTV;38?m zIvCaBjC;m~M-bns`sCKH9K=@$+~|-DapPC{3Swzz+T@>PAH;~w`$5QZnOxy@5U%g~ zvvD5{MSyxHEL>QxOLlzb?IxgjX{AIVH{N`oP|ha$sCrd{J?-5TSK=So<^KbkIpI0d zD$QE1T#~kqBiklxrNIV@TR^t}XZ=rnT5PIzJHp{zx)O8D4V9EY0a*{*I5P3Egi#Tq+N zd(V)k>il7T{7a#;ugx*_7vLZt;H-ZwojuJ*GBC4&U2^T0kK>22LW6lz2*qlZWD6$q z$WPn^MA8}d!0*-PZyFLO(B=p!MX^{^Qs(2Axml5th)R8RG;Jv&rJ*KaY?G9_NnB5B zmq`>TN1!oolo^Y0yD#$b^S5+`Si0QmUtZL>6jxMmFy#ut1fd+~b-$wODMUYt#h_yR zXqBsSNygdlN6^eU-`P2n8A&w%-YLX2x}HsaD*o3h^=qNDIXjlJ3ijli|BxfS(CZTI zON8hgFOZ7Jg!V%}U6f=rV<%8DY^^NhpPs-pV$p1KsY5 z?uQlVtyOzu*4E3*_*aq2jTAs7+t~X6c4kgU<|GuiV;rEv-b7m)2#7CBLe&Y6__**r zZHeS#S=Lke*P18MN~o>_j4LxqWv%)sM|GUwX1GU)!201W|16!Co{kpsO(JdqLXy2$ z?i&04RpUkcwUM2zmxQE@E8`Jli+^|3C&uvt>o-m(irn=Cnbq&cNO8CzCs*h}y_1e? zHJ##e&+X7Sjw&@j8^4;gMO6OX$-&Pdw%A zCiC=+4V4tdrYxt98w)T~ZuU&;$ecBD(uE1uoFUZcEa&^%CKvsxb}fbSf+n8ZNPEjy z>Dly>n#_A4j;NW%F*dC+ssb@eZpx<#!H96*G9dN>0SU@`*pceYj*@Ra-?~(V1aaG- zcPz3QrNbj8URfVBvX}@WQYpW$l#S0qq>qg02 zHkmu#B;8Dbka6Cim>o>&fcwtS?pMz0~Mw%zg;q#usi{pQhc6bZl*RaaJh zH!4yQSzL<6aQpfaDN)51Wf;rDcRQbP5O_te^rl<-D1IAFSH zYk+SVl9a{%FXlP<^T-|$Z{=F{@OFP{#?oz|FJ)0>e%~N5VTd_Gk0(VDXK|mlz5fT& zh1BKz4*e#kd7m?2YZs`B+5z=^0q&4OHkpgX>hx&)_(GNZssj<_?)b_4{l1?ncS^;9 zetYsWsqT9+uVc&L!ED2+3ty)3(aue7WY&=X240?jRGoobOI0&OWlC7^HN80z8>e{) znv?F0d(2aBTEJ_!4hEo5MZv849P*OrU#67;_Di{XCG?r2v;EZk2H?4rZe~zxggG&P zuhAA13Z_IOw~{x&mMCf!#|I9?4wMF9C(dB(c3HQS9ZA3kR6JF2mD#y=URUKDg~L-& z8_N05Cu*DBp*5P41EsS4Qs{sD0K|vWbTH(!-BAvADe4#=OH*oP4vnN&?Eglz4x~VG zhdq1vfLY07V2SmcWZa+<$(QJEE_;N$ANe6LBQt>1kN@}8<`2+Oq2ur|1U5471WqaL zCyAZ=Tte$*?NSM2)NTdpkppYQ%?Q^x`ybiOFn6dWRNI+xxbX$K=klH8;}2qQYwrx- zyL8_bav5lNnh`%wm+B>+OT&czU(7OvgKS4Qo|H248z)i==<*mmDc|HrD9pXadQ~Ug zx$Yg64j$w)C$GqUr3DTtUU&T619)#y6^q09aG!kDZa^D;AMf$*mV@!Fvg; zF;WU%YA4HngA!NZeMv6;1rrt z_}6FcNpK4|5SPM$`DofIciK;Y`BD{d1)KfS>HdK+sz`2`s7@613L z6_^;9x`mzqQ&~{58jgyKZvoPpvFjM&%?|r^B)!F&pd@();zGwh`S~=Z2?VYxzC%4m zlmxJEE==M)Me1NSAsoaF=6mOYIUv)n#?>K`0cD-IweaV06%Z-g`UIRqN&cSMGWe0h z97wM2l`|l$(D{BoU*OA)uX)Zuf9@_09glePoA>9Ndf9A!xtqs6cM24t4>)x1ZI|C= z7&)t^YWn$Z;`npq8*Rdp=&dEYr+bCWTh?C}1oeYP5c*K1=5G#7NY3D`bVsD_BXeLv zUWQmjVZ<$5M2rj-b!R zp*|rF@5|Z@kPg~@nRFkzvXcRFU7UstmR0B-I~tY*j!wD;AQEZ%?OG(@YX(r;<&uW& zu0!jz=ko7Rr!XF!A-&1FqDT0-3HWxW!HNC@$$|EP=%3Ns%OD6?LqgGfz}%>J%8IkP zS#uYRhqVl2K{I%bLG98hawRl?q zHHaj@P*x8~%k9OLL${p4Tw6M=o{pH9HW9Hwc9ig~?F9eCXYyeA2t0SBX{OYulmzCP z#sWlWMiYJgB>QHaF@&oW9)JDvM=S^(U)aZY3$zB65_x9Ephs%E@%Xf9GG7wYCn1lcAbe0qBeq$FQ(1C6TlY6|d8?wf!A{QPU29OfG%2>kRWII4XRL5*x_{0W%i zld{?N!T;300d}bQV;F`E_~9_%+>|W>a9Db`h}%>M2;3x~U*{Un9BdVa)8IC3nSe@h zh+J|lKYJQfLz}<_T(1GYd@Vv^hj4+%yvh%1O z*oM{E&L}#9B!o?Ry)4)dy557dG43H9f>gqiQq?G{B%I9RcDczDMSxC1ATgqI~`IQ+KCyG@1X2~B;Y!L5mgI=Z?X~8 zCkiVf4?e$4Xk@Zyf^Z0R*)kT)FQkao-7RZ=8n$+LJ|U^!$!!*1%c{zUk4}I(>8D-o zB61x`c^0`+T@_E=v5dH%Kt(`@?@*Ocqst6#{asevF1a%kFmYW+sShaL*A9|@Z7n>l z?!lLjE%gI;@Q76g&2yrL-BDj$?S3X_J7tqv6P*?L0Or<6rJJh1 zBU5bC(QPrgS#GLNx*t%b8SXGNm+ownU%8W*(O3&*E+JnyLmY_ip}zdLApMZ~Op z=w!u4stthLhjTa4D0&Z&vM{-0XV^rZ=Ow%R&V2-p<#tJX_1L4QG9xCz^I`U@8(j4&5`q2n=nm!PSMs}V_n-1_&cZ1ALF5z(P2n9| zmCpXjTs*H2zy``XmW>J_nPHIVuT zFcuy`CvUT>W`Py%S>gpj`HPy6RaC}jec>rYb&?73+A`5VJfs^%~Stq@(u`|`$R zdBK*d9(GrR1{4E6-MJiPn7t7+7fdRZ|1cQGk5kKch3|bUWcIASu82{5T!DL@7kz^& z+&XD|)pDO@v&hPY`TlKwj_wb1j{C_mX61TFPZskjZk4@Ddn!nCfOf7;(U*6(vL zb)Og(_`pH$gD9?FMRVGN)8iRqJXGDoYwIt*kvGf&YcQX>tr+eN8WZB?;;4+`unKX0 z^X762JSVEBXf8EHi{mj$Jj^i1R*0}<>z@$<21o5WM{JJKhAW3fS|v#!3|j1}z52)1 z&aBnQ;`^yxdMyK6e}~qn{p>r~?7ozMc(v6g!K@}bo}x-eCFl1GxQUaj`Vp1}B!T>k zCLQr83nTr$S{hsI4JX}`#1};p`7?{XzPHBIZ?`0Lmhrx^S4WKJ3WuLMqil%wSwZU| zQ!{@5`PpI~DGIw-p+l?-=u}Jd-cjzHa1V%4&!2+LKzp(q4;8W6 zm`DByE1y*zZIE!t13oh`mWv&yu%GxeU}YOg;3i!Ewk}=fX)$oo#Av)W8Tx6~-A4w~?MG|w($xCLrQ=Y^!+z;;SxQGh zXl_cS79Yc>XnImh{o$`?4hKw z@-@mXl%g-^tM}Y}uW5QenK;+wvNjl)4JBE#{?Vr__+;<-`5L9S$IU)ByJQSl2Nm4= zEJAXHMe+Hlti9j#ad%TqC{u^a_f--jz3~@td)5A^5m2(j7m5iC5e(HBVSKJ z5BD;X={CjX_o-2u!s2c>&!}?@N|`{FpW^GB7o?)q3*OL;?TQH;5gRk5>f3o6?!##= zIzlc}9&9;#8<+h1yaq4V>ETbggpZkStrp}M*^no{S}hq!oO=vk-;z9-Pr+)?hPQ$Y z{)%)UQrq5IV*L2BV)9_$$9m93l+eBmDjm1x>fNvUey&P|_m^3TFrNTr#GDJS&NaDR$>yxVBzXF<43L-4}xY`Kx*bPO}2^p^~8=eFM3 zOR#OELzUg23l!-*+}2z>S2DHv(8%6tzb2OEMM+{J&IVPtjp6k`aUtVwJJt%~;WZVT zNA?EeI?2{18qdC6xp#(;)Dy(AW!W=UiUhIvo)3)*UepC2;`|@%y;V@1LHq3)2q6$W zxLX1QcbDK0Jh*#s5AN=e;7)LNcXzj7!QFxdx9RP>%&mMr_G)NnuGm0WL>9KvCNu_j?3{eYfd#Ffr|%*I_EVGc56a zwMr+wn?j2A!H8`fSku(deU=JST(~#CwKWH@!|%ZNuK_e@iNZAPrW6T}-4fuyJY@-^=1|AgH!!NnpB_gl?B<2#URO;C%ONV=148O?6|7R>|9uXS9fdmd03{Q7dG zf-+ktY@D3Cve16+pdwzFAR{5NzIls;he6Mz_6Jn7e(c14?65(MMn0&{SZ|TIPgTNA z9=X8a+Pwc|IkPD8%35kXl(>so!~8f-Dw)G%IShq}ccJPJG@UZd(b&BcEj{6~|0^NJ zC4xiFZ$3o`X5y$BcC3-QtFTt)$6r$nxdcYSr<7`T`WE(kiSW@yrTZC4x=EVgH;&Z_ zM?@iWNCt2qq&d&l%u#03oDPfo^Vy@ zn1b@*{r$VBdO(XP|VIzIP z9;U|+PD7hkSLBF>{zr*Rp`C#r^rOc3V=^_n#<#2KOR#GUB(b1tDa9;U zv>s|H4Ke;CPGBces3(Kt3N{_VK`vk`igbMlD#7+&8~$gbk3WKL9|k5Y^5kwresRE` z5$b&)h|C5#^O?#DIaQ%6A_2pXA6Fm{h;{^4X|#Wo+F)O4q;{`u4IKv+P-%*$IG^Pz z($)^PWt@jn+(q>{8W%E?8vXq{kOU`d{b8SR8gwk)o?}LhF4N3ei<=nzBj-~z;OaHX zg9d0pY)FvBulS^I3BD%a|Im&fk3>f>J++p~cvH%#Rnt|yz*6dz)W6FtH9kY&NzA&y zNE5p|E0(8V)?smV_&%UCA{njRU>q*E6Vts467r!o6yW-c71Y#`UmkQ~W$LcST4v*F zq8`BKfxDR`6I>oqT2#*-EdO9PP@TFxN)Y1+%eg=+>=+LPZ$7G6i8 zb0)2~)*jy^w9%&%&_kwt9u|Zgwa7#;!t2`bfnhetZaWPyaTc184XSWv3V`XNfM?fb8BdO$C9a!#6tOZziT0 zd2LK4S2QWFIW@%?mgB?=-8NQ3!dIA{gwn|8v!oc#!=jH@|w!xr2fx_BH#leggc zAHO5_mKN9=j)?Pj(+00FAaZR1iSQ^o$9Mg;I7vX|+ajK*O0_6RY*O&rHHz{crivQr zg1GQ{!mJ3BAezQ2fS;=1!%Fz`3);eu#hQdQ454qowsJc>?43+NW6jEnr7B0u0CQ#| z%NUR5yEsZdIM^zgYmnB|2yQD{BCVY?R%5Q2?}Ow@{!mgf`uNWEvtye~8^0Ejm^&75 zy7isQbvwMA)Wy+ExuAw=g-~iksrKqcQUjQ%1ZzUH=Ctief23?cW~Q9 zQq^B&GBJU_v+8DDiJ_ac9HTn<6sa zj@aX(x4%Joc`}(VM3mQ$z2-t~V=NYCxgMm7uVBk^451!IF2w@*3V6>|`VspyH2? zC-1-+h22tLGDYC|>E=cU_GH+v><5_(%jBD*ogxC@q217rq!^yu? zZpV&^-0GmUULt*!MN6s@=~i09mvjIdc(Khn7CvzwNyIe5SSEEI{}oxylnJy4b4#k& zZv-hTIiF01j5TgW7c8zy7I#_ot(mQ#tOv0~F&ev5)Ds~m{hnPMF7RTp;DV`3*IDo1SmxtF*lR#LVCSlC7#tZ z;TLJWQJv-UB*uV`Am-K+V^fgWbETKt7xsGi^X_hV0u{&YedFp2fGR9>0G=uodWNC>34 zVWAd&2rYkxGj-hWGzRL-z0p$P zM=PboUbBB?mt>%XggrTexKINu)Ma<5!=)dz88pD5;*XErruBI;)nI;_HlJ7%J$lcs zZIFlK2zPylbIMe1d?of(ZEXeAH;fao?kAG%ZHjbR8t|74pExbPy`O^ayhij#3{c7+ zOTc&Eh71XZuy{B-_1EDCG!``5+3&7WP{_2Pc~o^r}(EoWT_9U=_npNKvuw zm7QD_4*yX(d29&Mk9(-7Y0;XKty*tA!C+IqH|=kj3DvqE=9$8hcUFAS@0dwY{IHh! zG1Ij2JaH#!GRrXhbCer5O=;<#W19!eWP~W^$a`JO!f)_@C7TXoE_QSm6-9`D3~Ao? z{tOmzVKmS2rX{d-olDUPh))iPL651y4%>fqdP@kTU5#g*FaI+x z_OmMlUGI89mJHy*F(O~iS}G9czWjLe#qYoHO~(0wCW^elpji>{9BM4>|6^Ig67*Ud z*Gv)qSDM9tR166Sz5V~o9V#x+`1d74@Jq&jF~0vn65j#A2B_i+VgJP)^dFJui!8Vo|K9)* z{{M&Kf0fL4$p8PL`2Xfm#MaA90Xb*mZ`+NIGtkYNC-@&|=iMPP8pIIo0Jg3<%fRlq z0*aW}BQ95SWM6O!v8Zj^^~M@-j*H)&K|Ib7K@Ws%92J*y+;0JlizCP#2yeOF3_pUM zI&M4?Tlf_W&QWRN<^fn>4T2tJ69(-^x>^?%yRWNKfjIdS68HEAY?(I(E8PA<@B_f_ z`#m2>(hqchzyZ-RL=;UtsKDd^CVSQY=&|5!R-Qnq-xMo$8AlD7tMobHVXt7$v)akjfe00f4l(7P4V)0l5Ujf?RqBnKj8Oss6_ybRrW;l z=2l1R>Xoeqtt}WlD{}l$rV{T32{qA7vwu9F@Z`{5fGHtu8NAU7XyjDiX1c=!eR(u6 zWL#+b6i{pGk$||6VmhlJ9*L!4nq}(y1}g+`0=7*dz-()<6pl^;*Y1SrPP}T=Z-8^% z2LeWz7=c~ypttiB82Y5U2y52pPN21-MhZON`nm#FJv9^qP(P<2hWBz}yI!>TqsWXO z9iZjh63zyg9?Eg0YqrX9)j6zJ?MLXQ0LL7S4(w?D!`*&>q$w1Ux{*q{I1kr9oqOI2 zN)~&!?7tPA0!I!yu0bXPz;^^fd<1v%4sU^CEDlE6R$`tkoc1fQe!D>FNmS(dZ$Zf2 zNVv?st+mJdf#*{Yyt=Edz-@7A0`I9biOwJ~9cYoB0z3|^F4$*qfOh;I;_D{*t9ch3 zjZN=-p6Ezw!+XB>q{o&0CmP&>Q;?X(bbv!VUv8Swx%%N%oA&vqTSWo7<_9{_Lqdk{ zQCL7}HU-dt(8peBR-i@(a#Noye{mlWI|LUryifSa4zLczAP{v{kfbJF%Lh@qR;-7r zB>2^!pG1sn!A>dA?HrVWH6zIbtsa|DX+RDnMS+l?2jxsfAhEy@0G~KS0Q{rLIib0? z*)&yOA(h*V3dcGv#vVowF1x9VXokf$&!_iZIbP0Svv@{m4a}dBuvvRxE#yw}Ia+s~ zDY=67g($SF%-;*!>SaIn19vn9aLC1Xw*iry{T|%>G&jfF;OZgWK<<27c&I<1+Y+6- zV^@6O1(g%{c~YagEi^=dR;E1Y4~oGf9S24&n;`kfGi1(nA5S=dFKK+7HQ zs*8z)se*i>1<|~w1I%?a$??ZW7)v>O?TTT09{aPQ%fB~^enjQPM2s3 zI>%5BiYb*w07?>SMedCDc-V#e>z2|jn)ErD${m(f$><3XTv!@<|EY{tYedlR4+Pch5 z{4&L`cARqIIn-#LUDBm z73HT;-*(wdGo6XI(EZ&^zr4L__xPK*FN%olHq1mrh+T{}0WkiA7iG9YY~4J7dm-#{ z6<|IV(n9H~Fm3|!M9%0zqX+#E(l|pRJR+JJn24R7xPY49;>Z3=S4^QPVGlue zT6#5p%LSY~!Y=34h*Gt4s6rYmj=RYwVs-+&7Is+V5=B{RC?C?P7<|Q#+fXfkd#C{;}$a0-y>KV7^PU>Rw zl?ji1@*F!6{fo1>P%vO(>39IIVd{RpoSi4{+VsrvH&X{tY z^zaw4<#r>j`<3|5Q|#3iaCa5CS16YPD~%Ik?XmraNB7$Ro4A-KFgcf4UW@OWK|q{a zwSRIuJ^jm~P5d+aoQIrfIj1kc6|gLP-Wmb|<)CX>G`;WbqA~EKf~-2ClbnQ2}1e(}5k z$cW}o1!>ceAe?yT6oar&|LIeCl=h03p{81O95 zY2zb;zf9Ht4k_(PO8s;jSn^=dE2_RSc1)k6Q9o760o=0+^y^2JmtYhkk}zbwy5?YM=Qs`j2ZuxA%c)kmA`n4_EKBF-T*Jy^GP z{5UDOb9TEVj4cA|{Lu<9h-bEzu35?cDj0Yx$=gP#%k1^^*Ax0qytyrty-&>m+G{bc zM~_;l3J7N`EO}m7%T}O6IBUieupD4WQ+20NVdK9Sw-MHn@RIldu*LWsUaJ8?oZ#-$ zDr0MAkpnm}`USzEr)SDILeNY z|FZz0B)jUF6tUm=6i^+9U0ZCsQKsm|6$&&mg(K7yDN|S_;Qw=jzvENB5fUrsRAb!&#|EAulFnCEn4*?)U{I$^n}|% zMPEtGkCzO!0q%(_fDQlDN*rWFnQZjF0dU~IFYdp}8P1LF8Ur(ND)o1n{`kjqX+^$r zoUHN9z|V((A!5I(lj#m-()0!>oQqKgT_>Fq8eGR+8-Y~fzv^7!?nbZtvaCB;Nwlst z-uwj(An6DnQxwe#w(-ec9Q!}P$f4+ju~A3dPuSq^D#IF})xfs!TlepCcq zX1leFG!gULBPs04wm|>CJFg+lcFpN-o~==7NKXT6K7)%NT} z?l|Br^t|@s_GgSTwR*CBit-yl?H~J*z$(nU!3Q_Z;rQzhB`4z#NVC)qkY+!ew=NGJ zQBINPSdaTRQ>r)Y{)FA`hn5s3Nrl(>27iFEXj<_;s%~>|r0(}^XT_`?@XANFfLvGM z_6gq0(ea9JaE5Kg0Ux|(hod#lnTUQK$wRjlU=$>AhrX(3f22ga8+TZlH;^RovPvF= za0sgU(=04yJE!HJJwC?aVmS$@W$*KB{+y=|^$6zT6#y?P@{KZd$A$I*m`KLCX##fM zK5wL1w38vsd+gv&kFh-~y%a4Uf@n)LvQOHIb{n{BrZb zM9;|dC^IJmL0#s?AWv72a}-a79nQ2Y_oJnb1jqB^=i<#1(2a)_6ty9e5o6NNJpq#b z8ZT|fHv7H`tl0*$b|Jgt=%kY7h9bQU<2;5rr{9*e&+&!0$o?2|A&n#G`cIiu%&E9~ zUoh$Dg!M-14zrz`SgE{v{kMSbWi%{&jQUZJ`^aghc@2$aL9RP0X8t$A8to3Yrj3^# z+78`37Rh6!CM@yVMpy>;1rIuZqb|Lme*w!f&e!0#2N4YJACYui2>+_L868xUp9=H4 zcO_^K^J0Yt+oZCd2YX^2BfD-$i)f3jn3hWQVE;SZl)EhZJ8lrdw5< z7C!r*E+Mp&2}okB#>%i2YK}S>=#g_t=yHT zD%LC_lF=$j_)Tr_6_2{^xwdNxl2r4PbZ}zu&wsKc1e-a5YB+J~+^$?R7 zC(*O;%NqHtjYtHM$LcavY@}c=#7=Yy_WDs$A3gcgxkYj(>|Um%x~>!YmgD!ZkKe7I zO6^?u+h0@jU@rc;#X!PhS+N8E&*?uY3`-sIJ6m>>v~%j)P;Qvao` zz{4!w+4+)Y){1)H#n_$|567e`ele7%ti6sY-DzTh8 z*lQKh)~tl66z>L-ha{nzlN{Hahpw>UH`uk_woCEr$voW(7S5e1yA$m%=*lU-=QywNf@}I4c z66o8AGEGkC+g|Q#KtwDO=-tfIZGXEK%t0E*>c{YtzZ;qS_MJYQo>ePp1O;MO{S=9D z6>IT4MZ2*29lbpAGb-=3)F-bv9-Tplrk#WtW)cZQJKB_!C8s!qiCo&wBdXwz^S_)+ zS&|?dF0;AW@N(u@+z&JSFGXpyhe@;711#=*lSe_6jj!Cei`+&M&&_eSyM4z`t}E*l zmi$9Q{kgl1+{oBJr-4`M_Z$}ROM6~67AG|)m_))oarRfkD0wn8#6zNxVLKIf~BseZ|@Vvx;~{^eXi+x zx3ewSO5dn5|8~8%0b3M_9D`#iz?|zu&~5IK7Nuic21cuponzT?yN;Q`|5&==XW=%@ zYf`g0 zA{kc5jNQl;d^;8#4(}PiO%>4|ttvxayQ4sC`CudYBtp87Du+ z+Xj$T`NfVQK`1G7aft%_KBlX-6MhsFtZ4A3;)TC4=P`6}eo=b!$4Qs}B7WKze~oA*0%L}eFU#L0S!5~O6Spu^z;S^Xg>>#oB>&6Z z#Ld5KqX zK+rg#fD^x*-UsJE^nCA#zfTHc@ouGzto2VJ%LvtJd3;mie5c2PwgK%YzVt(&oz&4G zhav<2qvop9)Abckxx<|-;o30asc~O+D!s!5!RpKoezN9iGnb)KByIz^B|k*Q(yt-> zhWls1PNL?GL#kH8Zc1s%AOz7`BG@>lf_0Da< zy|}#B+ZvJpPnwU0f2r3FP9ima=tNE|_Ip|rY1@{SqwEV?hMcc#;#>L&{C1Lwn;~k| z9jo{x%gtOgWk1FCF7g)cl`a%af_RU9xVI&3l z2j>PNJF4FLt)QTJ87&%FNFP53lXWUI zKB4@;E}>h5B^Kpj`a^oZIQq-7mGT22XgoDl11OHGXs>FJjRL#Kg;c%%j-9_G)NyDJ z?Bu8B?Y^R-*UK1XmyFX_&P{zB<4nKx0tN$xR0{i1p%b~Vb)l1jA(*ds4RGE5E_aHl zUl!t7hjEX3%eDlYPBp!pPX2R;-hn&x5Gqu~0@XKV^-?Y>e7|i`3^(p{$VkTuBkW9f zne2I7Ex+huI%>hO#|g>vD1 zV+te5Eq@!Nn#mvDpBy=B?Omi(w2Nvl_don{$?dQ9)U^CNzk|EJmLYISCJYppaJ(YIG|Akfe*(QBY3(a;YUH5VxFgPZJy$|^MOb#J*zRzV__@0MGU9AquCxYEb%z4n8Z&q__+Op z6t#FKt5#I(hs+yvHC5v2FB>Vt!cqIhKkcS4l>FB@V>$%`O$LG4+o*5Qwh**W09fcvy_#+HExXM(#GS~-p zgJ@xcaHhYZZ|q<`XP+{`+oSI%EKCrsih(a-tZAX-LbM`0qO0LAoYw>OXH(cY-r5&g z3_|R7wMM9|EMi@_UNawMq;lN)k`cO*0~%e*`U-hHQ73X-#B)(X@?+_#40Od+?mt~Ic27wVA}wX2Es;eOl&wqEdb0^Us4O@t8CQK@zC~X14DhkH zto--Y!=?rzbqw#+CnuKBfQdW5@ zmi3kO7A01PTi{#9U}lEiGnZWlOORgvb>~W%5@(Lp-plz8GWR{~@TffhIk!H4Xxlx@ zpyxH7baO5m025yMT6nV?bF>jZi8$s__H596JSp26dxrk}k_bAAz3l)E!=(rT6A6LA zjPUWRlJ#_^k4~ECpKf4xqJ01Gn>f~4*jSHsd?QEsLXyuoD;aL;`<9(`!_y!^m~gPq zqQ0?~>jZ7!=Hbq_^F_&VS6sU-L0IIKO@b*MDXZa6ZSltZZ`A_<)T;*-;hFCm(sSaR zP&CYG;}%1MEN?{PBuqXSx3IAg8Nn>jGju0WlWGZu_YH^6V>2->qet2c?WPy+ZT#?7 zuh^QSBM&JW}zhxd+S%RIOg4r2=J{I!@%9-No7RxxL4~F(^D~KXxhv zwlfI?C;5AAT1lKGXQm~zr|x}veH2BnV2NeLM%|5O0pO)2A6LI@MKgQDgGn8A!((}m)9GqNQl`evI|1&wu z+kY-d`N-Fiy@r~|b>}&M&V^P@+x>7g?3tJne&sXqNzHPsbn0hZkGGqsgWLt^7}0X9ORA!xYi_SoI9>$=L+a8 z!Q3OT7OtdODfntJ)W5m8pt}sQC&Nbda=7ma(5WMKiB9Egp6&bH)vx+`+e|EPfUl*!tT4^UQ zA>`qaxFUt2E(&Cdc?5e?@vRV$y|$1cY9Z2dtY~ zGlfRkRqi=`wCd;d%zV>=X4Nw_lw^PDdR3xJxS)`aLbkwW@HLA4FW?$0oBQqNo0;X7 zTl)CaErd=v>3}fds|A)61=^J4fN+`43{{7Iw@2s`V#WEJla+GA^qc!4;#06>vJRNi zEQOMjIYlHnK3oLl)vH1u4atlqbXg*>a@k{FXVX|?;KA~XXv z_R9RF6EVZskG5NJEAWiKYu326bD8AasZjO7#8B7rT5U4I0{gjtB*>YK6oI&waPvFe z7>4etpIk9vDIwPv?AV2o*-Sg0rOW&a)Pj+QiRn_E2i$q>JK1=fov0gg^}7}0zsWuB z%^u_}zn5Jki;3nKmzI`NO=4MP@9%V!I9l%_8AS<-4<6IGQ+#H3h5K)i-nP7N81Y!P zjb5Wf%4xRE*xQV<4e=T!2u8wZ&spT$;z`K%8u)CTS;M^;&x}JH-t%>%$@P0zT{FKP za=0tbJ=B0<*O#>UPfDZnM^p`b#dpf{HjW4Gw{c`7>B~cC`v_3_{f8Oq&FyYwac}gK zk;Mehe^G`vL2o@M#}In5DSbjL2w5xX-{OEB*&)w5HzrjS>-t;)SM^R|o~~!qFyr_F zlasykDChXYK}(z>jL+dvEUPGL!G_D8CHY-r@jTmfXJH<#Gy>On@u{KwAGnJ2UbI~; zH^knR<^_xcrfG)o+G^=tBVX3hUtY&kvlm(IF8S|C6AZqpKGVBwT*X~nh$lyk@}O8( zMjCAt$l`=ZwQRtq3ZPvVK3H!~VeOuX&yLL%@~r475|2q&bM3BfQX97kACpK57I z(gtFStusy2#8Qr-*qBr&QHhY`cNj9{$8iLUyejzHDk*L`^{*AW9EYm!7ZD!mzk z?(fi_Op95j_AOj;;zi|r(V^i6-rMt*erFcKX@%moE$+hE5&1Mkz`8!Z zLd8M6nYyPptS{10FtP4B3^w4`vWH=Uo{W)%jUi5XL3vAjCZ(~_uBbhiR?~WcKGc_ zX|roGIwEqUlupkyU_fZdx{ot>;6V17dS2aL`gb+`r~=ewS(0tQoAwAnDoT`1N60S- zHPt1B@`z>_VZ$TXwaC)x=yVp;o9k`nUZrbkyY$c!5$OcJzNmU%DF))dZ-#Nm2fV6Q zEX#n}LWwu_E5HgsVw8I}3T{V@j1UtA4^mze5xIk z@*^3M6X#tdgeTu@#ch2GB)FsA`XPXDz#gNGkZ!8cgjP;UQv5yx8!zydp|xPx+Eg8R+9>O_m`B{F zx8dli^73+6)Gk7`)iXqmo+iG=z2fh(^8579n}B3}U~>-}`-`)^ZJ_ScDZ3V3I<-y! ziygEg7BC}&j49bSaV|mrmIh+UqS`t=Utf&GOHs>Og%B4lykp3z^M27s$!U@gG9li6 zjy;9=pv7k%lvdd#D{o3v`+cq`rBEjVc73C7;W|(k1ZiuFyxG!ko#$H0^DI;;US}`n znXRKmNT#@I8>CG+H~+K1I$Ot1^o9S0gFD|o?gy=Jgw8g{<%QD42hDi@(KwG-g%2Zz zG4Wzj=L{i0^tbrtKj})zKQ5c`vC(<{uhKn46wB3s@w-m0ADS(E{-cb0fm>h)2?2}) zc|S>O#bMEWMnj|{MSMSHC)6{64Qg$h&0TJJli|wh$=8nZ$3(mSr04;ZaJnhA`r|8Z zxV4^{QmdGCI!)G8NAe)v^K1B*>OBw5gT!p(5+OQ#fiu>rN4!E>?K@Oq0CZmhv9Z}#f-P+)*7U)y!Z1!idWRnuY(lpE8>wz;%Nn>2> z|Gvig%heIm5(e0x@vvu@%I)I0+(ix4^jU2+X}5bOd|Rm-X{={mx|PL;92F#FYP(ig z{pA|AF;Z-E*o{y@Y55I)CU$At9t_fju*Aj$q>SH)`tl1+>ow}G!p??v7vQo*kEGrx zUbm4W{iYS;x;!aw?U}B(K>pin{D{|4sB_L8K7Xwr>6_0#Aojt6mFD#tC0ADtzBrYz z8s{bKF5hU8`W`AW@%sTujjMd#kV(w>!+W243c25~9xX`?EYVh%&&kU~bC0!OpKZp; zDqpe1BJXU&Ax6A1uO-m${#@x1GP}Ff8LIOB$D916zuk?TM0tmBsnmswVVz&1$Lt%Qzk>?!KCAnc0#-|MRhuEmZ#Uzp8h~j zy~AnsYE6k}&`&#h9t}Hq`&iN=562Usqr%&f`AM60H3&1%$Th5~N;%z?K(vZ{ z?uSUkRJUVj$2C1RWt;Xs35n2MrEND~-7|XaOvtjaE736fn9Rs>JKV~UPnN-P?ew9^ zFrD{pk#6y55hI$!;Z3AhXbzG3tI-g4xV0@R)`8u1I@AG$Le;R2@j*^BMhW%zLu{}L zD)&q}9JmN`r`pRdX41TFNjy61ML@$ZBXZuw$K;_4iIG}GPVE@`##6g7Gm9L-(NDc5 ztFDwFJ{e15472O;uoQ!9q;)gmTq@1AwX)eiuQ1Bj;z9nl%vmcj|3MO;(rOLimgX_k zH5E=|Hu;?c^R2(7&S)VuZ@^Y;f3%5+1Wbf^JE6&30MA`T^)U6}XV_r1(xF>J>8&AL z{BE*3-J|C+FIE^<=i{3$i@$J2Wb0cW z(F@VUFP(6hIx`+c$WRgHL>|n@MmSBgDnEq^=QrPP(8{t_0oNWOtAO_!nk|eQnv49Y z+{+FeCv;TjqwuRebR4n%{bNgn+5Y64M~j1vS+%H7B^!DKVw_yiQJ-0$`E^pxlgkQL zk!u2L_gKu}l4_t@02m=ifk;;2S8`AdG;eMA0qz{0*lXP=(!+zF0QT@5N8J@K%7^^N zXT3@mvrrhmLGZ=|zGlL&lurTEgfGN*TAksZ^D^UVc>E{g;z=J1#=xs|0x0ocxKP9l zW4EKf6>WkSg_bUpKfrLli+bxAl2Z%fgSAlIePfk+v*JW8g-hU(s+>zGWP8ojP#!MthIP23?zTLxWGU4*9zO+aE?Mi$LPJisq2>7`!Q}PT?(*s@9 z7BmqxBtT*VQ4&EWi$!Z1TrHPbI%s#>0G&k^9)b3Li=ZuI24{i@&{*;|qImvRW)2+z z{td=B5Qxu$1s+N7JhXgkdq7J8K0D}uumxR(^;kIwQ6HQDbHBJC2lRrLu$|Oj|4nhW z2)d-|2ECp{^?&T82;Fmv*{wVPmmwe$xX+c;Mx$rdO|5POcg9D0Gd>M!8lRdEhGAMa0c|~Ph#x{%VN5Is5d$*{5MS#f#4{V zi~wLEpxW8Xl;#sbf8TH=XrBuP)ClA36819BLgZPH?ZSNwS}&F=4mZ_q8<(h@WuXN4 z0j8uIbdF$zWmg(Z+}BwUCtpF!eh$*UUxC4x5C6~A1p#7r3!F%}z7xP&**BAM&Dy@n z@=SD9D2@rRFyE^HJRB3!2}w%)OuEPKKJ)~>5Pb&7XGwH?yr1vjcTZNeUji+x;RAes z?TpnEwCsn30<_}QULNimI-bfF947d}MX}U#UHWKren!lEJOj}(R0$g9Ma(u!p1{LQ z*IDodf}lun01Yy<32FwR2Jy-&pQz-*dg+|1mds1cngJNoi~7s?k?xDe(V5R%-e04- zSmZ;EHH0p|)lJL@tq5wbuIM=-V2nO+gsV;q+~XQA;973UcCsOG1 z%^e1BS6o?Q@3|5kWk4msG-iHFVC!??mce&j6-|c>KrWkg6`oe-op1T&*B%DN`M>td ztUQ8eeVXY25e%%ujkXf;HcLIt{}z=rBXXXr&2l{t!gU`F&Qs=F#U2J`GN1o#0`w8C zxE<_pO*uoy{agk8vHSITw717EUa_YO*6S>8Y4$(1J)43kZa=PzP(1gA9j915w5;NI z3T}Tlv@6rL-)??d%f`mEahpjE zoAA1>=>y%k3cGYEwjWqjvTY{!h%bHwn>M8cm}}c&L{@KdO}IuGcmXzsDIu;Q0&V4I zJ76HZn&m2JYuR3jz2$v64`lGr7aQ|_SYA6^c$lm3V%u6|gx;3|sc0qFIg1#@3fBM= zTt}b^*K7#REb9I(0_ZoZAtL%I2zO8+O))Jvu$bL?I`!^opP^9NdJ}MFIgJyE{+6bP zRp%fxTlA0OzkL4G!>zgceMw6!ug5Lo7b-}r?k3-kZZx$& z#7X|1rJ+sy<%(m;WSPP zspakK7D<|x#DV`TKR8g>#eJrTchBIvWy#97|I1?-lfab;29t+MW=>VW?pW=#=GwhV z*#IXvJWrU!VUj^+d<56IU`KE;W*Unendcd<9b730@~97>p>+nQ=wp;)$jwvO4_-F0 zJ0>e3!B#Gt=$VB=tX%E3-lN$I;6t(gTWTtH=wVIX$8JnteqQPeMGGX<2j!YZ& zvGR1-;?ocR3IxiMdL2!=hBn{po6!z_;Gdmc)xLPvHNU*+Ah4n*x~>e4M0ypVT0^H~ zI32x9vo#5`3Hz$sqWkUv+=13zJD5;QM>;pn7aSa!ccUh(UQzO8dwu%@oVFp=na#@$ zZ6{VNF2>p)`&R~zhWj{tyqrKcZ-T;ps{LclBVQy(QTt=4oQKd6-sP=Xv1Z~kyX2M7 zzBsW3da=T;UA@A1njf=0bHIIsVxbsUS_<0!^l6IXMZtfT#RwFrh9U~xKMFrhapx%7 zMwv$nJxS0WVbI{-a7C%%J5Li2{`9TF{MqV#=1&ZxaK$h};#XY>VV!Ux;~9Nb4jSOF z|HtyYc+++qRJ;<^SSD&n$9tqcG0h5Ts%_H&y55GI_r0Rafs`(uh(pP!98859glw6h ze=eiQwRTnR90aZw-%T?gz%1ZQBs7wGpD&c;zh`;Zc}F{1lyucA(w6+Mrs6oqw^^H$)t%NXN+ zmz?-+@ZyGbHTT}0+EU~2cV35#MtbvEJ{V7HE{81{4W7}43m2ZT2CSQVZfFN|aDzrx zX`@vpO<7gFoimKkIsP1o;&tY)4{2VbDXabJa?`R#_zV_~ajG&?hCqAF4qDvLTKD)EK%5h|AnWk(cgE64Uw6bI!$&pNme~;Y18_q+LFEkoAgDsL zap}QVqWU0?K5|pSvG(-Wd5-aTMCZEtY%1D|HKZ)jJnr{JB`0R8k)S22ndi1z4jx^` zPk9+1fV5qCUx^r`U{tAKLu50_^PJy5yuG^V1b&za^8U zPG0#=+?KO1E81}#TF{J{dqjSCB!^W41R=UtC-8h8O??(mUX1q)nP@_^3rPl6p{=w( z9)5lyLH5M%xya5_jbz_)rjKe}2>KXBT|66LnAlo!@cT(jUiKw%tI1qKE2;n%h7nuG zMgQ*0Oyh_5S8+KyzEzDNXQ)Wup1|&Ngl0edRswskBwWzQ2BtlX8|<$C1^TUzsbCPu z$x(awwBvT_zJ`w~5r*XxbubScyj}Mw9-*Aq;#$M66y73Wm(d|@>00A1hA>utKgL6- z7a7SL-2R8jP3j6 zRXs>)QF;Vx{W=rj7v%k289N51=O@EBPYVP5Sld(`^(-es#O3b|k9vroE3a9q5b$t# z;IboNpEACm%x^EVMv0Ut4@4bn7Bgme*@Gkcj}MlL#5U##Tv1raz@zz;!18=+T^;&f zQI#LB!@{EzrWwwvZ~#P~D~XMK5=NG*h5;s?WBcPD*se1-R%wgzGKeAfnrhfYCU<%F z%oB&*Cwwg$D@i$%#EZEGUZTW&AP$OF!*#4Hyvk*iX#j?43pL4Kuah`fTI^H1>in8Z zK@mz_B+bS98CY&_;m^_%)b3LH1N*w*r+L=yWS{!iar|5*RKu1{V|Fp@ z_;6nSDKI^ui8!e3#h+iM**9DTbMm#wUH$Z0sy558;jJ+n|8uQ9SR~-ctP__KtCnt3 zvi5V$^72zjjxH$4JJBS_82LXoHD%UFS1MoeIzG;rN7K=o;XFNn6~DBr<8I7mwzEZg zJq*-N4L?K^`S+5j2L41CZK@6Wm7`ka2~kw{A?TbzM+WoJldHcfYGX>4FSH_wB8gcm z;J^A5>DL3p(mVE~n0c?nHy#275(@NkQ8%1FiOc_Y7J$!Eg$Cg5u|=GbNApfsQ;iHT zQ6eI0y7k5ex=h%$)?etIMr;|k(m;Q%Q|;&Tu6{*#S=xfeknEPL$jd(`I%OMW9JBjt zK;VeEtC0KpBBHWE%xjKZmw9o@HbdV%=S#K35v`2AtOoti5MZBb& z;93tqO2=3R>VbYq6k{@H2_5l0N>CMiPWl%62F`n@729c2p$MUXcYO|-4_c8@kNI1f zL(pIJFvZoS<92?A>P=WwH%^+6X&u7vi3^-)kGYFwvq7!*b7qe}P6a^i314M2Hgg+@aC^RH-P|K}v^)hY6{~5zsUeuMId22B%cf2ohY|w?8s`8dzbxg}?0* z-q+pk;qyKtkD}6ivc-X(!sb-5z|l*T#zMc3@FGD_;=_6bQ{~ql`wghy$a(Ly~ z<^F|mdEh+{a_W10*1juj$9O{5*Y!2@17-@%Bf-qg2DoNc6>Hojm#=YoOQt<4luxht zL!RU=NaY;JI{&<>f&F2sUs6MKU%TjRVSzuwFqfFz^Mk`7jeXPIcmS$P2WFkG^~Xin zwSBTQvW`eXjx)XE*vEQ$L&8d7{H33#f!f9%7jbexM_05Vg1b^L8QF*;1qO{9Rb~r`O^L zB|*hQ=IUp;)gt?ZO)ATt2e$p;8Y^WL_k>tSO>1Mf#kX*|zPtOj|Lm4O!TibBco$C^ zxC1vQvMere;jy3WBA9)irNdT+Q;n|7Xhs=jN^i=DjFLp#56#LFFwy%yMq5H#sal@d zz)p&r*3YWTC|nmyp<1y>p-QyB+ous{t)Y*aND98ECGRKv(;3Y0cEp8&>L}J-9KtXi zisJ{AXD_h6VcNGU1|lTruEdL$%9M+yYf)~;eH49yQ~!F9+pV^*=%o1%H8_w`pH`%} zw>QB=nS8%@1g)49RXE8woDl29<&6~?3_&e}ELMaXr#v!NzZh)_tu_oPT(t{8Irnxe z!$7wZ^GJ4%W9UCRVixDw)}H(A{iX(xPp=e|?k;Lat5c=bIo4D!Lyie7UVCZPK)DD) zm;$b?S6Lh<=m`F(?esh=-FAn|YRU^S&-34h*Nv#fuJDS#bly z1{<{O()*v)WN||iHGIhRNKjxxnYuXE9pK7?1?%^F+f&Xl&%_q=p*dh=P$$me(yHT4 zh1l*H{Y>^v1Rj!qLlIeuER$o5f?i7l(}U&sF$5UOYd#XKsOXzo{BF5`eH*XK)c=LG zvkZ%}{ra^aNSAb{DBWGsf^>Hy4FUp#lynRXARQ9Y-Hmj2x6}|)(p~$W=gqy3_y2y{ zU;H8m+%tDw*IMT~e@8sOXx8EGVexS2lowv#mn&TRaDwF*P3T(7$Mf$%hWZPiP}Ue| zm%h70NiDn^(J1S_6l>qJYVqy43{UjL6?>kNQonUj5;0rOtq-dkCEVPULdeEaGR|75 zr*^beC_v!tDWioRUr67*19ju}q6c0nw_c^H07dpTO>a^M;W)N{EuBIconoxn%LWa~ zea>=)lhfpW;r#T1Do^Pj8$2=s3$zFY4kcsh_QKb+8fiTOK+gQa=Nd(RUgM6DK2@bA z*ZaUaaoB~qQa_Ti8<%wYYG3mQSA!35bt+RhxPD*U_lSR!zqqOHoZ)*6t9QId1?nvf z#@Wu_721XmE!B$M8!R@+q+ZeuY^gk3biTHjDn13)9+`gq5Co(#( zsBx!V41_2cTrOZZA10ePdRB(Ma*kAVCk*7LK{lC?A&Z3~$63oF&H%9+C9+#ftE4-w zOF=HKJ@2{chH@>%bFPb^h3-;X1g@43tb7Z~(05^nT1YscLPHM7J#Q?s*#$X-NHTsI z;?*lF_b0CU4@%GOhh*lHOQTwXOOXSl3+2hrC_nQEN~5ti7RP<-uiiwhY#592FP$#> zI@fN_Zaa*-mM@IHHV zX+2J>gdji7#uW(q6Zr1#2b0anCU%d)NL%sS%-sYwf^g$^UC0P2#yI{6ZZ6c>OZ_ni zB{I8sL2l0Vg96+tu7j?@*~p%kI>Zk{cT6Z?cg+}S4P9S|f{O*jmmuyGYjT2N*wH6@ z?Ku3`+Drw5l*@8XT3wW4~HNSCdowtkPHuzEc465l|nlibcG@0qEAU+xT& zxXSX|q2%)R@6K4FqItnDbaMjRW9`%TCIz{?*sYg!nwzxkJ}Pj8xjVgZx+_Lj;zq%7 z46)lTbYnFd8NSH~QxBthb&LOUQbQe=)H#KDjlcA-=xk_nB-4%sw(#tT{AcuNr#57+ zk2RD63taWY<0I2%5l8WT8v@sH!UdI0XqW3c>_I8m?+R9$9>sA>A3pxag>3jcU0}B* zM&0ksIxQ};WK9t_6JGW$uz*Q!L5>{ndRXbLRUb`0BsN{iKztiiMrTh)Y#N8m*?nKl zRnmS09l@d>-E@=hzLnKuj@OCor(2@CQ+Ic|jL4#sc3!$#Ato9CDm0!ezob};FPLSs zR!#JuMUr#r=q%Tv$gbim1`*5Y5Cyb~7qT9g+ss`;)15n{oB_E7td5w18g8Ra0CF*? zWDY^uD!F-0NXop`P05Y!tM)0qv51R1(nQyN|0VAz(2%&nQ#NMo;PY2?B*tB|#SX9y z8d~`BnuWnl!#{?wGiEWX#H-;We;01w93WuMl6ZB7UomRSg#njpO&J8tJ}Mn8Q`-kV zhZESk6RdYiB=riTSt1)aMDo0uVGFq;$2m&M*utSYv6Au&s05-~>xmd>0|dW02;u1b0xvt|kXHYyIqk!fQoCU&g%8MQ5tuG_NDQ z5Wx(MB+50lLo*7Xyl4t|zSZ=@P|aHQK0tpJazPcapQmZkPH$V+9}5wgiGTyW4~~j2)Of9Q`VVH|>g}b3x+8 zEM@Ket#Q>o=iX<NNZ>L0)zbbzv)gHDqUQFg8XebP)6=s`J1oXNt24A zWdClimPkz+FTo0<&!lXjTTWVa6b=Eyx}V$Tc!6%Fe6Z&Z*@6>oF&ADIO<;SEwj@J) zK-pfU2+j_@WQ?FHZ9L#53jwaL-s%qZ1UDv2`k-h~2xZGb;Omx3BGUes^k{=#a$mrq1nC?O_j(!kiKXgz0Y7w6b}c-RLZMxQ$h@-^>XS zFboF>WDHlU8XwK9j~qz~5{)h+WJrTL50Z7rHa&F@=M%cPq4@4mP%Ib9YrCmIV%fm0 z`71|q`c^B;D8g|8?^>4e{qu6m!nU<5Qlsu`IDh^$3H~ne^H)bI+?}_p)GtD=`}9(B ztVyf1`MTkx#;!x^v%F8bSwWp8>)qDvw9K+G{?jkpaGYD}O&2a&%Y_3YOUMpGZ+}4! z_=;R38Y3A*)71Z(ULirF+@ppG*GT;wQ+NAMORj-aoPO6ZD%ZDoOdqbSx!mC=1ncjJ zulq5IpBJ>@YO1@Zs6K}RhIBT311bamlUEUQ5(mFTxBa{_8~DR8-$>hzvXpFd?s@lvm9r+90G_ww~@y`f(YC(~$QRGQwmpT9}@ zT~iZ<{bGX>Ef}<$LECMJqA2_as3xl_rp??7?A33C)nhMlOjK6c4-07)_;$JU`7gXw zH$`;l=1@X_f_9|!bL6cB`-13S)gD$4CkmSoJ?%(1GgMjY%yT zaAq@*)D!ngLO;s8C(#gSxtWqx$=;)H@ar*?J#tsmW^F~yA!qD-0^jvcw9z7O^zNuD zJ5T=PWwE-W#PbrZ8?Y{-7T$ih#9mZn92Y(7X|TrEji6{>C9tIK#_rE<$S$86#hHZ& z?_B!Ysp29Wm3jL(rr|O;-^ottQLe^8$;^}I6sme5RC1hq!oU;_+xMD0Q3LHkoO%JY62Y!E zBw3W?*2;k%3WA<;c0D`hECF8=*`*I?NxSY3Q-=~^8}}4PyxesBw!tCaQEGH7s@eIv zSV?VH=pU-W3k_K^6iYWxG?IHOj8eR-ncjt%UaC5JGL!2kFC4RKbAP3>XUrSex410o zGo=}uOeA}qbM^I5E%G~34PUnxP(Mne7`AAL%}F8qEeU23bvHTciv5LGmr!$udAj$~ zBx=W;d{P#BX-fI9kXUws>Y(9MPUM;!zwYgyZsuZa-sInHwyVy+O2%(~1k#=!B4eiN z1F61~x$k4}8vI2XT;^tJ`Hop1yUuupk37csv)HP1f+vKxh-i=S>_EC-XAys)kSd}% z1B>nlqVdR&2<#VF2ecs-hGq5!I6*WTeUKdfmSpO~p>5Ax>ANCf&?~IoD_Zl+V2Rms zDlpVm|HOz;0+}Tw^Ai7XVS-l%c}2nXyVvwY-L89`sP()p$Uy9G$!VBzZ#G&;BBgfC zwhU#LR@}Dq{m+zc4w(;R(|;0rbt9>T14nU#WVJk)+6^zIZ>?EXFs1nX=_fxPirW=hoSG zR={=4gSz4O(hgnsUk}4wy__9&jZ@n> z%UtHC8A+n@iBnYkIE61N_)}s6wyLE-{wyLzrUgxjQGFN_8UhAw2APN&){pAh#NimFE`5No;QzccRB>NCn*9Sx$MZL(mhG}N?w5Sy)-9wH z(Q_3i+W+W@yAh>I5EqQhikhPFhmvR*N9xj+e#vC}fablrvhNPHYHc$f?dCvGNhIOg z`VX*6Uxw6ClQpTW*XASkvBm{kCGI`x8v=rculU)Hd%7w?<@?f!f-!_XkosJV(>oa= zzeYB`?>X)y^Z~|bj3+K~!c`bQjg(FULJ2v%jP0i`K(APg75cwyP8 zGa#YgZOLKG&MW<~IFgUqS0bR#yeA~(>meT8uN_(vay^1cd8YFyrylnh(NN049x>nC zYXM6jow!%S66K{83yw8~``Za1O)?jDX54T`qUXen1y!cPK@)Q^8_Fu{Wz&bx-`r~i#3&n$QB=ekUB_YM`O{a8`VTZJ44n^`#H=r+B zLq}TSa-je{hm88&D0Rr9#Eq7oJ(9I18=q1v+$1jL8DF@>c zRq$cRbL30dA9XK}QK16k0gfpN$ax|^yDzqP-wZEiaz_9Q7=E#g6)=AY;G6Y2*mWTV zfw$l&dIL!u`$T<{cXvM3jm^TfjGvn_wSN>3=X%d6@W!v@3E29(?3 zjf1i^ze8stgaR&;w?Mx_xb`UGbp|-+w)jUPbBQRK6{K-Z`?%nB6vCZ-SkTP1xNo@0 z5prgR_xmJ1)QSzWSH?lDrExJGi0IMi{NocwvGl*Gg#eIY8FtQJkqWBDZ$6iz{($=W1W8Eoy+ zn%g4RX?EVyBPed0n$l|oKA&JnPRLSP(n^pe>eQYsg(RWO65)>EFZ7s}y8&*Z1e=-5 zYz;rVeMtdm#Ie6m$@Wc?@2<3+E}urE(@7L|lpTvPDUc|0GJZY1T9BddP?zwu;}vnj zQ3u!6;^x53;EKvo_VZzI{}r#xmj)Bbj-8ehV_s-hz02+el49W*+pKJJz2&lSyTe%e zxuJE5*z8bB9D2>#_DCJ$=YxkY3*N=4q0jCxKqd>*9}z@FNl}0z^`5@cwmXDYk?8jh zpx3Z&1Bea1s1axxuvhE)i`J(k&92tGrqoMHhmP-Q|7ATEgVeNopit2q<{QaHhwv{!a9M!(u1~MUW5OlDPq}nLTkD zVh#9Ck>)Y`b-nZ(?Pq=j;vi*>>AE$;d!FOjDB6#4$8@p*Mf#X-N6-tlL-VO8vS30} z1tng|D6S#S6U8iFn)pKot~D7*GLKLH(o+80PEo%T@<1`ODfn}O5y^MB=RcY~Kj0b( z2O^!1eplpql-az<6jH`B5-MnZkQRy)R!IwWH4 zHxN|LtM^y9ofpn?;>ysvSZr@+M2`8{^rFRgM=x%y0G+ZOfU-JPq&k9aU26<~X-U2Z zc&#DUXKb}|x*b&bxG6TXjX>hTOeUghb*!KR<`XR8lMX%oh{xQ6;}KT))e0-ZTMXXfa1`A&+n&Y=Hs=J@|p`-mdQGuVzJL z1+{kezyo&&#%lwg5G2bg-5kACfH}&s&7To?OfDfBsr#zySASqok~wd6gREm*b#UT( zf(KiH^Wr4uHqF`3EuX_S&wJ7)SL5##*tCq!JcGV1s7%r-k+rzFAfWrp{UIdtkoHnL zys)m~|NG9ptTgO=e@K-L!49x|1W>@?wL~w<*6!e|sH^B6&#O;-z}1oBs5SbUzSAh& zztLMXhLAV|-U2F}O~?ve222g56yyH@W7sFq%vG#^xUggzgi0P4pec6|uY>M_v}G!hjrvek2B^b8T)!J09L$iz)hy+6aOIM0OipQr$!Q_mwZ)A-BeQE%y(ym8@23n}c2NWi>J4rz>>HqC))k@p42W(+JXOpqHVvdX8Y2M^b@ZKW6(~jJ zjEqfZa3awAc;~PGLv@Kc0jsB?ei74YUL!A5v7eNX!LVnF>lGzVC}CqKw0&^q&RuOa@`N~@1L2r@P4~(;HqnsRpIl@iXkzK@c;AS01SZ< zMy0uk(vxNczW;M92yZUl!86bQ(!CR1OQn?2PCR@7wH~v zejoc1!mvU)#;J6ck9E=LB|mfI=ZE-4+FHj14}y%J&XN)@N{xWfr>&C>EI*Le`Qdk6 z+_56(CA{{JZ8?#o*Q2mD{?b+TdlK732K$iI&al^Mb1u=y5cWMNm!?y#k=ThpR?v0( z^P@<#x`Pk~w65TF&560F>Fe_@-EZzP1h6o5(74ws7p*XUjBS#$Ps=!L@2~bT!Bwwo z|E8xl-fwCsWk0jYQsER}WX2osu7R2du`e*x6&xzOMcp)^sL|?tJ{=BkPC@vou_W9R zeTz=>5unDfC?D35tnl{8k3pfuOXDDRaX3Kl=XV2u1A^jjQq!c14rl}C+%@*JhIvZc zBHvpAVXhcxEVU{;;Miw+r^OUfPtiaNl~C8;{AFOV55ystj&)7}&oEaX#qEGBCKH-s z0cKkEC(eML{JIs|ZxV6oA*Z@!_W+<+3q(301zCxnr-(%FFS&p3w^K&^blUITkvoKD zg|o`Z)Tf<tqbr3ER~HD;T-S%*x6n{I#cg z*RS%4HjUVG;B*`)d{eMTL2HYgFl#V?S^c}^+C;AzbIW8O^BK#sk88{Im?^i!t37B| zq_L)v70%u*{jt0D4N<#%UlHgN_@Zn4umaykwrxMLh01LfJZm$ylM=#DH~b_eRP)*L z0`#RJFR_H#9{@xZ9laIMd$YA}U^pdb{|HbuMb9t-07d}n14)1uhm8n;Otu0w3@!V| zpktsLxdB+hrn$F9ylz%@MF{~EhcYNZ+epA0V7!pAycW8`VHn9ruHqv1_PkVp1NaBdB0Ez6sz||WakSBgJL~~94?NW z{Djg!ccH*Zj(=orvRJS!DI>w?^t+qR#02ikG!irqqFZxK`@jobxZ8|R#{Pb z>~|=Po!LNS1Brvq)7DCzna5`|5BrO7?lJ+ybOU%GO<&!Nd9>jchAyxmSA3l(zL0DqKL&*l(;GoGNO$6$hu?{-dK%=9u@{^v*sRvLwlPJC_6WR7?ydEvgeRG{A0{-fx@C=k$u%@)TYZU zKN_7kB1ty-eR8kur&@x>M(r(?vH--5`$VI{9 zbx{S_NVMa|&v*0P9Q|ZDKF>|#K8^s{`lKqT_+ev(TS@(N5XqKFS)2Lbjt`_!ROY1T z&C!7k5H}|;+P#1)f@~E)r$XmjcX+NE-O#yB)#+WHF&w@E;bfrz;KW^8zhr9)3zd9= z&-6J38<+N9XWY#cys9F_g8*jM&oDCj)Ch8=$q+iv+q2dq1_Edd1&Q9BC zv;p3?E0*AH9eCzyK4N|oJ7RMGvAHGr_r@M-<>uD)g3FR~^ZwVv*)Y>u9eX(tqUfe$ z8jN2nwsiUhvfg3ck(4my0>i; zxT*6&EAjlY?b*7ffq5sNpnNiBALVlvkox(LnpGO*?5N>$lK!0^d2}`wCtC!HFKYRT zV3_9~5G7i0?e1JUeH+c=M#5Y;GMYOiSdE4V#eDyyqrO#%0EPC#W|6anku&`PYt z&UlIJt&o9hVHtDoWRTyO>n8VUEWIxyZz}2TeC`o95)KjgO@n7l5&NP9k>V+EWz}|2 z)h}?Wzl@CbT7jbK#>69sVP|)|ZzfxO*8`QOUKIfFlhOzvkW3mnsCzC!Pe{V5XB~_z zjEcjEUwtyo9;qh*<9bnb@oc|xcFubFf@89=sl)o-ti0p<4bv#cgqO5Mt9sDhcHpsn zodk0~aAn>`A`;TrPd^OkyPKin1X-sm`|PV*rte271fbz$*$C@`tQVzC@+PG|YnN8_ zk@TKtT(?Tl5A^~TMq^>%tj&M@E=%sSfoA+p>O+yuYh(J#JW~VWAzOPbQKP$Ng+CF5 zZ70Db*FY@o9Q&;`-U_ZZf+PvOM3@BqUlN%{WI1rC=tcIOK0;`)0t8J!UdI~-3-yS; z_lGmu9F%JQ6On_gIP>W;0W+qetkOtxFKvS9U2hsz^IS()WuF3th)>qv>!tFNxEplAf-}q`&k*b zKmAG#ua2SbHmiw-Ge_vnW>Hma8ZQ@gsmdr#P~iaWHyl#j5qRKFny)*Z&KO#K&OxiF zKh9vrL|wF)a>7}IuSD>h;v6E+ba*H&Qu1zJyU6FWdGh|~)VxREdk*7M1^O&wRR_8x zz|zn9wncdn^S}POEnO+DQQSrQfGu8rSgWvGo&n{p7@mCZm7#{uG6SShOcv**F^ZiM zyrQ*^>!TjnqS|@%-b8^a`k8Mq&)+S6ndD?2kHJWQr(Ny?wphCvN^2{E3aRW)OeM^s zZslf{-w_KTZfSPdj^|vuS&27;r@v`)ra3Uy+jssnO~EsSjy%L*od8wa^ZkjKIydHyX>Yo7CZRP(c|P zgD8i-`PzPbprqpu>9AFPk2>L!d3p-ku4D;&+kFGD`zPNKk7L+$M7@yrKh_z#v^%S5 zvJwcNvc!Gv9p4(`9O4L{-&IW}e)XbJ$L_7@>975z&}7=m^0=JxV0&IXv#WxbsNdiH z`X4F)v5{rfjp7Y%!I38^rOjr6gN;7%qhJHJNx`@c0y0&y$rKsdgoTwPafr2o4W#;I z8Lro4{8OkRTUvdo`kz9H<=7VcW6;>Pgm*w;0Z7rqwNYT=_whjl0^>t?~Yq~pf8_niS>93vP{iNw$)=N>m}%DK>IXygXk41;Cg^ikeZXSE*-tR`P@I6^q%1%L`cL&4FI~&7XVb zpUZ`U9OGrKe{aO!kI_6ORCrq|tJ;^&qs%gMcIlrGLzLoH% z4Z35#id5r2FLg}M-;56E-@b4vkp#FO#f&r+MeZcjNsS5ZlLzGTpE!l>uJ@AUys00y z*8pHO$CHYmE8}Tb>{+*;#IvIP>5dU^od@?X@c3@FWE5!SeT#|W&fvi+Hn#1i_)uGF zzfGT{-F-~Vwa(C&S?6Q(ak6lV9aqhrI8y+2D#6YH;h$00QxL9=!W zvQ=>uqjN-!6CairP*?~zNfJPm^2<&4_S(FK11ogtT99mCG_5${*yMvu#k}2O+7tv7 z3hM`G!10%sol1`zV3{KKDyvy1z6}A;;=TLm_GynY3i;B>!5K>}XRkKtvcvgwy-Q4f z9{zdwBFVks=Sr9Q*(S%oBv8V&-7_Nn7WQZ9@NcKX>15gZ3Pn#TT>Zt+QLSU=TC7X? z%j0ODLvuma?RX7cw`H=*+mA`2K@;iDPtSlflxaE+xG7~C%U%wJPAV$tE}b}eDY-X! z=ME{mPC<&H4X()kS6r%7EkBy6sembUE80b$1A)Xh-yf(bTh9i<4?iQMoFFd#I2i0m zM;}lMp+H-wmR+NQl!lo|9|vb6nqGb7M#ld`|6R^ICj58gyQaPG$`QpGdQz?m(H7|d zQ~OmoE+_ueTScNM3M9omb;7<=HOS#-dsX+yVQVr?eVAnGLn5=p&z4VM|>u6NC7(pHs|TaZ@F9vi1B^ zaCv7`tr4`cG8R9}`cFGz#58g&W2G-n;xZqkDvJCZEI<5`OhzWWz}ZH$gILA9z4TkV zU)2_D&#G{ydnNI!Io#!-(^*m1`+|rff0W;s5u8dDFu|FoVZ6i7z1@|Og=2d`hVrMM zN!js-Yd;n=qly)*#FSyQ_g28-G5J*bId44tL|_23xQ$h){p;v91Ay%K4xN61I5{5% zn_H8q^U817kE_jVJgl6>7_lZkUL9+sK-m|G-bELO*QbhZ5(&mHQ*yiPh}o%6jxl%& z5()1Lj8EcOWUC0OR+^WcPIi(RrQyDnAXFllxXgE--cKO~56CSNmQnNktPVw%jMM z)IP}c^$SklT(Q^Bsr#|hR?3TBEo*F7A;220oqshp;C|6x8Tk>Vz(|KuvX36tiI2ekj&-4fX^eZoMC8# zqxCJRzPQqdKL&CL%p2AmEM0=-&581t5m_93 zTM_LMlu>fpOC8+d&Fzl$fSNy)=cHHHZmeCk8jDJ#EKik}B!w!A!8@uuAUM2RQcbm; z{fiIQdWuv~`Sw_xoUCzL6=XVC4p~zCPQJ(=v1)!DDopfHJ)9pGKpgw?#ne_H=`{OP z)HJS}?hhg@hvxwZSf=Fb8}ORq?_pI*{9+9b8rI!gf#vA;`4AIFY@J1sb{vJUIe^GQ ztWykrUy4@69;ndx>DcTgrjzKxh?z@R3{odzeMd7kzr@1&q8XTFNLxBj=NPAWMz!6t zumtzk821 zwgIpSQPVn8NMPU@3)d$!XhFY>69zA&*;{yY%MLk=3Zk18L*b z;l}NjAb%*4bWRI%stAe;^aHmOTEzwyC=oH;pmEjt??U?*yzKirpbOspn644K*bPf! zDJ9z@Rm_<;f@4?V!#Ha-dx7s`uW%KcJJLy|!x^_PsO{&fbd7#s#c8=g^c6GL1T1a3 z+mCLkymMKOG=2!%J5rs94R)*)4)@GRXl&Lo*H7zcvvV&|p;PxEsB>yV`?Bm+9p?F; zsIC(;43Xr(9*c%}_$I&oO?Ip9`jun|i@U?PCoBTcX&)yyGJiRt{lTo5lS#-4*?$*6 z{)K>u-|l@4_RC(wcdL12W&_8~SVErYCFstc+wUT5qkaG>u7aJ|ZVxxkM?Q`s3#WZL zLP4kQ^wZ4i+t$&79UUMq+{NT>lf%k)1!KI9hk8j3WCgRb^*P#v6?ULHtof)UJZ152 zbqFOwWxEpk1kJZx44ri>aC3Y=d##-zvCL$9iRU7n2nN{+ z#so^7CYnz?k+@TtvAZs9WPcTgF+3&r0!&whQJ^zC+1Cb+o3<*W?34I3Tv=AevdUgA zVEKlUDbBEE>&NmgvqOvfU|{3p*{tftHs14SnKE$VFJ8e;yl&=b%5lLzryi33<&TiS zqg70mm_9%EESJa1_gAF5^>TwnqmG7%Wn7WR=ud80MynyA% zJ(rg0l8tA+3rIg=k=@>ZZYfRC+^0V_jaG=!Go<6>1*IIRuH zy)37mbLN*eA%s4cTp-tox0A}((66$#dFCYsKfw+e`A#!17=;K4{)}GlknL!WN&P8- zKb0v&v7|Gq9jVBb(X{nW!c8y1fnP6mPVCU54hyg=KpB{2dN)F^XzBUaM=Zi}h^_rF z!7jtoZ`w_-kJDR2e^a`g*@Ml^OTvL?fX(n*U&o`A?r2v}!*t)jKI%)e9N*(U{k`E9 zzTX(0b;;UzX`1++41cfnefm^k-%IaECY8?vqR?Zmlh^&P{DCs@Aw)I5M8Rtnb#cmUn^Jy|}eYFjoWa4A{ zd*1mvRdq4Q{bzlF{i);Eq5})Z0l=1`CH_a_oNOv6GB5m!Mi>$WzoU1P-MP3>B>bVt(@Z(E;%#kN*!oxuuq*gU5x+qZ)+t-pIpkemC74t$Hf^H=x7G00?c8Hs&pkGp1Ndso#5_sRW%qz0KsT!*Zp+^^TUvEs_yeU924Gut2|ppUFy z>O*u+-TDYC9UfX6gI|JGZeLN`yXWFl*WvE_CY_xNCnja@vMa@d8ZEJwGstiK`|Ybx zdi%}l&rUYWvl-gw^uqXw-FB{J*S2Pd*8Nlp50{?(`njLB1qHT<%Gs?nQF@#ujOu2 zhyLUTv}HcH_;O&c=935ZQ-3TS?T+GAS#4$cBYSXo-mJ2&=loK4c@XhmXB|f2hH>4+ z;=NdUywC!WX}fnq?fubkh`*s6TJ@T9N>jthbMM`nUl$bA1nRZq2N5gD#t3T7;EhjJn+>k`8IJ9>|nUfvT3@_TcA6|PE zXu=OS`t6KV?SpFSz=kXpi`JB9)!s+)$z{8nif(QC*p0Lw0$hd$Y)IRD7PPq1mhW6H zDr}U})f0IimNPsyXf=INSq07y3Y&d}w6U@2*MZ@7slp)nq^EH5I(R1+my0TFA%^|b z6y{TGnwQ$pu&i9>V4`4cwlo*I67+6-p*?4w*ZDa{J;>39^I#Qa=y%N3k5XBAMpdQ4 zG~Cs6+`m@7Sc>QE4Jj#7ld$ZIDzhVn|J6e+HsXt#5#k zE1ksm++VmA+*MIcFZKu3-Diicw{!H?Ex)_tnihmWix}yr5OHx9Y%1CR!jEVF^jDD? z?u;D(EmrZy4NCh1DbMYjUnwd+yTz-AXi#!s$zRMSccfm$MVpAX_i@D_H`m(7qgA;5 z?98voof<6)^$wc(NNFww5yA&jwmqrczoH6rP7$7Pev&fi?ga)YJ3~Hmkd$QLmNC!$ zz4E<`c&qqPIVky#zhSHi`n`&|Kaz)Xa$kjT(}Z3xiX?~rZMq)d1;oUO!)b^l~`9BVrrN58`Ed12zpB2RFiGI8WC$Iwfx`0(-& z@Oqv#v`)bJL+MA@O+#ih-=qBT1tVWmYw9Vw<3o6eQ;K|@PfO%DnQx;0TcD7*Xm;$r zx%Hu2N~n>!;&*Kx*h6riajEG_-eEbv&yLlI&XHojr}2xwhuLKDwD&E2KgI8%04YAj z%Ymbs%`lmRArCoTCa}o$N{vam<bnBU*L=Z)S(d@=OWxv;Hr-fM;aqjC9a#?D zUw^D*1bkSN{JwvRAiNsZE{in0=RDrb}s`drr+;=+LL?RR5lQkl`cglfyWJIV)w+nR=B_!KHPoaa`N2!2~W_if@CFS6Ko31SbWhTv|L!?SuqlRvh_8 z0Af8y7N8z0=LfQgF3CmV6}WL&2dciqcgC{Jgt4`-AX0{w??ucdpuUm|{5lvb1Jsc9 zg&Xl)ETqo~Uq%NL$*>KFynl5)Se>Ri$Kdud&OAWr>(4fWus$_nMd9p3$Muw;h*$B6 zYXr%bJws6_vmIE}WN7%GWhUMTt%y{~eRQ83ayj4Ve{28-r_2am$&r^u#;bE@p`Nnp z=D*DEL86?@V6-MgNTYwCHe-dv%huj=i=1s@`R5$QC*0;ax(ult(R$}%TkDEm4Bq5~ zeICBcvQ{BL{?ZZGOhd+Aoc|HzC<5q5esKB$h-|NWG~@>$dJsjX0NP7d@ir6BI2t@S z5>p`iiF%h64P%=U*ZI@#Py+w5S(J@;XsW*8{7BU3gT647+2pOs-JVaGR~+oPN5C=d zoZzLYOeiyif_|zWVn<3U@)z{ks6V8ied**Z@VkED@*HiuhL`3e0{+~`n1*Qod7b8m zyJ^?kC5coCeLpHS)U^AW<0f{~T45qdx|Qi)jbr?lNpWjLvG=4jR`m+-`t?^2mV4)a_zSw6>C`!K&w8G z^4xl7-nj$D5&l+>1WjI=%JU<^3e^Tr)L}>6ki!)vur(mv8|SjE~#2%{pISSQkNNJJ~a$nP^9(B zL2LM#9{-xYvx@3KmF|xgoUxsB{vwr?r8@({C%FJkqYpa33(6y#)hFc!IadMnD$`Px zRhH0er_MWCccE|1I<1}8r)Bws<{57rkQe)(@|&yU40W>Y>L)W2nhFRSMzj38Q!RKaBfZ%N}}}Ga5LOj zFlZBbJloeWGVHU$75kX?0~IP1zeH!M@N8oth3xVPGAvC0ol3W3OpT(g}*CV6~ zGK$Qh7Bt^LZ?t8QQIbpUek?9;X;mgzQvZkRkO85U29(zW!sF1I(j-uj8;NbA8tRJ@ z{BkZlAJoyz;PH1=hY5mw^)Y7AKJMH zZ*<-#PLvgLC#4Tgz0>MxR0!pO8s)d# z8sLtaeVIx$uQ6_6*8M3!eoq?CABZd!4P!yN{7OnobMfJvmWt=MzMmZm)rb}-=M_^);`Ziw+OuLfTX=J3PQ!k8^u__;W8G5Eve zoJTxdT%W4n_(->pK~&$+j?Tw~*uwfNsIGznh{Q0MN-HJ83_;2tRISR0He;E{fHX;w z+weFHeC{iRJFI_bv`@rvRW`UiSC;F^1^lWgW?^DsrpHv637?wi#OqReUs(aow$kbd zr}r0Bn_^`C8&vFa=6?JO(&L?_7xkb z6RlPT!0Xl?yX^`D#)bfqugtKH zuwFr|j1{AJ9?;r%MEv)ZdyAFpw!r40qh%Lv=C%vuchfOAfA)V=%$M> z1jx)|1ZXBPWTuK%7nls}pVogRkT8c3GOxONHIQ?u%`*uRJ{zb6E~HRkj+;XmfVj}b z?ia_q0IrG>h`j(;{&rsuh7HG?0xC2V7)8?sNN;#+?_l)Bq1*vSw5J09R*Ym9&{4Xr z1oYR}!lZLp+-HCT{ND7(M?7o-i@~l^j+wPz6j1xfhR6cQie9VRyrFj8 zRO1tX@t}QVt_lia1J-dHUTgOmsI%DK7=h(L%j%>P%lEU4+A*kKs0(Ng^3!_jz+r(p zUdqr{l4=o)kpC<2l879JQ;_D6<9C}P&XVB8Fr$f`=UudP5a}KQz)(yKeYj%sWlyZlY|Z<$d}%y z#p=F!!NPU;-O&5AcLN4R!h}a1aNlfFe1KX0nQGVg^K2|1YZ#E1!(h_*4CwmMW(Wl@ zXVkj^QcI|;#wNNhZ`2Ebm#p|3%FofQ0obt@}0!8!qeqa?rw@Y{QY(N2{>vfiE#tK$|L zkQJz#TJRL(hx{8rd@{d_4TH;j} zoF@}Wbkl{80M>N^FrJ)138h_?_6a6`>*^Q1s_MY$C3S2R4^}2K?Wy!rK(;Xg2)fW- z0)1vO-PUC(v5h{vjbQ+-@1YF7EByIpPrRKoWYUjHvw5BRP32+`2uP$Je3qHN+ zF1k3t*c|0`kq?Db7Ki%+X15T0Egfo@X-`#r=^VhaK2L}vA(nr_!hl=l9A;Lh2V5?o ztF7igKf(K4pGk6T6;z%L|}Pi!rgWjr>Pz zGA@~W$;9a)sJ_7cmuM-OgCS&{`FLoB9|+h}TD-5yJ$`*ej6rTsH2P|TA&WeZ&zH`% zPUkOt)9o3EB9?iczKbB7`_Ei8@O?9!Uy=T+8zfl`0kt5Oii$)&_)GYvbF`O%GY}ze zM?r(k)Pt5E0)~6u1fG2JpHCBuOw9sInZd{#sFT)=tH9TtWV#ZTB?EN?xCqNe>u4LI z+i)2jY6?DZ1wgX&0?$&tFapifGAEysNG3gV5^e6`2*C1~X$iWNsa-|I$x7(_iK8ui z>^VN|F*qLfxuhU?adzkp1t-gg3IQANdJ#6Yfikf)dx2+opLR+H@(JEF=X=M$jZn<8 z2IS?)J=^iBhewmvm*` z{`jJXovp0{peewiTG#pj;4>D0AeY*vIpg6f@`gck$e6aVF!;DPa`lV(#$fs6&s4I^OSc*yS;ZDVqpXbi*WU+5gc(m41ton{WB9=9O3`P8!?5z}MBo!2*#zn#65nfD z<64x-a!Jw?KnPa1BmU#_R7aHtOr7vQ+){u~!542DxNm;!ireB}wE6f0S!W$$`gfEh;XT(x|RuG6j~E3pfq3TR#pc}_d9qu$%6_jZl>I@fTTrD1fElh{!{-}HCSw_Wkn<+%f)=X!XsDUAP| z0riheK6_AhyB}70F7^QRQR*@P~ zLK*}Fq;p7Vlv27oh6d?wknS3~yBh|$&-||Ie%?I)-~auy*7M4>@T@ueoU`}-#{L8n z2gt>J=t^6G(D?HEz3S}&00vYs#d~=-2RH(_F8twi>STeSZDM?VwIcougAj?T{TyD@ zb$I(fIz<0rgmPeHOjNoJdh8`XQyha^RhPym^qc{L%}wRQf+qF>cuvtaKoTbdJl0>H zB`i5jG6o>=3q?E4B=}DIx%#B0-_3eG+)XrTkdw{ZFh5%+ruxuH<6~Zb9A{_aJ{nd) zWFn>3`Bzlb?aeteXnzxsk$qhMb>%Nj!|nW`+N}v)$oG9qYd0+oz?{9;o$p4b5&D6= z@a2+4P0a7Z<{3aH_3Yp~D&DZWE`T|`c-PZ803R;4rJe43P2KzbQKVhBl+SURjGzFZ zul%21zXMVUny_*fh{{=S7Xd*+VgBi3Dek6_y&#YT2{Br_FhDea{R{A3j(m@c`PW9y z22jq8GKh(B!C`5y5r0+LK_m-n!Fqj%8GO~=MT&>do}WrvkuL%${_ea!Cdm)Op9Dg| zksnBiM%!iCpON{`ngs68qKT&KTghH^jD zA2tcbwfx2eP|8_`9}f00&IVYcdewS6aJ}OW0Nz6NMs$Mw<-<%+h@<- zzEqb%<_>!^a-9Y(654Ubu^b2z*IHS;l3tDj8Ui@X1xQ-Q*?dyPd#2)PAP2-AdB-$H zD6V1Kj>{W$ZEt_nib0z3SS`pzizdO;AM@^M8LE2IYm|x=#Ocr>G?02lT6OlLpEXws z;c&n#Qcsr1d4!C40l@juk3rih78H>QxA4%rf?@)BFiR#M=N5EB^j~v30RoNhhCf?6 z%zOyNB5`j`ziOmsPvRrRoso$UHHs8deU|N%j&q(4Zy1*dpsu;Y-!`qlzv2w+*{FE+ zcC@9~0N7d%;R+r4twE?ec;xx{!^b(BFHsJ&d!y&U6q+j@&*WQ?8Fx@=dG52X)k@XK z1|?|D>tFL_hgZNf-u?<=TYpA-grqhg6Bloz+B;Y8V>R@5XzU z#)z;MW}5FT4al@1|C0+~B@M$+A%zVPU8RKn=Mcyqj9HTdXZG3G9I!;=lMdy=Xvm@c zI15y|ZGdwsM>W%a<-bsuHr^s@#9Z9N2`XF^BoMcae=~^~=ulFgAMqz>3w`>x*h9vP z+>4yCUGD$$TK=B}t`gXSnp51NtN(95^Uqt*??;x6{kTgr|5lPAe@%`WIn*ZbDbats zDuf)_6{~$LAj6SupXN-(KY;US8*WSpE!8GoBpG|^&ht^pt0eB9Q+NuUv}@m z)z2o#P`!bEwD+Gs{{P6E=imc_m)A>#{`hZKb%p$+Uh^pBUjqfQh&@9VZQB-HY-Rs> z&ioViTH=rqIF6#F-1)yT%|wuc_pscc|A(FWFWCqg7jj0}qq zsR8IA?Z8iv zBZdB(g8u;7z8_GJXCGc}js~A~B6~RBDn>q}zxi3KS_!Yi$;6*v5ZS;`*Yj|khHfUe zk4RAqZ$$J%F4T3Q#?zj+`|WRYlQ;#*7gGCxgp)E%_+lDp5K#C5?MP>}Q>)&7s1~un z{WmZn*~Ro;@9Y6ktd}CYK)~?05I{__F1i7b2ULIy^`A)>dBQiVz**45v-hd{!Z4w0epx z;F0{G;e-M9u1I5vSxzv()eEr!B=R+F_RoR76Ar)v)71~DP=fG3h`O0Rw$f9oJPw`r zHcW#B`Ok-@p)i1zGu|-3rVTv|nMi*6WzfEPlY!zB>TUQvd0OL*lXL&&eN5qgl81A@ z$mX2eP~$@-;5gklwAbT2Ii8?taSzl->c|w^a=vw1RN?cXMO*Rx*A%j<&PtelMO8yU zBEc{U_ZtGT&=#Pmaik-C@8#TlJ3pp#=sM+aV4pgR5Cwwri{u4Y>@;bZ!7)(UJLG5F zoy0a5mOTJG8qQBIcji(S63e$wbcuzhdTvBi6K*^gz09MR> zMriZ;+}C^SL)xHkO!SHIGj}c%&@phVA3?G196gYIb5kYaurez{ z%YInJpJN^QOR(`IxQ1eEw8-d1LHXzWy5|fJ*ByaS*o}MfY2dGXC0KaZ>g%2p0 zwYoQ?>z#ZM}Jn+oTuOeL4qr+aGxAlw5(<(l4Zw@ziu-XKY!+ zA8lgWqe8MF-`j>)^)rYPzp8^AlzscXfx(zk?? zq$fZ^G+#@RqV(^c3}g&y1qRsE!{$Tv258 z_JII19sW=nR85FEEIziB>~7bIrv=%|m^+E7<_02kH;F(?pbgl=9(i6%pW<6ZhUFdUzptk#VEKr zTY_iE^c3oit=$6tVt)x;P3dl&J2bkf1c;$M?C*j`={7hkXm)&?k$nnzHj9nR1{Y&E z3bp%DtL)8dFru|`w*p?c-*YO{IKPbN{1GUso9Et2uh$k&l>of;%3EMjKeZpa9Yjt& zr_ayRp{(Ce#XPRx#kl~)De(FW7Jzoz&5VoYXbD;uTHqKuZ(`6Mxc|zt`PInf6(Z*u zcw#&gJyc4JxLu~+)c0|vpo;J+`4GF8^7e}}YAO_OGeXS!1d`fL?CSK1Y}HluA|f?x zi*KcS6=M)=<37s?MuTK}cOX!GLJntBIUksqJix>>k#-wf>DYT?E8ZFlbo;ShmN-=w zeBuS@x1c#hAVlzbcMAkg0s5%awun)|en=zHJ|<##;aQVMsCGKde16{xz4+A%!PZXOy<+4*=zEC00o zI&rEJQuqnzc~lO}#+#;Sx;fY93%pmWH*2rSm^Yf*1>7bS_7B)RuF;&$a6fVWURhwm znlF&m*-?&0t9@=e~e7A*hD8PHVO0f^q+5iWKZ`%9|u^MWtAX~-s+ zX@HYs$1KkGdeP*h0-%?ctBNFVItFXaWw`DcQEN$iOo$Lut!9($#|%Ws2=Y0VwaEhx zALamcH9r(>_l;vE0Har{ZaOb2K)zfm$Gb0fjFtU601d+4u|R9S7pE9$;8EOcaaoq} zZRrHb=69Ncq>#TxC*A_|4~oA853WFg{;k&S>J!ugvOCA-noz88uYJ!?zfOHQrXhAzc`e+!?+`gIscz`t6KDNd)D0x&s1e{GB zf6=ca_@y!t!aOv?}RIg;$WZ|B=UB_zWB>LIHdpiQeG4^8_27IB z?ZKqFQLa)?tRNn74#xxrKUM(>Z?SwwC9&4F-`CxD?s5y=;~;2cg2ekoV*}h0<B*U7%{fp8T-~$=y?rSLki_DW?_nDIR=;UAId#_gzZ@4N!nX9F0Fp*gsbc(O^R!yI7(|JN+nam|?wz^Bi*@pV!!5 zHrZMSkp`7S1q$zP*aw;3+*F!q8+o>O6RewBMXKl}I(pID`_Opa1E&pY+a1xNBO#$k zHw??LbYcx~*e?=$vt-t4D4V@=a?1&`oKT?4lOd1mW7{0-V$t9F-T3i(dBs34T^+Lq z{uO>P9uj=*x0lD0%rwKwU9J6buz^@2D2Djj56;RCIP6irJ6q z&3Zm0bO5mZhr?dV4jV9{e;$t~)Gc$3NMpK8sA%D#c$6SUx6eJrh(#u}Py6j>n#?=* zgrEdm)P?Ivf}wE+_WmLWINANAM_NMoHh`kLfa8VR?_lkYIhW?0PbKD3RU9NTFW1!D z=*k_x%M^6q0ZBpGV1(84KMwSAvI&@=J!2R#7&SX#I!-jqJM*)+OGuyu5!q*`ZF@5b zm6{1|;YPT-68cB%D0m6FiaiB!%A*$=qo0cHqAP%I3d8(av@Gc-8(YGY{?{J_5;?vRu+Oz{99+lnZlU!B?>${<;W2dB zm+FfrT@BYKvVAxM7JO9R%8vMy>9M!RW~$Rde<*tgC_VR%fl?mR!t01+`{Pn1-8=4j zFT|i_nm&jC2gtQC%iRKdIXx98Y+m$bCVb49o!bCc?(=@bG5j7QKxcKoL?KUx!C|&a zbCT^ZTi3-?Y+$^Jg7NKukS(8n+QjBXqH|mHBnT|gKxu9p%}ri$W9QpXmH;?-+qWmw z`EPPRE;{}@A*$rIW6@0S9+kU$NMx0;L%3}Y;@ke9BdaIT0?&~)o5>wOb(a%v-GoRY z7o1T6h9IZbx3c#)Yamgx3pd~ZX?H>cKhFzqnLD6a$vNG+8y$og67+(lrhh;oS*Yfx z`utb(zVeYYtloX?HMR7ac!#*gS7rt(=lhp!l+E;aAdd&dX0=hgz$;IxRTAT!zCJQ- z$HZ@S!0D*9JfBQvX2e^+|so026TtVn6!Yw&KeE#;w+A!B7I`!+k4}&@u+5G(a3_- zJh6Oj2Gp3d{R=!--_=N@OV-{FT{yXcKkgqh z;FzT)QueSQeM7{$TpaS4MZb&F6q~ zP>t)r7=&hVWt0(%je)2ab#(1REXU49*DybB#q40on#)=9 zJMww*!V?R_;I`#7bBuE%VBj&j-W&(JOgBcYO%R29l7qxw#Co;;bw~SZdx;)=NrGpN zpzhjFRgf7BGdJbj-fHfQ$37$@BX>FV-;6uLWPgJ%ApydHtps?liJUxs*$khrayQBp zmzrS_B7S><3+2~=1yF#g{#Ij8*o;+>M8HXzFMGRjH6Uaw@Ac=n<956L z*r$J%zNKvIA3Fz;7X1=&Pm0Wa0KCvjomg3Jr-gor*|(|n<{H6;C`gx5DU9!dAZ}t+ zbL&&bYIDJfo~wM%;0k8`YRX@EZs~q`|HE_s$FZ-c;tt`D#Q8LiI2WON=Fa)qUB!o) zZtU#+Qoln}%4(StPIUF;LXM{1eH7gDJY9?dQ!VYQx9fpbN7?6c0s~b)w4{?mwr7LN zL#K~=t#QVGY`fl%Y%F$fa7gf2#jKeqfuALHJ)PJRC7|W1dMzYg>N8te>{#T=Iy_M< zU9JiX&^rt~wJnJv?K)yNTjvfih2K;P6(br|VOKC1EXr14@VO4Fn3{sal8RMO*4sk>ny^bEBPqi@0?e7jV`DF%I z;R-8WMC$0^rW%Fu=Un(45xHx;=J^pUbJg{pUY>CP6svQU!)L_M<}fMVC(hK!@a4X( zAw^yZbi+NV2cdUg_e>nx;8TQChiu!M#AouHQZ%b$cq=}rvOTZ(gPG<8T8^R5k0gpF zsjPg;5GLUGy|j9?NIfUw`)8k7Q>AWAvy7Q|gFQ4c*r*w(D8hSC276TowJt9pvOBR^X~B< zE<+OwLX>mK4t2Ss9Ub2$(*J;3BO7;Blb}6gkGZhOgki$newQaV$M&>GtFtiri{G2c zt9wKmYFPy;?$K!KByz-2G9b4-9qbKyB?D?P;sh+`d9km?-AcZ(Gf*)~MPe?M&h;8m zMtX>T$j=f6(*speO2LXN_)kcrziSFmr3UW+G z1$E2ewH#U@OO!bvPGDUTod?gQVBX8j9uk;zL=&5vWhn@+ts&AQSsfQuKVOtV|Bjts zDvPjKo}Ssmvc^&x7HL`LX*HlaP`Kp~2Oqy4-m$ZmKn*a@E2PGk9hFCJ9P#_EY-8)^ zI&UF6wHvT%3?%!#G2Df zyb&+@BdkbAAu{c>E|9VvyZq>gS!flSyq-6JiVY!8ivVkJg5Io~c8PwYlZ1IIPyGs? zfX(u!az3_&c|HV_TvPlNQ&x}ymi!}5#iI35f{uyh3`v_M7j zWNy|fJzqqgO6yw;ncW+7p^d!?NrbVQ+y9+>Ki0uB#D1zlJSx(%1zQ4je*GEtp&bcr~1A%8$8Gg=9{Sa z{IH00ml$=hmR)?JCr4#Z8c=R#LSUjy;zbJ8pc|g-;oFfy5|2Mk(YC~@|tK8M(8cnx!Zu^xsF>$baE4S>z z?new=_!WUCjkTOrMW3m0d(O+XHkt6MAE8E^`Z{pZ z%~^x&L_LN$pj$t4{S>ff102hTT0T$`UoZ^%SsR9GMRqL#DMsS<)uG8^K#|nRVj&1& z)Q*)HDd4!-8qA(2%&RM7Lp|o@bSxn)nDyWtaMcuwff;)lj|hNw0rQWbiY1w$WVs|X z;AXsvUB}AkI-MmY!qo~}9ZnjJoP=vu`n~fG7^D_ki^uN4D zXecuX{(>U0hNfZKB+(L~GD6(?ckmXnrq7Xw&XGS%Vp> zoNg$U`sQ>F+L|BWXl2a+4qSSgXBRs{dqW$}4=kTV+y)e|ZmJQQaL-eA`oq07NwSiG zAJPQX#nbnBJ}$aV7;IA>Y5wgW6X&8Xp!r4ms3~9)~td;`kJB42WGRt zZ1=>zhH85itlE>EKo`(QTT{l61IP793R{X?{Z z`BiE`RK-jLzxZ3x$f`@W`wmO0sMFp!M1KM}0cWnTH#Ff}Z%vxfq|0raJv_>(pI*Bu z{_vi6_8XU*u~p9po2KQ?h8KpCrfM1Tc1mOtJk4YVlYE=xP5jnu%Z{U)6#}a`xyPPq z*sIenQl&T>eXZ)iJ|vyWb$D!;a!zO){hB?`_Y)PXJ32~VK+8s=wUw>?d;7?mbh`xc zmesXMW=Q9{pZP1^hymZ4>mc{nr5Tb#7#L2Tr2f-ID*-C#)_(6W<7)O*FND8gl+dMm z{$aW7JD~7`KV4h5W^&VV!5+T~e8J|YUmy(&`qQoxQ%BseyfepZpqNmt>5{`8%Ia0D0p{v0{{u1qg?6nl7a!+(w-iLoIyKfmhhpz-66zmMx&s@*|ES2$-0KWlXjS}X#%M@ z|Lv!cKW;BiS5Bdq7$UlIf>K%)0<(&z#1fUbl^dJdRt(<1L}xQD-zSRBhd*4rkDDcE zxAL8hZDSKGhpkoOexQmK^+;cDCVbIzm5cQuE{ayp=kFmPHm5`V=~C!wtey8X$SpB( zlb3XIt4lUGK&Un!2JF!afe4p|gN>maJx|`dm;h%QY*6KN>+(Ci9mYL)w6eWzpEWv{ z)6fjmZ|)w8kpZ&zCvr%eeysU;O$%a0x)0!QV0^Uu4v6D!^}UMQgAAi(1;ll|QJ|M! zzMn0HW)te(Hm!r${u2sSg19tVZ!h)jc#LrH@u_swEPYwW(Df#?Z@xk9-r?4-BbbGY zO%MglumbB5FJEh{5D{)psTNvnsISK^Bsi*5;e(v-ltqU$i+cR@eY4yaS~ zGs4rloP%ZiQgVNH$Jg^NQsR5XoV-2$6)@$f-jHOa?;SjkSFJE}wyVKAe=Up-!q;nC z#AMtiT~>l8VvpHJ4-@o`0JltBaKj*9RQGOstfN@sC56OJV99!$-4REAgc^zE8)J{*r> z*HVjKPgIdz2)R;jE+dlpl1UvSzhqN1#3Fv9d$~(aI56AFpv_iKn>kWcbco->PXg*U z=f_SK@AvGe+p#;8dfQV{M7xjV)SEYK*A+^F=LQyApHh^6bE18vpX4ycKyO*~1)|tH zwAQoRmRbY#*s$_AaPQ0OVKO?A6dI`Yq`Djygql!c#i;Xl>snED^{pBAHy;lsy(j&^ zovh`R`P`@O?cJ+f(PRzk8dqMc;^Mz^b3ho^=`~86fNDI5L@8XxijLHMM;<-Q&Dsf`%-|z=<#FPlJ-JdmF*~@u7 zLf2&oA4;WKEVSniXGA zg4qjPgxZuT{_8mmAjk2I9K41mano?&3wB;Ba};9vkGtGF;_{yDbk(5Wq{$U0TSV0% zuJ;bE#ZH^(JahCoh4b75Q=astoR=KScjzqpuJl&Bk=_=4*wri>)u@wLCTv7)6J{3r zRcv!Om4MG@Tzy#ORMQ>!^?n;2%LXxTiWlMC5lJ? zR$ml#<8QL8l!u`uLhoK^JshF`s#Qw+`QdmVmM7dLh?5_`C+u?ulnt*Lk$Hu;<=SL5ZSI~_chyc^^sWjjAqS}aZp{v4=?#D zW)`fedH$YXW%C&__enB+B4GTELtYraZnnEX&VYRZ>vUh0PQ-V(m2OU>VDsPmkEXNK zzAA6MRIIGKmj(v3;e67T9u%IncX17)5W4ZUx8B6n_Z!t6VXYmsJ@?Tox^S@%8ur;OEmyI$q-(9ax}Q3$mDy4Ob85(;YMav~1%EDx=CYqnTBUlUGOQ|4Jaguh5; zAss%;>iD#~q5YJIXgZF?;Ctid`NT$XnU z-DB>(Y6a1$&>-+j%i>l<_$TNQUAy-i)8DK;FRuLyF|SG$^Jh1leMI zSF?d{_5O+Ajs^ zTfAV)g$yy=n2;Y2WlCq?wZBUXqefQS$zs%P+HJQVtay!^GRO2{`iPo#-V8?Ard5cN zjcxXGN&&>+ni6J|j|#ph-g$)jM^jd&EW>FkMx(ir9K^PNG`?hXIScUn$tq(=W0Kgc z;y(^|GG$H*kzt?&C>1n{t91tZGV&dX4`NH+k6Kq(;d|PA*_4kdxE)qt7ws(>V+tg= z!7>bie%<&eSPcBy3Wv5kev$H4#!Dh*rUg!>X<4f#N`HAyu5ufgbv;HqR+4{IK?oqVYoyuDH*R9JzK~!dJy{-XVa`m-;}-H?ud_fmV^cqU>*)Iu z{==Cx|F<(qg&gLWslR@ZIy1XAwz%CW*Y{`kXt_xcN9F{%Xzd5f>YE z8@V3~fqK?!v6CY}71DV0_o3gfj$PsuBSRGLW(7P)qPH}|886pvbZ(bXDV#A@(!4Z*1NVX$pKoh@hb~uYi1o6nQ*E zUi`8G%9f`<-dc1VJz`)XC9uppGT9pW9+i$K=O)3qH~81BIMK;T@fcN=OU^ugr5=f+ zN1Uc1%fpiC&C?sQD>7Zf5ynJU;wIT%-L^jB-#ZwVEw?OJM32$9J8}hP_(m9RZg5s4 z+2!W>6pqK~>8q}?g*npg4W8d8s{T~L@^YICd};S_6ia}(>Y(}IzQ{wXDQ>*TXEMhu zky%FL+o)O|1<;gD2}khz33|%j3=w$($+4unXt-@K=lQxZb1}0`1IwSIcQwkRxe?(E zm7VLJ0auT`be3gzY6~p!CVp&|R9M?T+-Ffwh5B{vp2_}c{378Aj@?@HDBHh>{`s17 zcy=++wE$pfV%?-~_p4Jqrp&gmE;quJ(_h^E!SMxw#s7lr2~Whl@`-I7D=h6v;OE=9 zsUjS)-lha%4$BKX2fv32*h1Eq1x{yVv4)l!XG)Bf#!Hrbk2-dlyg025a55k>LF3Xx z0^0YZQzr9zJxTgOsf1m>sE1y!Rzq+STOgmYDh1DrXSwBJGRG5y!0s*>1G(MX6Mf7{Ye)5ZQ!?{7{O zzZS<1j#89u`G94vbjonH!Vf8Koz3{rNaPDoa2XWL%Uf9ucxgq|rua6W|E0LpIsLCBUw_9JiHSv@=8O0g9NW6bh&$ZAU zwylzQ%(L3t9D5|GewFSz2>6||b!>eamDZHl}rKT^jMKZ+s}H zksz0aW95BOR9OgrbfVYS)A}SU`UZB3n`|MjD!oK{z5mIj+J?&4B1?^2j2EtdfA71Y zyCSC0Dj)22eA>f$Ga6t)Z;&x?ZQ2RKS3tnxZj6Plt2qt@Ccf?iyQy2Zj?tanIlj?} zz*=?iRF9w$jyI~Gi1ie0k{D$-x!H7IbV@}> zN>dH}G1?+CQJE6SGfXs;VBhbH8+nmE!I61?rC$+X7CuFh4NotW0n?6%y&}+fi$;c+ zdAtcXgZ!isGrCMnmSZ>s4xz2-Z&{LOj%BG3Gus>@6|_q=*X0u`eCQ|^&mM1DcomNr zI+(ak-j{Q&ToGV8ylNq%{O4Z&-^Wq*IV%C`qf;3tNi7x{iuWgR;F$_g+~{6l7E+=7 zky1h)@;MDu;E*VM@nf1sI!p{wG=E7NgVYcPz3zpv+X?1`G(tLvMPq1NI6P+z^S|hI ziS#an<}LpPk1G!?6JZu|pn;#=r({298-02)gA3dQc#8ePzg#&< zibA8RrFTxAjr<1xHav~T$UCCEDtSlraOw4+F1&B1p!Fk*HWU}f8woC(Frqq*+W{yS zv-&+qaJCx0`x5HD+KBj2d?1o!II$c^tve5($%>R^W@25Qc(Zw3_e~&6%tk;IHQ`ZK zpGVu60K&HSZLX@@UYXQ+o`Q!tWsKDY?H$lT&09DM;8g{nO?M{Ydr4$~zhB4>l1Fx) z!`o%)@JeCkTyXYqezyw4jpg@^v!Zb^yO)wMk@E>-(O zb**iK27n*xKLH#|jC>@bbAlddfws;87zpbM{|&$!;eH382wtao2_bnX#ekJ#$qqm~ z=X}7N0K>m#W|UI+L40E7^ZXlT8=2Z+5I`vC2D0w6gOGYQ^h z8VSo&*T5eYcM8QCPO7V0+J1wb=AHMWTAnwg*S@E20-L)_CQTKECj8JwM`_3GkghZc zA?fW#Lj86Ch~&e&6jqOIS@l3F*RSV0>dmf(Bf`sXJ(-120KnOB8z6v6tWbyqk&tc% zM=~Rsl?5Q-ZRt*f13-;m9jQB>Z=cLmmkAyQ2oskxZ!0&dSub;%&(GW<<-vIXQ)eh% z-%>c*BE?vI_@i3_h!XhT69D5#aOh1zRoS;m8oJuUdJ9xombq9sC zre)lg8w%nJziOb=+W7ePKCfV_(_a!DXBXW(7Cz$n20ZEd2Be0;XuZbWQ zC*7SETfO9DfiMf)=F8??kv#|~sA~+XJv0kbT?f&I(F|Og<9H2Pu zaBmDTKJEBY^TG78OxGqA{YRymx=~-v)@e}Lx@O6}dO2?KCAd`A#RL$~bZw>YCB$SF zKw&EXtn2VB=B*c!teuYpG?_&101EuJj**FTS#W^$4WOBJ)Es{Twqa>!NI2IHi#1gC z9Ergb*v^V%98W3@uL9UY@ry`p{|UgQ0EcTOtjz8kHsKI*((M2s(cf6JirB(;XJflH z&}H6x05uw}1{@x(=OfV#6M)XJN zonxQY!XH130P_djiVT=toNSeZmJwlIEH7(>ZN}y+{dgSucRH%#rAT1jr5Gk>v-gH|~5Y z02td%0z0tG{z=jODFx~X@PW+ zmPnmKV4^Nh>{~h43o$hwA_@BgRHP|@$#>1OM@_aqyrt1-scjYnAdVEkU80`UEd{y} zA0P@Y0t^nA+6S(EIh%o3#-S_mBy`?07rC)?%>o!$5EH}05gb6HPrI&QCYlFQI%%8( z`)Q*9fSFVm2KcEg%9l*bY^jB3$5LkV(3zX7N1_W|^)7W4cLeIOMf}dz`8!DMr$WUN ze*j-hsydDB!>+HOH=G5nz}>SlK*iHdYvNsWx8GGyqAneYEhtq19g%|ykjP;z(T`26 zcE5wit7sFi`@O~vhXawg;21p8suo`U^9kpJl53HUYDr^y5%{x28kplSH8tSntoETa zpc=qs*F)%T%fdbSSyA=nYJhF{TdXrX-ta|ofXm<=zuuK~O11$~dEiAcY<6_0sx!KK z_fRtKEYz4v>Xe^5W>kIHOEM%GK=F?4Q$~Nfq4*1>n)B$-wA2Q`bX8-OQ+1P-`63hi ztgrc&zN3C)_Ghd4D{@;H3{sk%mWPalN`uAPdM2Nqq-|6s&%Rz$+wq^_eUzDo&h&tRvT!y z;DQn*0H*@SHZ7bNt8-YtsddjT(2c_;)PsaLu1&Fx*4|8%SlO=>gZ~Oq?eslNgT>s( zE|&c$ckGvq_nZYdM1%k+V1>#k66Mb17dRYU?2rxj`>1za=i&y_V_gm|u1j<#e{-lP zs?)aHfqEWVJJz3ha|CKkFQX8ZTxZI|Um?#(Z-_eTQ-lVd5Gav_BNp$R`&-4HWEgcqD&CYO>bWKD>OT}W18DTW{3{P{N zF|*lHr8Uu!#!DgrdKQKVlA;aBbW(*)dA9$NgoUv7uoir|g@Urqkp@x;zj1`J32^uL=n@ z)4X%s9Qk9T620t?O>y_6i6N(#e_|W^5g*ecEA)AJ7o<<|oNFW_o@Ue{WeTL*8XV&L zv>BvJzgn$HwG|130`F=CX}vMOL)4UZ|Ch@vN(zObeI3x?`1ofrGUdF`R8yBODeqM2 zB%_sATFk`YZ7h00R?na4csrfTx+(d^o5^ZsMwSmm2nkPa1I}tBEUs;56s4WWz2PA1 z&u7!eIE_sXwjcJ3-^)aZvCjjSSMeF&4y~Z-$9pmDswVH@ zx-wU?D00{W9n{&5QePz9)36$%{q2sX*0x74P5~c`@wR3pZQzaPm`>YDLinM5>TMRV ztKe69<)LfNMk#{tj>EkQ=TBpS#e0-pNJN*7WKK)Bso%$REA{L`&Yfs{>X^_8)-=1)UF2sS*ei4A_8=z;;Myu_ zx=>DJn&@H0Ndo~3i>(W_%WZ2N@&nyNYS-FV-PZZB2}le-KiB~B z5Bx~zXjM%;{1tWJiD(Wk!6LJVi&<*HKxrNRmtvMyYH84o87G?z*Tlu zL-LRAKrww8wCN(O&**4WC%*zUHtBq`9QQDjH8i#{ome{bZ7#7IA!YHeWa>fExmEo- zRe3w!GWFUUIm95xq=r&4h6Qa{mspn%&`}+=YV1tcxq#0IvL#>0z#X}qN$}RNmo=z` zfz*!2OJH8j%_u@bBRm+NdC*1@wz@`U=G>P|6l_kq1!%E^b1sk41imyRewNJmk+*In z)V!IwgYYv^2}Ccx-f05|n-p{TuYNc+nh0yhvG=pqu+3A_<|}`BnPWF3GlAseFA=ND znr`8p3RxsZ3e6SskDUZ&kQVDB@iYN7*oP#2IdTWi90-ayr4=S6VGjTHmqaWu0zi`y zIF!cuEg84@=s^V5O%G}nL;absb-Jk@;I+W0lQl7%(_cW}9bwRr(I)%ii_~09T`2eJ zWh0b6JJY)lcaLT7=UPNeY=r4k^br_Ez|(u-p5C20VT zCre?&ydXc)r9~-L)l5;bElIt!G4t~rKSV6fd5)G(xT=YkBuGo z&=Xbe-PEb6UWbls5M+Ct#MR|9ak-f#DnwT;Gbj9*inw7ZlHA+`FIXl@MTK!#3b9+% z2Hq%&G4?Df-qNI`H-&q-z9zz*csoUJaie#x|yLLO~zLM9Vuu(9( zEHy+R+k@59qbYT0-9}1r7X$N3N4ZI4fgy|m_xQcp{6IO5$DIRKiAq-$RHu9oLB$2k z;%0}v1ExhqkBaE@fg)};4+N*`LX|^13qjm-0QoiE|79Udhf3wRH4bd<2YJcU43Low z^FacY2Gx!-ZwylTX^W&ADK96a(_|$4WCV4iAq1b`*?H`=v+qAY`b0!FVa|FbN%=5Pya1JXB&<&iMl1c%`0&LSMtMBB^WR2QwL8C|e4D9g^3e%sW_;DJ+U&U+M}56 zh>Q@HB~;Dmwt|xnRn?6}D^;(zkp3vbJb9dsioF{(nIt>L=orcHe7?bw!8&l#VSWru zLJS6rSu-Zlmc|f~2z?){wTe4#q$J)6d(d#*lBE7@mOH0v$aADQpAjRatxJVPRCJ&y zIXH1D#KPJ(OgG}$)_0Wbl!GW2rc`$xx3cWS%}B`7)Tt8`x&l;sU>g+9n|Ynq1J(jX zCOdsF!OP!M4+LJ(CsNY$W-FgNFm#0Ep)#`ydNYZOFpKeQrNGspi2)@*yJs_5E3{zK z)`b!>2HpZG@_uk6&o~s*dDMH0dc!mx3UCOmcLTSuUtK+k4pE-{4eJ1~>OvnhZouQW zPV;o5eG0+>qnh$!laFkT)-m+h#*Ja{^C9i|bcWd2k1@g@6_69Ku zjxL*Wuu*CFldJkc$6_NR({k&Ri^y)C|DFG|H1;Dkv72wbtou$g254k%zI5GiI7S;S z9a^5|je_@Vxl`%SwFJPS%Q`1Y0$mlyEzIkz+mf=UyyKoSH(*PlS@);JO#N5)%L=gg%k_xW2;O2T2^1;E_tq`%z%j6 z02q5Ry;=#eN2Hh`$X1!rFyk3hG^qS?9Xnl!tjbK|$bb#QFfFk3@!BEc16dB` zRMk{P+y}B(*^>5#wpcu;-$SVo870NZU$yAA{1UGR9)44!Svf%9JTU*4wbTpNHog?o z62WJ2SzBv5{zv)Jm<1YQhM>?N7#%1?D>-#ZTZ%L!84&$P2D5VcMhDv4e9euwv{YVx z7I0Df^yEdE88s8y6KUDx@46NBW}<{=;@MC$+019^qpgGJ)$a_(Flk7FEgAf#706|e zyq)j{CZ8j6RU}Q=AoUQE=aKjf{_d+AG^E@Y+3nv4S14Lj*}f(Q*eqkf%ud64n7t&| zh)0vEXWODqrkD{Uh4soJubM4|Lfy=6Tdm*zRzTC5Rv*jbDv$Nkf8>o>1qpzKT4Sk< zf{y~l@MnKc+eFIfTJRxgD$;cf7ZnA2qsPzs2WhHEvKhl-N6_$JtG27rsD54?@RPZ& zswlLKt9vvJogM49H9@&84HPaMTp&v+KutbXelfZKh-deELzLoM27232a#`6Gdr_VJ zk>*VWu;vyh(Pb$YH`0VUs5!l?oM;I-VL=- zgU-!V)mftD^c@&E#@4l!V$F=v` z%ccEjbl|d;9+*IBl-e8}W6f+Gd-T4?RX@czEv2qkscqMfT9W=0ri_s7J}5rHo#>9U zi(boSqRw8Yj7&YEz>IoDAW=ya_2I@K5U=f{VI<#g^h(??OHac5>y~lE!eu=Zepc|X zU%`|xK5PG}sb0f?HRfELkp5OQr6KG4U%e^GHhp)rn5&#>*kvxcHP(fXuqTYXK7PE_ml~lj7~l1S9D-LjJl5_g>>;*$6IP!}bT-E4;W^tB zoh4qQe4haFiaHV3s+}vUxT|>>1;uK<8khLkE1?3$*{3ByQ+#G7Ju0- zl=zO@+=gmt854{}fUq?TZDmCgSp=;*X&tm5}eLjH?xBQZ4o?eq`gSJjW_pwR)oOJN9{vdQMvgl_LM5`eK^@ zDks7=bjl`(;}Gxhe+ARwFLU#MiiY|Ug@$DAkAVsAN;;9?yW$mpbK2ZYJBho1PX4v~ zzbcV6JyD5fCiDtMZ`jIn+Cx(@#p2J>!=#ga$a$INC6i7fb+`p<0lofKRFIour0>Ht zxx`i5A@uj*xLtkHw+Xp-!8Vo944bz0AnI(yx+5?C{ZWm{vhU~x7s}JqpK!ctghY~> zk$MW&y&W+~i{H4fN9hVI`Znl6K>snx5u!wVHtN&z1G8k=4Vd7=Ez;u zBzxubO_N1Z_(4eCZ&P04iSCE6-4nTX`>;+$4J(uY1h*p>o8|eI=SJv{a3gx7yl`Qi zYYPe^;YAOHZpp5$eO0T(#bWOHLq$DZh%`tJ z-ObQQcQbT%4jse0$8$XA`25fR`SiXY-s|EE*Rc1VwP*jYbmjymex~r zv!!5teY}^W_k%8{s@O`?Te=2@!PqgkwFe~KfUGwwD)v3Ln>gx_3i ztt($-8s3qEcK@J3j zE>Q8w#WF=pz~~{>8Qb%H-Cbb*pA#cTq_$FXK!r<@vhJI_+~ZqTf`);7j#>}gMDMoL z<;8F_v+$oK)jM9h2aS8pwm{@6_dxh&|3)ykjXO7vypIdkFxBN$$;yf?D0_UWount- zLl|pY!>}LyVXTHO$@?(d4THqBA@O+D8X6x_Djx-ZnsY6ObDfB`mmKcwK~(i{2`6*Q zM5#8p8w-Ye5T3OJfK|mcDFvT9>6zcNcUsySWOkx<(j#n6u(T>1@H|EbsT?U3bvj;q zvr<8Y;_2QLJPha==z$wnIf6GtJs#u6+}#Pv>UYu5^6=!Ggxelh2~Hl8o(E3e2=TUk z;3G~BYpXpWa`Zepp0I+y`8gO+a!hsmygW1y=34GcJe*%Vg7_UxBkUdHW2uH@Lmdjg zNZtTzivWbWXEN%V9Fqzt!Ye^)U$f8#mW8wq-M$DTT0y&1`@Wz`xtmS`r}0d|#?rCh zK1i)s-7~_T4rX99bj*%6;pra5^SQ-6bB#}P1p!!)Iw|L%46yS*hf;9ag!>+J5pxQ= z>9@ceiZX~JJQ;taSTS|XlRf!Xn67_+#-|*9chT`_ajDxGy=wehcpUlze*YWbh@4t} z%a)0RCa#}-pm8)4DVSuaFg(Nh9({JbTvh)5Pyvf~Mb8!~#IA>Zq63Q9d@})Ln z(8`3|1!@5u=M0Gi2S$}n(78V}WIzrEfMGAUbASt}9f3^n_cya-vhFcCsRv2YGLJMx zbU?ZHI&9CNT1NciFdaz*wt7Ft4wp2gKw1wSGuByO98~d^gIev57K)?k=5YkG z=Pl&0fM6NgArz~n4Hcz>1`BS_pZlv*;&vrV9cS5Zbi@0YfWZNNsX^CcPF7hD1_mpw zU?)7ZCEs`Sw}d<1UE`|E2o1&9K24J+$CiJb9a*fd2ziJScG8$Pc-pDym7bzZzvS_A zkL!?bR1BJ^Bu*Y}^8BH!NH%Y9QIEj*MEU9q@_-8I6_u9yuHcE_wB+rQaX^a85aGmY z@k4@2G9Xu^tNRpxeA9&2P-)q)Y|OAaP%Y@+s&nDpOD=E<%=HPoX z;9TPA9K&no`;$mWBl?W=iUY z)-k^4Styg0e8#=1^0@-{VxE(>9aUl{D$J*BDL2d%*hx~s9KbeFzJliYVyJ$?4l&cr zc&=0?M`#TU4>fdqg5r54!&5#PtM<%?xIk)lXiz?5$|^Cim7SNuPWAtDDD0nf|Bb9xDxOaS?d_;^+ndO-R-&nUs)?B<5*=pdM6fq8XJ7;z_@Zmc4```#XLEfk@w|G~+^YT~^ zm^^75m=~&h7^7H1sb!GzcvZxgmz?;d@}QVv<;^uk)+XV}{QUk@TuH8~A>9}1&riZ` z=78>{=T5$fWJe)u?|7{d6-fP2hrRj|ai;G4(fgd8VL+~I=sGGFN$hEppY01nJ5=u) zN*O4D!-CkUP86JeI;yE+C$J6TKob`1B)@|RP9yp#3F?!1E#Wc4aPL|vZE=jD*DaFh zU3WlwM6&Wue@zEl?k@e-dA$|WM*=kGXJ1Oq8=@{tJ?YLDXMK+$6yiYbXv zu&BvZNzxoETzQ<=z6O5?BYm+oaUu{>ibCm>kVI4<39-wu@{S-FEg|qa1f~H!EE3cv zKN4LQTlm~5c8o7vF7)y9TdR7C!gFhvdDgf6Q5BWsVc#0UyR;=q3IY#xi0C5M&@c|X zCJ5+`yt~E-p^oPR7Rx}*XfTK+W9dWR1{Yo?mJ|_{W%Y>UQ3)*mbY=X~6;pL?0uL;r z^Wq@Ga!19s*HW+JmU6~#Tm-2s%9cyltWKw@nFTmm$(KKoSZe4l<kjt$s?V~3ueoXCWPGuGpijR?F=+T;vj?aS9r@f));l&AwHC-P}_i^@(D!WG4 zhR`>iYht$D4;n^42?Ytf2Y@Stb!ammvWp*>SjzeFOaakSj4~Gkpv282AwU~6OsT1V zu5jY(G(OOpKgcS25Rm?3R+Ker#91q*r^a~@AJO!b!vQbcDqWyC`;G73<0e+R zMGIg}?fUyS1fw6Z23IkeiBL^P(>%OLX*01&dqGMfsXpUh6r@%B%pA-W1_qjPUL~|& zSI|tiO}wEZmELG9V${-iabvDOKNZ2<&o~=4sV8-JkdNIoQ#?<+K1ljGIr!_CoCuic zj^bcL>$pEC-q?ZJ>G=nvkKD~6aU{X~>w{vD%DbG@Y^S*2I$mz|LvM!rZ_gy6JGifB z5ObvMeR2Uc>z8oHmx~i=^`gS^2gGtl>-frQk}MzUzKLUA6RQ$!rYV_^)lRot!=38d zwCJRXGC4MjKWAs8yjhZ9!Y)ECUgdqKl;u_E%7}tL+~Y<#naUmvMvYLY7J6BeK`i*y z$mvEE`_AJ{@52G{f#D;3px#4w`W$Q-u7TXy!J--(pWe5VaG5#|eF1R{ zMpV`IS2|u=^iT^>2Jo3MHQZ0i$#%CK7=Ec8Tjar*Go8r0(ed1lV%8(VEO7VuEMC<8 zq3+q9D$L^}B+DxKl8OTM$fOTsZ4=U?h|MQfG$>8ss7mwSanBR!2g{GOiL#CIeU!(uNgqy&sMTz5$TiN8 zd}&{Ie6|UEhU2X2;nY(dhhlr%;{MfA2YH;CPcz#9dm{_~F!;?3lh7~?&Og~S*^f}o z3@PrIeS2vb_QEZS;I061ap%3!-egDbGlWKn(@JZ8oKjzbbrs^?ES|64ShWGf6EGGk zi2;r1k3|&8D7of1OuIWid03rzW3Z0vc->Qj{-s*gWZ-y6H}5(VUuwmG9N$GxqZd>% zXH-sDw=-&-rGlCT%@jw8=S$Gvw4T?-Xu~l6N5f1wU2>LG^$=>2JXER7DS`nyubBXoL+@Mq z1M^?3DCDilZlkh?z`kel-KfGq$`X;Lr?l$*^MZfY9KedI)1zi{zO$&e$ZY%H2v_)6 zOteU%Mysj64Eq1hrNUx*jJ#?A<`4a^SN+ej)-m4;B6dTD0HP86K>7PaNveDlnjK)B z%;-9c`|W4Hq8cd%WOkTSQyv38z?6ED+45}5W(c_)HPs7=wUsJq0kmBb0O@#_3+9#< zr0mF03}6qp2J|!?4}hZWctRu1Vv!oDmOBUYD+q-+O~e&faT z<%RY^G31#=Ccnh@A>kQ-&n11}%LPrW1oVx{Xs-t-Bp?-}vXCh?^pnYO1`sep`70Zd zl$A9=%-rpuFT|r*1dB@ysebx%AF1e+T5SR#-adq+Io#NI6$)ER&O+1x0_dtp*}4Nj zQNrv&fd2Tt*bMq93M&-Q`^co&d51ZA{{A!;n_{-jWMI*2a;q4+dD(b$pKt812HoK zczBahbaC3EKl?0F{C;>75Y#wn;}{EMV+^d@ZJ|s+u6e3e#~neJ<6gLztSjTp?6<4d zJhmuoqhD+jylenY9+p(D#kg)V+3rQWaFRPklM)G$GA0x9+9;vt$hW2R{;Qv_~5!M1v z)ek5NMza9E8V;u>XV$Mr4UpOCYZtjn_=TBJF zFw0Iz4KsA*>yI$IUx1%%9g_o1!8#F&!?4%S-3^2%okju!^n98kPam`-$j7RxrAxq& zd?)k0mK1Yltf9#70w-kY)b-G_54EjI_Jxn60ez;1j1{gi$ z^n(FCKvMV-fD`&_&H#q2EO`?{?bo{7?E#&tA%v4|f%nWN23PrecS;(SGXPfcxvrDz zX-L65$;@=(ZGZ>W1Smz4r2D;CaP)2Xyv-~Jefl3keSQ} zamfJ!5A)1w%?3`WC?KyEXZ&M;%_sl(TndeSKu3xc30JdOP_1fAtEjdon*{=20?<;4 zkSnVk${`f7@bT}=G9JP51hz?ycBfY}hY)1;f%0{M_0UWF?#q3M;HHd`7G*TF_k&3U z--&TEdmc2rxd^t(1+O5qsEJCuOpAA8T2qIVdwLS)+E02-=OSS90Y*rYtJP1E>$;=3 zRLcVt-JxEclI3{U=-P1NOdc#GEsW`+gh~a@&y^qu_^g;ml&{vL*N$9Y3iz~{eWGRt zro3dELM;KAjFr0B2W9nPG2*t z%#Q<&fctt(4?nzcY1N}*xR61O-w zLb9|ZJyaPz;W9_S(%;AMb%3?%OwJsjl;JsCyS&@L&=$@;+2qgMpLjDs#Nr&-2CoGW z&D8E`14@i83x+~|0x<|vCgA#E zB0K5>56lC1R^MOWtRQwa;aQsjrYN$s0Fk;Lx;3N{98_g;Nh#P_Jc+??Ouc~_U__{$ z+m9OntDBqaY=j?G7BF3rdXlcDN8uhOS+$&H;oT#)Da+^902e1OSPK&OC6O1rt_$>zlYV4v21JO*YJDcf}u=0$b@^cZOdNAB>c^fc07&G6Nl66a5;?sXhF)#aV0#p5W(@JE=!Px4?N>Kl!i77-d}?P1gd{vD}w!Y5pfe zUl3A!%tI!SxL3Lc2;#DG@ehiI$BxuU;W`ssQur{+IKUdW{?^wrsAOw8;&o)iN29t?I&~Lu>-0`N&1}LUhFR`#^ zNLV^`boT(kyrNT}HL;kQg+K%^Ru5~oYtCL_Ra4#UnO@>7Gg-ujfA@qh&>df+CbHN8 ztPPH6H{LXi@9@v2%9+fD2%H+5aScxD0}_i;4#D(u=4Zlusc}fx8jkxj)#Q#71)-Wv z*xL(u)NRiV2em*Ca6!b@g}cgU>x~i+s!SvP`Fq2jgdv07*>O_1o~@cckM*3dZ#LVDu89JTB%j3Q~q` zo?7JTn*VM=(2OpuP;TS(iQ||d37NV{W8sC0Qv!?Bjw3D)h-0ji~&8ZzRp)_NX8v^7tT#zZ5Ook!CW za;K5%A)7=O7+$Z&zU3gzs$l&2j5oL7#>t}4&-&5JbdHpt^wZ<;Jvt{CdoZ`%S6#`> zV_Z4sXUlrtM;+M~bO4m+`|F_8c5Ng%w}i^w&R9NgZ0Vk=n|_J`;t6p`D7ZbcAlxg| zuM`~c{_{nLbA8+yo2}sPO`zxYG#J@)>v&g36u*O}EPVnfcE+>S1-f(~H5~oF7CXtQ zQPG(<8{592{BksZ;501OFlbafBL_GKn)Y{BlP7zwN^6_iB(jJ?^&0J4sr@3!G9N?d zebrD?e#lyAydny>Z}-b-A&sns7rha*`|M|=gy+uRzVRzk_xZ4| zE{OI&;BcSC(SAW_I&8DFmf#M4mxHgW-SqD9qg!e!!@CL?%=YX11tX%Byzjp#$j+7X z%__73f>MeSZ2WT{X*%DM9%=ysifEOMLfp)OAi8BCxBS1B~5wvpYM<#FRL_+r-NOcoUmOb(=U24K8792 zX%9SCV*+7E5oHSAMQJG|(^W)4QwD8p_7bmn(%zILY>yGVsa}Is)Aw&564L7!6 z_A`?{wvQRh)SeDMJ|u)f4?jRcP_JV%hM~#4b^SCg>*`cY21^SgJ_Nfvxd-Ran1kvY ze{TP5mJhu)5ZDnW0G1JK=I#~WuO8KH5cJ%imThPzolfsbJDoV<#M^|S>QxI3*XNKz+F``8%~>#eHm->hXFbKzq37|h ziV(-m-17JLdE_+R>jAv>Jcqw&Sl+pz-vy{HlQ5E$mL3CUJS`l_MbjEi*I9I~l@7-E zH2Csaj4P<_Dh(g^cI9|IkK>UK4AWAlXGr~2 zVhE>r5bH|q3-6PW9*@H(NvkP~nPv2Xl2qmqcAr^qmMvSzLd0`4jrCbq4NQ!*Gy#q8 zJ-OHo!|yFHud6f5Nz?x{-;Gk+yA zUC*bdRt38I%16$C^-ZnlT{Ohy$ zC)D?w^uj+Bs2FXOUE0wU0~)}VsD|I^a5ql}QE#_ntbR?vc6<>d36{gkx%>U}W7}h0 z@EwQEAoVQk`5urn9e4(ZtHEUCDYdnTP}0CX;s`mVK?fBi!7`F;l$SbRj{rimaIip` z$Ut=Iw%49C^}*EVfESz?-O_>@oG(WQUGjiK9K4wGPH^2=Vu$2BHitmuOo5Z+!gNm7 zq6x|jOIx)k289x_SdZ#Sbg8}6CywFcCvO*L-&US%12b{OlCWuHM~fHRXL1L1ahGh% zc=^2hgDKjMEil1f#u*<8V*P@_FG-<^1!x6njSpB}&;&x23G~^uF@*DGUN*ZXQ;h;|d@A=04TWMhJlKHR6x{3@kf!;;TRl zBEBpyJ2;u*inuXk-(EM@u;Lt6F7)1>?c4Nojg)tSKF}#jTN_lc&sjClovJjiDFBDK zP9z5x<_MhYt6zYb`(dZ3c@c@bMlu(!Q@-)~$Fb#5&jJ61#B{Uk^H>6L<#m`)g0Ji& zHgo;{8rDDttldXpZHn9gugp4?>Z-w}s}zFxE9-`x9n%9lURqh4`&Z`9&T^iMmd~VCRu1@(dKfyg`4#&<9h| zb>jB1VeOFm)`CwzM>(=+2uM~60i&@1ma(F#1C@fVh=ngrGjGP*HTQTgxqDHW?<~cO zX!h=hIgSeuevRaPnCWoes3rJYSS||}m|r${qHXYUjdB^PgDDg+j%_4+zQMKjFg?k} zK1TlxCiyg6B3M5R4`DrmtF)v|MC)oQl*@tjDjH3$DP|lJb=qm;uKz)Y zn{6>^e^bXGj}xXSXwZk&n*ENjqnSWkkz84%JB12nTyclVqZmYtktDhCu7Pmz!)*J) zPL=rLaf>y7H=!JPh?R^i?n^F}!Mb7W679`)GQ1T7e;zX<*zxrVj<&~KYhoY~{@07E z!?(y;>7c{JDmc%SX&k`(D&aHASVM-O;6>5&f^uA1?CHQ|tm~e^^%L_J0@ct#>|?zI z^zhr8uVPd;w_tX!C@j-rE?MeRQe^e6-x$*0%zZWLVE|=$%=<~V1ae9h8kIt+}ANAl!<6>fd(;GU1L=h zbCM{%URWoy)>`?8(nGKq+CUPKQ<$wap9qt5Ivb{636C%H`rkq z_-`?yeb#uz$Tn%LydzC^5T7}7h1Tb@6 z?mFI^PDk|JVhfu+Koe9@6>zKJ|wU?*xNG`&0xKYaPZlG!lw@f2y;%s4w5 ze&p9mCN0FULGWE4e5qBAPh&Uqb%W{x#l46QlkTSDr@e6RLD)aa=(o(g(1l3w?JiAX z5_#Zrg-K|SI=RuwV-U1rzQ7aJqS~l+(sI&^2s)=q@ygG*zSuzNQHFiZnw4&ID@HX= zE6bb8yz$kIu!o!bk$gmg8(|y+z`z9Em4PW9cFqBRqlAf-Lq-1?(QQS%&#Ty&HHK)| z!dsOR@1NN79F6nN@4(P4@<&JET#cNeQK7BH0;EoYlE3Xlw?qko2ja$f_1@n?jK6Ri z;yfAgPvwuS_C|L&%pb3xzS|ig<`C?yKb}oP@{lj2yS?jcN$>zN?Gv!XgPJjI>dJPrL2q%T!0}@yE#3SC(=r8|G=41(<*RsKNa8N zrk-+O5YB0&Qp51QMSYr2h*yx0ox%5K3qk^NG<+OKaSsI7aF~ua&y}Jn+#fg48NWy` zO}F?8b*=DgW;rhnPv$vl&?YI_g%|6qPeaX&$p^w~3${|70^dM7AD5QqsKeS-3cHPQ zNGyMLE0FX4kB9C-LfN7NsJoFWrJUG}`Ru@60!=0Qy$Pr0Tc+@k0klFcLl3)T=n~tq z=Si@|6UuXk*=rad5<`gy^$S-TGTaF3exO;tjv$hjX?`tJC_4OHfA6&trn`xa3$C8+ zYIAADMxx|a4+vdpvIGZ{yRE4yp4>_9nU0SeDd}8EDfg@>eIJwkoBYDoMKrZAjnPFw z!wyg?gEG4%#ON>Md}XOkJXmG0=iWW#fsyh^2n{8N^;L7S}hYRuyoAa4uX^6IOdHMtS%xdu(0$d zEN<|oJT{ot_-HJshTzdYEBeuq$(^G@w)sdy^|Xs~?2bq4qz_8Swzq z6v2(Y`ec_np}Ib+X%lgG6y(fp#KN_3MY*bSHk?H1u-ETe^DBAI7J}N|hPjp1uEt*; zLcjCAS9>WJt7SX;ZF~RBKWl<=+hUdL0$AZf56b#jK}m16acF1Ojr7IHj5t}v07S5! zg%lb-Ex?I8+jVoPI9sc0ESX*5TV!$~2o{Mg4MWkvdn>P+wI35&4)zy+5MV%z<|A(S zSy@Ft!)F9Gw@}K_-X$BoQOSolJF;tnGqS{q0WaODP$ycxKR=-jpIo>7=vNU=7@l~J zcgH;aXO=)nU*~gV_~*<|*&kWU@=r`A0J9?@MJM+g$AKAe55CfLMBCw@m;xGa>{~B> zK?@MEu~{swun<2p=YVfa>kf~g6dXoO%ym3Cl(@>eM|4Y*f8fpt#}?L^;(Jm2AI!xQ z&63*Ud?HlS&zX`G{mcn*oaAgpJ#3R#{Z1wBL@HZgDJ%)c#?ErkH0eD834YPYL^t1KyD&aLX&N?=)|H`$X1tG!^?vl-dx=O=ilO)Yys!TYLHgI#DcFNLhsEhVs~}PrZ%1EdH?y?@I)?XX~4dRHjBj z-msfCBY6QrIyMBzreP2lR56+=THX-MzZNE7BK#WTr0E^Dq-Bh6oa=^ie)0k*PdZiXb#&Le0)9f!9S;p+BZ}Z|bw%z6>ZT_Kn4g3+J`qsJsIKMN4 zydcRa@Uq%N>sgq!v1^BKSt9J!pYL4D6rjL_%8ffdHI-u#X6lX=JPDG0!6xCC~B%cV&GNadXiJy5U@1G8+)1Z-UZ;J#G)Ta=y>f zDRvP??zr*2PrlCzmtdEz=A`ZYL~VkUL|lnvATyvM;AbIbbJ|KmC+ivClWRMZP)rW; z*me%a_SJ|B?_!W^E#P_0=4kv&3&87!6Qy%B!oC*J1g!4Dy*%EvqL`Y5?`(Y&oUA>A zFWZ(Vt~GSAIw7@<-Q=7owPPK}=Q=03E4n2;8=e764!H(ClLBXL9CB8nn5Rdv_l-PH zxh^-4XScQyO*tvGEeS2lJrm3!fWqUqtf?2?_Er6FwSJth0d`Um*jx1uAMw!=-TP=0 z!kpEIb4J1~rL^~+$1I0foh%s_1rd72aH4sUp=F%Jrbdx?xJF&9dO$60k2uR}xUpjV zj>^XYL<{cnrNuebhWj1uJ2_NTQC@DzPe91W`Q>`TE-9Y)S(?H1mjvS-v?zKo~=KSXi5%Y>C-ihIV!TD-?I-{sWtnXTKktAn6cA4s|H`MuNQ+&sZA85c%OZ- zUu$o$rAea~IOy{2;y5QJzt>cv&T%5=WIg+>g0o+w+ft){hR^9~wO_=wfjvg$T>aTp_~NuJc2I*pr%SzTy>_Q zX0)`lToFt*Y6sIY`ZHY|JxAWp zeqX4NpoyO9vZ9Dfj~=^~G@G{H2*U_3f0>yQ1@@*{St$v&?%K|bxOQsT9mz~d>>BU# z-EZoS{_-N1yri&eTz>uX!gQm?Uvzhki5dZIu(VKXaMGBxx<;xqU3BTrK4l>G4#B8( zRV1enQ_uduLWIEAaoc)t!L>S|H`g-wWts{?q~TBIVtCHi2kJ{$EMs(aIU%9|3Gx~m zxW^3+5|x?T(omht#+@Fo%oeA=PzoqRC_rW>Dh?!1n|jIzBw(?H+Y>j|#p27WNjKay z!b}q_1ne7#zNkVKLniUL`c#! zw=8S|O+cx3dD$yOc^0ekPfEWSStz}Uv$nI8qq8$UnjTt`UKUJs`kJd;9#w5%PF`eb zvYsc+riWX{``$*Y!OV~8PqgXyAt$xU6@vVU0oLU%>_-+!OML9j*Yp|5qdGrmy>7*? zw*w-C)uTRM`EJX2v!q^Gv5}+3nAwMoUSU~P;KF(zLMG08y{}_k_<5f`Wf!KtMbGVH zBgn)77GaTZ_ut7v;*7-xZ=smC=*5jdkmeYA{FA4^X9O&=dbV1r3h2{{c@3U8!hi-hL1$f=u4<3e} zeq`>4@39x47#)l9&6;#DmvNv(;jr6FL2?=UhgLuF-phS#G?RM&Y`eA=TZ>^DKW~U2 z7VdRT9Q5QS4Sf|BC3qn7!q+o0^0Rz`411JBU83@%HWKy}=_x}ihM;;V(BuJgH9vCY z7DpSRAGcvB_cO5Ic=ei5@K1abu%wHe36Vr7#Q0blXjCl;`#b~GIHC_QXTGuC04o)+ zkQja=&Bs>Qfsmnvse~wz$ajWC;Nw?WzbgjMu}B8RJs`u~EtOl6o$se+MGX5y~>SV?Ijcw%WKNZ5)C%gWvzIU;v--`=$C zxF*lt<@^t0hBih-WrOn3)GhE0*1nK_k}uDRKSL5cPQ|Jf;{pFLhLRzOO0~q$7xS2? zy0-PClfe(12G!x|(!|aCeuH6h1W~cl_r}DhdOQyX^)`0T z^V#?SQ+j&nHeeTcs0q;kO{~h}6S4>Qjj&s`HP!hflv0{ED-idixt@wPzk#JMd)MI9 z&jON5@%AS&o59wx4im#Qm1`k3<7a$plqin|he&oTrYuw-UTcr@u{M(l1&p9wT-Gx< zoI7rfnXDc)eGsbG-Tv%fDx?IO_u|CMae78|!en!456b*^14@&W1F9nr4~{C0b@YmS zc0UIZpuOy7ObJp*4_SI+rFlLmqYX*Su}q~OIUhWY5%}>T`>~CVZqziJpK!jQn1x75 zDQA0Rqg&(n?FPOm1xell{;xh3k-S?2#fnbQ9CzfJ_Y|?8QB6u*V3eyf^rVRKB9xsy z1XH*qBxDftBF0j`t2!l-XI~+PHR>|(hj-UfDEJ2VK~T=^V*APdA#I`-e2JaXo-d>P zST}%Wo)Z5$2?O;w!`}M@y$jtchTK{q7OX1eY^Yh-24;^&2kP*1=>x-wrKQgm#EoKY zeD8TK((}(*(42pl6Xs9(@CnDkS|RQs9rp81OAHg8GYQmKI$_0XQB8~og6VOlNecGs z#Jb!|fz{V#3pbjjWj(Ad>GB(iZ#@dn6&PD9`0*uqP$$Vh7nsj8@E#j9Y0S&Ir9kr| zopr4|eJRvx2W>vrP5Cl?ThdyOMB#-H+ZVokk;!l8y5+CJh^6%#lzZ?t1Jz(NT;E2b z`x+9|&c`;>+(fH!uD5AIVK=AGpJBlHnH&H!7L;%S=Fg0lbg5Gu?CsTesv~x+wZ(qE zg9evp90z?&q|zLP#8?P8QQkZ?j)x9L1bdRrSsZb#6Ll(Zp|V=a zZ#@`%Te6a)P+@TxmpZBtF^FvtB zgaA*JrFIuOVr(GK57ed}j=;pPQQwFW<^>x%e2%88Ck~a{ioOOt$=T$JA;rQ#8i1De z%$9z~x(~?OaAK?vwtFqH6+R_K$w(PXrQwa!T18tJomtX`$U-WubuybCDEuNS=Fec+ zTd}e_HPg7Rlb~c+j7oCLC0MT$b9vcv^Sk@%LHPsV|W zp{%oQ$#-(8jFkKPTpa^0R*8fPQN@AWq1Y=LzV*klmJwl-X;Oy?*>35{*4GoJ_sg|z z1m%A&r2hQQ{zRw*X(v}mQl$0i?&51BtX5xLI?>rXWwC8(i(;z=(izA#E|BGJ%nrWb zFgj`>rh1$28}}!hl@A9o)UY~Lsb0_Hg^{L9gMEIL(ZPPn>x?Y)a``f!q;M+J*RM95HpCK=?{t`vNXHEexHhy7uv44O ziP!plv18)R%3psu_(jIm0cfy^FcB3|g9pEuo51YEe^5__beI9|Df6sayYs@+|8f~1 z&`5{mOG(u|FZ|CUekBa@>t-a#G@h­`>HfBlkwUhwl^HX)LsN;g9@_P<_&Y*+(; z>K?Y76z>Lx&Htl}Uyt$%8+k{MSweIp}EnL{Y%t;eJ|euIT--UscLopb?9G8tb0Ta z-0>xnfxk%A9il0^wpD&Q5^S2Lqo%Dsf@8elkBgA1mbT-AIg4v zEt6;|yzxWdO3 zK7LDxD}4MGjw^gz;p4Z2xWdP8;kd%b6+V7Th%0>j7LF@?T;b!lgt)@TZ{fJY#}z() zONc9c{1%QYd|ctj7LF@?T;b!lgt)@TZ{fJY#}z()ONhVl z5nVs#eC-}AuuJ(c;+sUhaGgmu?{@y@!_2#^K zbN+fmT(t~WEyGpI@W<}btKQPDuEJHH;cDmX)y~aWxUu9O$9G$*dqHvZW& zy6PwXGa6ST$g2_L)d=!x1o?kad+B_7YmF21YuXxzf3KCM1+cySnfzzg$wyVq8y7uMi<@tTUz*jz)tM;S|GBV{j?cQSLc{YA|;v)Z-s+30H zyKR-KyQ&G{KU+S0svSY}t?Hwx`3}I7d>8PhLzDv++9BH>M^!CWfNSsk#kS|=?m1wN zTMqB$%R4#7q;%Uk9&HhDn6POfZ)wC6baR<}%DVSwX+rPnzy#&936}^vP5OHxzs4Ze zgxqH=C4j-%;_dz^!0I!W;tc7{{K?Qr@Wv@%+`E3f#8vAYKI{nCb)Mo*m&Yyg?>8Q|ba73)xveQD@K&E? zXet-VnUaXI%K~))llGk7_zjf)^`_woT9K@jR?uE(=;H_*gV6?fC)!W*)%VcSHkDlcXxpO7>Sb zm4t;VQz@XU!dN#RTvxg#h+82@wy+B%W9d8&3x=z^jJZnMP z>&^o%*gd=9d2WmC@Tp&EgkSD~>T$MwP{ir~tHym$kq&wxMeh!KMe#Hb9Md#|O({=% z{em$moM!fSt=#6xLIC$m`4+%o)YEN_D1rN;xfk-R>ypu3L__}9>$X5c$y2lQf%SeKU>KZx+KV*1haB~INY;BID$cg5A(p98v_Gq;&hrj8j^VcZwrj|^RqaJNVC;!lH|vh)JA(t6c%HeO z0QfRf0NDdyEr@_F(EZo4o}vP|IUV8%ohNTWR`k3yU{-9?h|8tn+yy`qu)}cOepY>% z##O!QG+Y!9J_meH`MW&^;d=>wlpe=U`+d(t%AkwPEwWsb_9wcRw11_y9BL8_?8WK( zXH{9hnb|0Fioa-G1_Dq$Fzx5iLhg7!f<=>8>taonlGUXzK(6)zo?ErWTYWyPZuN`; za6X+!W*O2$S_^R-GJWbyJRop+(xdI%`FEC$$j|tCBF=ga$czYo&862pJDRX_+YQim z6ZuF2)E{K@Fk!m-umUj8JO(^b-Ju(Xtb721zs)<=o=xrop0)E%i;UVQJ_#*Ee^(+1 zsKnTu9+^LL!bu7psQudewZ}hLgU2naHl3yb`_``>mI;BsT8tSt;F(XL(CA+Wel;3E zTQa+?0vG=koWC-fN@yk)_zq7!H1>af=Uw`e+21Anb-s=VU97~;%lUuK3tdA|>>By& zy1zfXw*!>=meJt0zd-&gP{1Wg(Ru&)@2{s{zKuWBjlHz^*MYx3h&|Q5{`Y^sT6DB- z2CB?BqRtNNU#R-)4A3yuVEp~xU*}_$g;e-Jkr71y2*;n#i$COs``2}Uf8d6^OLvfC zWBv6?`uhwORptrlf0lz73MTKrcI_J5P58D8X>&(NbTaTx(gA`&)cNo6{ dict: + r""" + Initialize the testing environment + """ + init = { + "artifact_path": "tests/test_data/model_artifacts/", + "num_threads": 1, + "test_imgs": [ + "tests/test_data/samples/ADS.2007.page_123.png", + ], + "info1": { + "onnx_file": os.path.join( + "tests/test_data/model_artifacts/", lp.MODEL_CHECKPOINT_FN + ), + "intra_op_num_threads": 2, + "providers": ["CPUExecutionProvider"], + "use_cpu_only": True, + "image_size": 640, + "threshold": 0.6, + }, + "info2": { + "onnx_file": os.path.join( + "tests/test_data/model_artifacts/", lp.MODEL_CHECKPOINT_FN + ), + "intra_op_num_threads": 1, + "providers": ["CPUExecutionProvider"], + "use_cpu_only": True, + "image_size": 640, + "threshold": 0.6, + }, + "pred_bboxes": 9, + } + return init + + +def test_layoutpredictor(init: dict): + r""" + Unit test for the LayoutPredictor + """ + # Initialize LayoutPredictor with envvars + os.environ["USE_CPU_ONLY"] = "" + os.environ["OMP_NUM_THREADS"] = "2" + lpredictor = LayoutPredictor(init["artifact_path"]) + assert init["info1"] == lpredictor.info() + + # Initialize LayoutPredictor with optional parameters + lpredictor = LayoutPredictor( + init["artifact_path"], num_threads=init["num_threads"], use_cpu_only=True + ) + assert init["info2"] == lpredictor.info() + + # Unsupported input image + is_exception = False + try: + for pred in lpredictor.predict("wrong"): + pass + except TypeError: + is_exception = True + assert is_exception + + # Predict on the test image + for img_fn in init["test_imgs"]: + with Image.open(img_fn) as img: + # Load images as PIL objects + for i, pred in enumerate(lpredictor.predict(img)): + print("PIL pred: {}".format(pred)) + assert i + 1 == init["pred_bboxes"] + + # Load images as numpy arrays + np_arr = np.asarray(img) + for i, pred in enumerate(lpredictor.predict(np_arr)): + print("numpy pred: {}".format(pred)) + assert i + 1 == init["pred_bboxes"] diff --git a/tests/test_tf_predictor.py b/tests/test_tf_predictor.py new file mode 100644 index 0000000..b033f56 --- /dev/null +++ b/tests/test_tf_predictor.py @@ -0,0 +1,627 @@ +# +# Copyright IBM Corp. 2024 - 2024 +# SPDX-License-Identifier: MIT +# +import glob +import json +import os +from pathlib import Path + +import cv2 +from PIL import Image, ImageDraw + +import docling_ibm_models.tableformer.data_management.tf_predictor as tf_predictor +from docling_ibm_models.tableformer.data_management.tf_predictor import \ + TFPredictor + +""" +- Implements TF predictor to accept the input format from IOCR, e.g. + "./tests/test_data/samples/tf_table_example_0.json" (trivial table crop) +- Shape the output format like GTE would: e.g. + "tests/test_data/samples/tf_gte_output_2.json" (Note: full form image) +""" + +docling_api_data = { + "table_jsons": [ + "./tests/test_data/samples/ADS.2007.page_123.png_iocr.parse_format.json", + "./tests/test_data/samples/PHM.2013.page_30.png_iocr.parse_format.json", + ], + "png_images": [ + "./tests/test_data/samples/ADS.2007.page_123.png", + "./tests/test_data/samples/PHM.2013.page_30.png", + ], + "table_bboxes": [ + [[178, 748, 1061, 976], [177, 1163, 1062, 1329]], + [[100, 186, 1135, 525]], + ], +} + +test_config = { + "dataset": { + "type": "TF_prepared", + "name": "TF", + "raw_data_dir": "./tests/test_data/model_artifacts/", + "load_cells": True, + "bbox_format": "5plet", + "resized_image": 448, + "keep_AR": False, + "up_scaling_enabled": True, + "down_scaling_enabled": True, + "padding_mode": "null", + "padding_color": [0, 0, 0], + "image_normalization": { + "state": True, + "mean": [0.94247851, 0.94254675, 0.94292611], + "std": [0.17910956, 0.17940403, 0.17931663], + }, + "color_jitter": True, + "rand_crop": True, + "rand_pad": True, + "image_grayscale": False, + }, + "model": { + "type": "TableModel04_rs", + "name": "14_128_256_4_true", + "save_dir": "./tests/test_data/model_artifacts/", + "backbone": "resnet18", + "enc_image_size": 28, + "tag_embed_dim": 16, + "hidden_dim": 512, + "tag_decoder_dim": 512, + "bbox_embed_dim": 256, + "tag_attention_dim": 256, + "bbox_attention_dim": 512, + "enc_layers": 4, # 6 + "dec_layers": 2, # 6 + "nheads": 8, + "dropout": 0.1, + "bbox_classes": 2, + }, + "train": { + "save_periodicity": 1, + "disable_cuda": False, + "epochs": 23, + "batch_size": 50, + "clip_gradient": 0.1, + "clip_max_norm": 0.1, + "bbox": True, + "validation": False, + }, + "predict": { + "max_steps": 1024, + "beam_size": 5, + "bbox": True, + "predict_dir": "./tests/test_data/samples", + "pdf_cell_iou_thres": 0.05, + "padding": False, + "padding_size": 50, + "disable_post_process": False, + "profiling": False, + "device_mode": "auto", + }, + "dataset_wordmap": { + "word_map_tag": { + "": 0, + "": 1, + "": 2, + "": 3, + "ecel": 4, + "fcel": 5, + "lcel": 6, + "ucel": 7, + "xcel": 8, + "nl": 9, + "ched": 10, + "rhed": 11, + "srow": 12, + }, + "word_map_cell": { + " ": 13, + "!": 179, + '"': 126, + "#": 101, + "$": 119, + "%": 18, + "&": 114, + "'": 108, + "(": 29, + ")": 32, + "*": 26, + "+": 97, + ",": 71, + "-": 63, + ".": 34, + "/": 66, + "0": 33, + "1": 36, + "2": 43, + "3": 41, + "4": 45, + "5": 17, + "6": 37, + "7": 35, + "8": 40, + "9": 16, + ":": 88, + ";": 92, + "<": 73, + "": 9, + "": 23, + "": 219, + "": 233, + "": 94, + "": 77, + "": 151, + "": 1, + "": 280, + "": 21, + "": 218, + "": 0, + "": 279, + "": 232, + "": 93, + "": 75, + "": 150, + "": 278, + "=": 99, + ">": 39, + "?": 96, + "@": 125, + "A": 27, + "B": 86, + "C": 19, + "D": 57, + "E": 64, + "F": 47, + "G": 44, + "H": 10, + "I": 20, + "J": 80, + "K": 81, + "L": 52, + "M": 46, + "N": 69, + "O": 65, + "P": 62, + "Q": 59, + "R": 60, + "S": 58, + "T": 48, + "U": 55, + "V": 2, + "W": 83, + "X": 104, + "Y": 89, + "Z": 113, + "[": 70, + "\\": 165, + "]": 72, + "^": 132, + "_": 84, + "`": 196, + "a": 3, + "b": 6, + "c": 54, + "d": 12, + "e": 8, + "f": 50, + "g": 28, + "h": 56, + "i": 5, + "j": 82, + "k": 95, + "l": 7, + "m": 30, + "n": 31, + "o": 15, + "p": 22, + "q": 67, + "r": 4, + "s": 51, + "t": 14, + "u": 25, + "v": 24, + "w": 53, + "x": 61, + "y": 49, + "z": 11, + "{": 158, + "|": 139, + "}": 159, + "~": 147, + "\u00a2": 203, + "\u00a3": 162, + "\u00a4": 220, + "\u00a5": 176, + "\u00a7": 142, + "\u00a9": 268, + "\u00ab": 239, + "\u00ad": 275, + "\u00ae": 130, + "\u00b0": 100, + "\u00b1": 79, + "\u00b6": 171, + "\u00b7": 137, + "\u00bb": 240, + "\u00d7": 118, + "\u00d8": 192, + "\u00df": 197, + "\u00e6": 261, + "\u00f7": 225, + "\u00f8": 163, + "\u0131": 242, + "\u0142": 267, + "\u01c2": 211, + "\u025b": 223, + "\u02b9": 248, + "\u02c2": 195, + "\u02c3": 208, + "\u02c6": 253, + "\u0300": 209, + "\u0301": 131, + "\u0302": 138, + "\u0303": 156, + "\u0304": 152, + "\u0306": 222, + "\u0307": 247, + "\u0308": 103, + "\u030a": 102, + "\u030c": 254, + "\u0327": 155, + "\u0328": 269, + "\u0338": 170, + "\u0391": 173, + "\u0392": 169, + "\u0393": 180, + "\u0394": 85, + "\u0398": 243, + "\u0399": 271, + "\u039b": 272, + "\u03a0": 213, + "\u03a3": 185, + "\u03a6": 148, + "\u03a7": 212, + "\u03a8": 141, + "\u03a9": 161, + "\u03b1": 90, + "\u03b2": 107, + "\u03b3": 110, + "\u03b4": 153, + "\u03b5": 166, + "\u03b6": 178, + "\u03b7": 146, + "\u03b8": 186, + "\u03b9": 229, + "\u03ba": 164, + "\u03bb": 91, + "\u03bc": 78, + "\u03bd": 230, + "\u03be": 244, + "\u03c0": 127, + "\u03c1": 149, + "\u03c3": 116, + "\u03c4": 198, + "\u03c5": 189, + "\u03c6": 140, + "\u03c7": 124, + "\u03c8": 216, + "\u03c9": 167, + "\u0410": 273, + "\u0421": 194, + "\u115f": 217, + "\u200b": 265, + "\u2010": 117, + "\u2012": 135, + "\u2013": 42, + "\u2014": 106, + "\u2015": 228, + "\u2016": 259, + "\u2018": 123, + "\u2019": 121, + "\u201c": 87, + "\u201d": 115, + "\u201e": 245, + "\u2020": 109, + "\u2021": 129, + "\u2022": 128, + "\u2028": 190, + "\u2030": 154, + "\u2032": 68, + "\u203b": 224, + "\u2044": 188, + "\u204e": 199, + "\u2061": 200, + "\u20ac": 184, + "\u2190": 202, + "\u2191": 112, + "\u2192": 120, + "\u2193": 111, + "\u2194": 183, + "\u21d1": 266, + "\u21d2": 264, + "\u21d3": 255, + "\u2205": 215, + "\u2206": 175, + "\u2208": 262, + "\u2211": 160, + "\u2212": 76, + "\u2216": 206, + "\u2217": 105, + "\u2218": 246, + "\u2219": 236, + "\u221a": 187, + "\u221e": 207, + "\u2223": 260, + "\u2225": 193, + "\u2227": 182, + "\u2229": 256, + "\u222b": 258, + "\u223c": 98, + "\u2248": 210, + "\u2264": 38, + "\u2265": 74, + "\u2266": 214, + "\u2267": 181, + "\u2295": 263, + "\u22c5": 174, + "\u22c6": 191, + "\u22ee": 277, + "\u22ef": 270, + "\u2500": 205, + "\u2551": 231, + "\u25a0": 250, + "\u25a1": 177, + "\u25aa": 145, + "\u25b2": 136, + "\u25b3": 143, + "\u25bc": 251, + "\u25c6": 226, + "\u25ca": 235, + "\u25cb": 227, + "\u25cf": 172, + "\u25e6": 274, + "\u2605": 204, + "\u2606": 144, + "\u2640": 133, + "\u2642": 134, + "\u2663": 252, + "\u2666": 157, + "\u266f": 221, + "\u2713": 122, + "\u2714": 249, + "\u2717": 201, + "\u2794": 168, + "\u27a2": 276, + "\u2a7d": 234, + "\u2a7e": 241, + "\u3008": 237, + "\u3009": 238, + "\ufeff": 257, + }, + }, +} + +# ================================================================================================== +configs = [test_config] + + +def combine_checkpoint(save_dir): + r""" + Check if the checkpoint file is present as one part or 2 splits. + Combine parts into one file if needed + + Parameters + ---------- + save_dir : string + The directory to check for checkpoint files or splits of it + + Returns + ------- + int + 0: The full checkpoint file already exists, no combine was needed + 1: The splits were found, a combine has been done + -1: No full checkpoint and no splits exist. Error + """ + # Check if the full file already exists + full_file_pattern = os.path.join(save_dir, "*.check") + candidate = glob.glob(full_file_pattern) + if len(candidate) == 1: + print( + "combine_checkpoint: The whole checkpoint file was found: {}".format( + candidate[0] + ) + ) + return 0 + + # Check for splits + splits_pattern = os.path.join(save_dir, "*.check.a[a-z]") + splits = glob.glob(splits_pattern) + splits.sort() + if splits is None or len(splits) == 0: + print( + "combine_checkpoint: Both the full checkpoint and the splits are missing. Error" + ) + return -1 + + # Combine splits + full_fn = splits[0].rpartition(".check")[0] + ".check" + with open(full_fn, "wb") as f_out: + for split_fn in splits: + with open(split_fn, "rb") as f_split: + print("combine_checkpoint: read split: {}".format(split_fn)) + f_out.write(f_split.read()) + + print("combine_checkpoint: combine splits as: {}".format(full_fn)) + return 1 + + +def test_tf_predictor(): + r""" + Test the TFPredictor + """ + viz = True + + # Load the docling_api_data + iocr_pages = [] + for table_json_fn, png_image_fn, table_bboxes_b in zip( + docling_api_data["table_jsons"], + docling_api_data["png_images"], + docling_api_data["table_bboxes"], + ): + with open(table_json_fn, "r") as fp: + iocr_page_raw = json.load(fp) + iocr_page = iocr_page_raw["pages"][0] + iocr_page["image"] = cv2.imread(png_image_fn) + # page_image = cv2.imread(png_image_fn) + iocr_page["png_image_fn"] = png_image_fn + iocr_page["table_bboxes"] = table_bboxes_b + iocr_pages.append(iocr_page) + + # Loop over the test configs + for test_config in configs: + # Check if the checkpoint file should be combined + assert ( + combine_checkpoint(test_config["model"]["save_dir"]) >= 0 + ), "Model checkpoint is missing" + + # Loop over the iocr_pages + predictor = TFPredictor(test_config) + for iocr_page in iocr_pages: + # Prepare "Predict" parameters + # iw = iocr_page["width"] + # ih = iocr_page["height"] + # table_bboxes = [[0, 0, iw, ih]] # just one table per page in our examples + table_bboxes = iocr_page["table_bboxes"] + + # for t, table_bbox in enumerate(table_bboxes): + print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") + png_img_bfn = os.path.basename(iocr_page["png_image_fn"]) + print("Predicting image: {}".format(png_img_bfn)) + + # Run prediction, post-processing, and cell matching + # PARAMETERS: + # iocr_page - json received from iocr, augmented with iocr_page["image"] + # table_bboxes - list of detected bboxes on page: [[x1, y1, x2, y2], [...]...] + # do_matching - Boolean, when True - will match with text cells provided, + # when False - returns original cell prediction BBOXes in the same format + # OUTPUT: + # List of dicts per table: [{"tf_responses":[...], "predict_details": {}}] + + multi_tf_output = predictor.multi_table_predict( + iocr_page, table_bboxes, False + ) + + # Test output for validity, create visualizations... + for t, tf_output in enumerate(multi_tf_output): + tf_responses = tf_output["tf_responses"] + predict_details = tf_output["predict_details"] + assert tf_responses is not None, "Empty prediction response" + assert isinstance( + tf_responses, list + ), " Wrong response type. It should be a list" + + img = Image.open(iocr_page["png_image_fn"]) + img1 = ImageDraw.Draw(img) + + xt0 = table_bboxes[t][0] + yt0 = table_bboxes[t][1] + xt1 = table_bboxes[t][2] + yt1 = table_bboxes[t][3] + img1.rectangle(((xt0, yt0), (xt1, yt1)), outline="pink", width=5) + + if viz: + # Visualize original OCR words: + for iocr_word in iocr_page["tokens"]: + xi0 = iocr_word["bbox"]["l"] + yi0 = iocr_word["bbox"]["t"] + xi1 = iocr_word["bbox"]["r"] + yi1 = iocr_word["bbox"]["b"] + img1.rectangle(((xi0, yi0), (xi1, yi1)), outline="gray") + # Visualize original docling_ibm_models.tableformer predictions: + for predicted_bbox in predict_details["prediction_bboxes_page"]: + xp0 = predicted_bbox[0] - 2 + yp0 = predicted_bbox[1] - 2 + xp1 = predicted_bbox[2] + 2 + yp1 = predicted_bbox[3] + 2 + img1.rectangle(((xp0, yp0), (xp1, yp1)), outline="green") + + # Check the structure of the list items + for i, response in enumerate(tf_responses): + assert ( + "bbox" in response + ), "bbox field is missing from response: " + str(i) + assert ( + "text_cell_bboxes" in response + ), "text_cell_bboxes is missing: " + str(i) + assert ( + "row_span" in response + ), "row_span is missing from resp: " + str(i) + assert ( + "col_span" in response + ), "col_span is missing from response: " + str(i) + # print("*********** column_header: {}".format(response["column_header"])) + if viz: + # Visualization: + for text_cell in response["text_cell_bboxes"]: + xc0 = text_cell["l"] + yc0 = text_cell["b"] + xc1 = text_cell["r"] + yc1 = text_cell["t"] + img1.rectangle(((xc0, yc0), (xc1, yc1)), outline="red") + + x0 = response["bbox"]["l"] - 6 + y0 = response["bbox"]["t"] - 6 + x1 = response["bbox"]["r"] + 6 + y1 = response["bbox"]["b"] + 6 + + if response["column_header"]: + img1.rectangle( + ((x0, y0), (x1, y1)), outline="blue", width=5 + ) + elif response["row_header"]: + img1.rectangle( + ((x0, y0), (x1, y1)), outline="magenta", width=5 + ) + elif response["row_section"]: + img1.rectangle( + ((x0, y0), (x1, y1)), outline="brown", width=5 + ) + else: + img1.rectangle( + ((x0, y0), (x1, y1)), outline="blue", width=1 + ) + if viz: + viz_root = "./tests/test_data/viz/" + Path(viz_root).mkdir(parents=True, exist_ok=True) + png_img_bfn1 = png_img_bfn.replace(".png", "." + str(t) + ".png") + viz_fn = os.path.join(viz_root, png_img_bfn1) + img.save(viz_fn) + # assert False + + +def test_device_mode(): + r""" + Test the "predict.device_mode" parameter + """ + mini_configs = [ + {"predict": {}}, + {"predict": {"device_mode": "cpu"}}, + {"predict": {"device_mode": "cuda"}}, + {"predict": {"device_mode": "gpu"}}, + {"predict": {"device_mode": "wrong"}}, + ] + + for i, config in enumerate(mini_configs): + device = tf_predictor.decide_device(config) + assert device in ["cpu", "cuda:0"], "Irrelevant device has been returned" + + if i == 0: + assert device == "cpu", "By default the 'cpu' device should be used" + elif i == 1: + assert device == "cpu", "An explicit 'cpu' device was given" + elif i == 2 or i == 3: + assert device == "cuda:0", "Cuda or gpu should become 'cuda:0'" + else: + assert ( + device == "cpu" + ), "A fall-back to 'cpu' should happen in case of error"