From a63f7b313e4f1099ccb18be533ccda52124ae8cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Santiago=20Su=C3=A1rez?=
 <100789365+Bear-Witness-98@users.noreply.github.com>
Date: Fri, 19 Jul 2024 14:17:08 -0300
Subject: [PATCH] Version 0.1 merge (#9)

* Add gitignore

* Add packaging files

* Add formatting to python script files

* Fixes to make notebook work

* Notebook review, challange updated.

* Fix data loading directory for test

* update gitignore

* fix prediction test

* Add comment to challange.md

* Passed models tests

* Add poetry lock file

* Fix model bugs

* Additional model improvements

* Remove ipdb from model training.

* Update fastapi version

* Add api

* Update gitignore

* Removed unused imports

* Update model storing directory

* Chande model loading

* Change directory for storing the model

* Update poetry with appropriate versions

* Add dockerfile

* Update dockerfile command

* Add deploy script, and docker fix

* update library version for stress test

* update stress tests url

* Update doc

* Add copy of model to dockerfile

* Update dockerfile and poetry lock

* Add change to dockerfile

* Add training to deploy script

* Moved ci/cd files to appropriate directory.

* First ci update

* Add paths to testing

* Add .github folder to trigger

* add '' to paths

* Add commands to ci

* Fix syntax error

* Add module files to needed paths

* setup python version

* Check directory

* Checkout code

* Fix installation

* add virtualenv folder to executing machine

* Add test dependencies to poetry

* Modified dependencies installation

* Add model retrival

* Add api test

* rename job

* Add cd workflow

* Fix syntax error

* Check secret upload

* Add gcp authentication

* Add github actions workflows to PRs on main.
---
 .flake8                     |   15 +
 .github/workflows/cd.yml    |   48 +
 .github/workflows/ci.yml    |   46 +
 .gitignore                  |  165 ++
 .python-version             |    1 +
 .vscode/settings.json       |   40 +
 Dockerfile                  |   23 +-
 Makefile                    |    4 +-
 challenge/api.py            |  125 +-
 challenge/exploration.ipynb | 1046 ++++++++---
 challenge/model.py          |  171 +-
 docs/challenge.md           |   64 +
 poetry.lock                 | 3242 +++++++++++++++++++++++++++++++++++
 pyproject.toml              |   49 +
 scripts/deploy.sh           |   40 +
 src/latam/test_script.py    |    2 +
 tests/api/test_api.py       |   55 +-
 tests/model/test_model.py   |   79 +-
 tests/stress/api_stress.py  |   27 +-
 19 files changed, 4906 insertions(+), 336 deletions(-)
 create mode 100644 .flake8
 create mode 100644 .github/workflows/cd.yml
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 .gitignore
 create mode 100644 .python-version
 create mode 100644 .vscode/settings.json
 create mode 100644 poetry.lock
 create mode 100644 pyproject.toml
 create mode 100644 scripts/deploy.sh
 create mode 100644 src/latam/test_script.py

diff --git a/.flake8 b/.flake8
new file mode 100644
index 0000000..163c991
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,15 @@
+[flake8]
+# select all
+select = A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
+max-line-length = 88
+inline-quotes = double
+exclude = .venv, .git, .eggs, __pycache__, build, dist, __init__.py, .ipynb, .ipynb_checkpoints
+ignore =
+    # disable, whitespace before ':'
+    E203,
+    # disable "too many leading '#' for block comment"
+    E266,
+    # disable "line break before binary operator" which clashes with black
+    W503,
+    # disable "invalid escape sequence"
+    W605,
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
new file mode 100644
index 0000000..c7dec4a
--- /dev/null
+++ b/.github/workflows/cd.yml
@@ -0,0 +1,48 @@
+name: 'Continuous Delivery'
+
+on:
+  pull_request:
+    branches:
+      - develop
+      - main
+    paths:
+      - 'challenge/**'
+      - 'scripts/**'
+      - '.github/**'
+      - 'pyproject.toml'
+      - 'poetry.lock'
+
+jobs:
+  run_testing:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Google Cloud SDK
+      uses: google-github-actions/auth@v1
+      with:
+        credentials_json: ${{ secrets.GCP_CREDENTIAL }}
+    - name: Check directory
+      run: |
+        ls
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.10.8'
+    - name: Python version
+      run: |
+        python --version
+    - name: Install poetry and virtualenv
+      run: |
+        pip install poetry
+    - name: Install dependencies
+      run: |
+        poetry config virtualenvs.create false
+        poetry lock --no-update
+        poetry install
+    - name: Push to prod
+      run: |
+        bash scripts/deploy.sh
+    - name: Run stress test
+      run: |
+        make stress-test
\ No newline at end of file
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..7d3a60d
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,46 @@
+name: 'Continuous Integration'
+
+on:
+  pull_request:
+    branches:
+      - develop
+      - main
+    paths:
+      - 'challenge/**'
+      - 'scripts/**'
+      - '.github/**'
+      - 'pyproject.toml'
+      - 'poetry.lock'
+
+jobs:
+  run_testing:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Check directory
+      run: |
+        ls
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.10.8'
+    - name: Python version
+      run: |
+        python --version
+    - name: Install poetry and virtualenv
+      run: |
+        pip install poetry
+    - name: Install dependencies
+      run: |
+        poetry config virtualenvs.create false
+        poetry lock --no-update
+        poetry install
+    - name: Get model
+      run:
+        python challenge/model.py
+    - name: Run model test
+      run: |
+        make model-test
+    - name: Run api test
+      run: |
+        make api-test
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ad6970f
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+reports/*
+*.pkl
\ No newline at end of file
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..36435ac
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.10.8
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..f38ae60
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,40 @@
+{
+    // Set correct python path to venv's one
+    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
+    // Hide .venv from explorer and searchbar
+    "files.watcherExclude": {
+        "**/.venv/**": true
+    },
+    "files.exclude": {
+        "**/.venv/": true
+    },
+    "search.exclude": {
+        "**/.venv/": true
+    },
+    // Linting and formatting
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+        "source.organizeImports": "explicit"
+    },
+    // auto formatter
+    "black-formatter.importStrategy": "fromEnvironment",
+    // import formatter
+    "isort.importStrategy": "fromEnvironment",
+    "isort.args": [
+        "--settings-path",
+        "${workspaceFolder}/pyproject.toml"
+    ],
+    // linting
+    "flake8.importStrategy": "fromEnvironment",
+    "flake8.args": [
+        "--config=${workspaceFolder}/.flake8"
+    ],
+    "editor.wordWrapColumn": 100,
+    "files.trimFinalNewlines": true,
+    "files.trimTrailingWhitespace": true,
+    //
+    // Jupyter
+    //
+    "jupyter.notebookFileRoot": "${workspaceFolder}",
+    "jupyter.interactiveWindow.textEditor.executeSelection": true,
+}
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index ef0b367..bc0e1fb 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,3 +1,22 @@
 # syntax=docker/dockerfile:1.2
-FROM python:latest
-# put you docker configuration here
\ No newline at end of file
+FROM python:3.10.11
+# put you docker configuration here
+
+WORKDIR /module
+RUN apt update && apt install -y build-essential
+RUN pip install poetry
+
+# copy all stuff into container
+COPY challenge/ ./challenge
+COPY pyproject.toml/ .
+COPY poetry.lock .
+COPY models/ ./models
+
+# add empty README and install
+RUN touch README.md
+RUN poetry config virtualenvs.create false
+RUN poetry lock --no-update
+RUN poetry install --only main
+
+
+CMD ["python", "-m", "uvicorn", "challenge.api:app", "--host", "0.0.0.0", "--port", "8080"]
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 3218c8d..cadc6c0 100644
--- a/Makefile
+++ b/Makefile
@@ -23,10 +23,10 @@ install:		## Install dependencies
 	pip install -r requirements-test.txt
 	pip install -r requirements.txt
 
-STRESS_URL = http://127.0.0.1:8000 
+STRESS_URL =  https://delay-model-api-qzo5moezqa-uw.a.run.app
 .PHONY: stress-test
 stress-test:
-	# change stress url to your deployed app 
+	# change stress url to your deployed app
 	mkdir reports || true
 	locust -f tests/stress/api_stress.py --print-stats --html reports/stress-test.html --run-time 60s --headless --users 100 --spawn-rate 1 -H $(STRESS_URL)
 
diff --git a/challenge/api.py b/challenge/api.py
index 1a0f76f..22d16f2 100644
--- a/challenge/api.py
+++ b/challenge/api.py
@@ -1,13 +1,128 @@
+import sys
+
 import fastapi
+import pandas as pd
+from fastapi import HTTPException
+from pydantic import BaseModel
+
+from challenge.model import DelayModel
+
+
+def print_to_file(whatever: any):
+    with open("file.txt", "a") as sys.stdout:
+        print(whatever)
+
+
+valid_opera_values = [
+    "american airlines",
+    "air canada",
+    "air france",
+    "aeromexico",
+    "aerolineas argentinas",
+    "austral",
+    "avianca",
+    "alitalia",
+    "british airways",
+    "copa air",
+    "delta air",
+    "gol trans",
+    "iberia",
+    "k.l.m.",
+    "qantas airways",
+    "united airlines",
+    "grupo latam",
+    "sky airline",
+    "latin american wings",
+    "plus ultra lineas aereas",
+    "jetsmart spa",
+    "oceanair linhas aereas",
+    "lacsa",
+]
+
+valid_tipo_vuelo_values = [
+    "I",
+    "N",
+]
+
+valid_mes_values = range(1, 13)
+
+
+def valid_tipo_vuelo(tipo_vuelo: str) -> bool:
+    return tipo_vuelo in valid_tipo_vuelo_values
+
+
+def valid_opera(opera: str) -> bool:
+    return opera in valid_opera_values
+
+
+def valid_mes(mes_value: int) -> bool:
+    return mes_value in valid_mes_values
+
+
+class Flight(BaseModel):
+    OPERA: str
+    TIPOVUELO: str
+    MES: int
+
+
+class FlightData(BaseModel):
+    flights: list[Flight]
+
 
 app = fastapi.FastAPI()
+model = DelayModel()
+model.load_model("models")
+
+
+def flight_data_to_pandas(flight_data: FlightData) -> pd.DataFrame:
+    flight_data_dict = {"OPERA": [], "TIPOVUELO": [], "MES": []}
+    for elem in flight_data.flights:
+        if not valid_opera(elem.OPERA.lower()):
+            raise HTTPException(
+                status_code=400,
+                detail=(
+                    f"Value for tipo vuelo not valid. Recieved {elem.OPERA},"
+                    f" expected one from {[v for v in valid_opera_values]}"
+                ),
+            )
+        if not valid_tipo_vuelo(elem.TIPOVUELO.capitalize()):
+            raise HTTPException(
+                status_code=400,
+                detail=(
+                    f"Value for tipo vuelo not valid. Recieved {elem.TIPOVUELO},"
+                    f" expected one from {[v for v in valid_tipo_vuelo_values]}"
+                ),
+            )
+        if not valid_mes(elem.MES):
+            raise HTTPException(
+                status_code=400,
+                detail=(
+                    f"Value for tipo vuelo not valid. Recieved {elem.MES},"
+                    f" expected one from {valid_mes_values}"
+                ),
+            )
+        flight_data_dict["OPERA"].append(elem.OPERA)
+        flight_data_dict["TIPOVUELO"].append(elem.TIPOVUELO)
+        flight_data_dict["MES"].append(elem.MES)
+
+    return pd.DataFrame(flight_data_dict)
+
 
 @app.get("/health", status_code=200)
 async def get_health() -> dict:
-    return {
-        "status": "OK"
-    }
+    return {"status": "OK"}
+
 
 @app.post("/predict", status_code=200)
-async def post_predict() -> dict:
-    return
\ No newline at end of file
+async def post_predict(flight_data: FlightData) -> dict:
+    # get data and convert to pandas dataframe
+
+    flight_data_df = flight_data_to_pandas(flight_data)
+    preprocessed_data = model.preprocess(flight_data_df)
+
+    column_order = model._model.feature_names_in_
+    preprocessed_data = preprocessed_data[column_order]
+
+    pred = model.predict(preprocessed_data)
+
+    return {"predict": pred}
diff --git a/challenge/exploration.ipynb b/challenge/exploration.ipynb
index d6d5f87..2c5dfeb 100644
--- a/challenge/exploration.ipynb
+++ b/challenge/exploration.ipynb
@@ -2,17 +2,31 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running notebook from /Users/santiagosuarez/Documents/workspace/projects_clients/latam/challenge_MLE\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
     "import numpy as np\n",
     "import pandas as pd\n",
     "import matplotlib.pyplot as plt\n",
     "import seaborn as sns\n",
     "import warnings\n",
     "\n",
-    "warnings.filterwarnings('ignore')"
+    "# beware with filtered warnings. Bad practice to ignore all warnings\n",
+    "# as we may ignore one important warning.\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "print(f\"Running notebook from {os.getcwd()}\") # add this"
    ]
   },
   {
@@ -25,11 +39,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = pd.read_csv('../data/data.csv')\n",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 68206 entries, 0 to 68205\n",
+      "Data columns (total 18 columns):\n",
+      " #   Column     Non-Null Count  Dtype \n",
+      "---  ------     --------------  ----- \n",
+      " 0   Fecha-I    68206 non-null  object\n",
+      " 1   Vlo-I      68206 non-null  object\n",
+      " 2   Ori-I      68206 non-null  object\n",
+      " 3   Des-I      68206 non-null  object\n",
+      " 4   Emp-I      68206 non-null  object\n",
+      " 5   Fecha-O    68206 non-null  object\n",
+      " 6   Vlo-O      68205 non-null  object\n",
+      " 7   Ori-O      68206 non-null  object\n",
+      " 8   Des-O      68206 non-null  object\n",
+      " 9   Emp-O      68206 non-null  object\n",
+      " 10  DIA        68206 non-null  int64 \n",
+      " 11  MES        68206 non-null  int64 \n",
+      " 12  AÑO        68206 non-null  int64 \n",
+      " 13  DIANOM     68206 non-null  object\n",
+      " 14  TIPOVUELO  68206 non-null  object\n",
+      " 15  OPERA      68206 non-null  object\n",
+      " 16  SIGLAORI   68206 non-null  object\n",
+      " 17  SIGLADES   68206 non-null  object\n",
+      "dtypes: int64(3), object(15)\n",
+      "memory usage: 9.4+ MB\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = pd.read_csv('data/data.csv') # changed path\n",
     "data.info()"
    ]
   },
@@ -42,23 +89,33 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### How is the date distribuited?"
+    "### Flights by airline"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "flights_by_airline = data['OPERA'].value_counts()\n",
     "plt.figure(figsize = (10, 2))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(flights_by_airline.index, flights_by_airline.values, alpha=0.9)\n",
+    "sns.set_theme(style=\"darkgrid\") # change `set`` to `set_theme` due to deprecation\n",
+    "sns.barplot(x=flights_by_airline.index, y=flights_by_airline.values, alpha=0.9) # changed x and y values from positional to key-worded\n",
     "plt.title('Flights by Airline')\n",
     "plt.ylabel('Flights', fontsize=12)\n",
     "plt.xlabel('Airline', fontsize=12)\n",
@@ -67,15 +124,34 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "attachments": {},
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
+   "source": [
+    "### How is the date distribuited?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "flights_by_day = data['DIA'].value_counts()\n",
     "plt.figure(figsize = (10, 2))\n",
-    "sns.set(style = \"darkgrid\")\n",
-    "sns.barplot(flights_by_day.index, flights_by_day.values, color = 'lightblue', alpha=0.8)\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=flights_by_day.index, y=flights_by_day.values, color = 'lightblue', alpha=0.8) # same\n",
     "plt.title('Flights by Day')\n",
     "plt.ylabel('Flights', fontsize=12)\n",
     "plt.xlabel('Day', fontsize=12)\n",
@@ -85,14 +161,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "flights_by_month = data['MES'].value_counts()\n",
     "plt.figure(figsize = (10, 2))\n",
-    "sns.set(style = \"darkgrid\")\n",
-    "sns.barplot(flights_by_month.index, flights_by_month.values, color = 'lightblue', alpha=0.8)\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=flights_by_month.index, y=flights_by_month.values, color = 'lightblue', alpha=0.8) # same\n",
     "plt.title('Flights by Month')\n",
     "plt.ylabel('Flights', fontsize=12)\n",
     "plt.xlabel('Month', fontsize=12)\n",
@@ -102,32 +189,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "flights_by_day_in_week = data['DIANOM'].value_counts()\n",
+    "# this does not affect plotting that much, but can be used for productionalization\n",
+    "# as the order of the days is not guaranteed. Need to date-convert and then sort.\n",
     "days = [\n",
-    "    flights_by_day_in_week.index[2], \n",
-    "    flights_by_day_in_week.index[5], \n",
-    "    flights_by_day_in_week.index[4], \n",
-    "    flights_by_day_in_week.index[1], \n",
-    "    flights_by_day_in_week.index[0], \n",
-    "    flights_by_day_in_week.index[6], \n",
+    "    flights_by_day_in_week.index[2],\n",
+    "    flights_by_day_in_week.index[5],\n",
+    "    flights_by_day_in_week.index[4],\n",
+    "    flights_by_day_in_week.index[1],\n",
+    "    flights_by_day_in_week.index[0],\n",
+    "    flights_by_day_in_week.index[6],\n",
     "    flights_by_day_in_week.index[3]\n",
     "]\n",
     "values_by_day = [\n",
-    "    flights_by_day_in_week.values[2], \n",
-    "    flights_by_day_in_week.values[5], \n",
-    "    flights_by_day_in_week.values[4], \n",
-    "    flights_by_day_in_week.values[1], \n",
-    "    flights_by_day_in_week.values[0], \n",
-    "    flights_by_day_in_week.values[6], \n",
+    "    flights_by_day_in_week.values[2],\n",
+    "    flights_by_day_in_week.values[5],\n",
+    "    flights_by_day_in_week.values[4],\n",
+    "    flights_by_day_in_week.values[1],\n",
+    "    flights_by_day_in_week.values[0],\n",
+    "    flights_by_day_in_week.values[6],\n",
     "    flights_by_day_in_week.values[3]\n",
     "]\n",
     "plt.figure(figsize = (10, 2))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(days, values_by_day, color = 'lightblue', alpha=0.8)\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=days, y=values_by_day, color = 'lightblue', alpha=0.8) # same\n",
     "plt.title('Flights by Day in Week')\n",
     "plt.ylabel('Flights', fontsize=12)\n",
     "plt.xlabel('Day in Week', fontsize=12)\n",
@@ -136,15 +236,33 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
+   "source": [
+    "### Flight types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "flights_by_type = data['TIPOVUELO'].value_counts()\n",
-    "sns.set(style=\"darkgrid\")\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
     "plt.figure(figsize = (10, 2))\n",
-    "sns.barplot(flights_by_type.index, flights_by_type.values, alpha=0.9)\n",
+    "sns.barplot(x=flights_by_type.index, y=flights_by_type.values, alpha=0.9) # same\n",
     "plt.title('Flights by Type')\n",
     "plt.ylabel('Flights', fontsize=12)\n",
     "plt.xlabel('Type', fontsize=12)\n",
@@ -152,15 +270,33 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
+   "source": [
+    "### Flights by destination"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "flight_by_destination = data['SIGLADES'].value_counts()\n",
     "plt.figure(figsize = (10, 2))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(flight_by_destination.index, flight_by_destination.values, color = 'lightblue', alpha=0.8)\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=flight_by_destination.index, y=flight_by_destination.values, color = 'lightblue', alpha=0.8) # same\n",
     "plt.title('Flight by Destination')\n",
     "plt.ylabel('Flights', fontsize=12)\n",
     "plt.xlabel('Destination', fontsize=12)\n",
@@ -187,7 +323,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 81,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -203,7 +339,7 @@
     "    evening_max = datetime.strptime(\"23:59\", '%H:%M').time()\n",
     "    night_min = datetime.strptime(\"00:00\", '%H:%M').time()\n",
     "    night_max = datetime.strptime(\"4:59\", '%H:%M').time()\n",
-    "    \n",
+    "\n",
     "    if(date_time > morning_min and date_time < morning_max):\n",
     "        return 'mañana'\n",
     "    elif(date_time > afternoon_min and date_time < afternoon_max):\n",
@@ -217,7 +353,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 82,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -234,7 +370,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -251,9 +387,9 @@
     "    range3_max = datetime.strptime('31-Jul', '%d-%b').replace(year = fecha_año)\n",
     "    range4_min = datetime.strptime('11-Sep', '%d-%b').replace(year = fecha_año)\n",
     "    range4_max = datetime.strptime('30-Sep', '%d-%b').replace(year = fecha_año)\n",
-    "    \n",
-    "    if ((fecha >= range1_min and fecha <= range1_max) or \n",
-    "        (fecha >= range2_min and fecha <= range2_max) or \n",
+    "\n",
+    "    if ((fecha >= range1_min and fecha <= range1_max) or\n",
+    "        (fecha >= range2_min and fecha <= range2_max) or\n",
     "        (fecha >= range3_min and fecha <= range3_max) or\n",
     "        (fecha >= range4_min and fecha <= range4_max)):\n",
     "        return 1\n",
@@ -263,7 +399,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -280,7 +416,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -293,7 +429,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -310,7 +446,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -320,9 +456,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['Fecha-I', 'Vlo-I', 'Ori-I', 'Des-I', 'Emp-I', 'Fecha-O', 'Vlo-O',\n",
+       "       'Ori-O', 'Des-O', 'Emp-O', 'DIA', 'MES', 'AÑO', 'DIANOM', 'TIPOVUELO',\n",
+       "       'OPERA', 'SIGLAORI', 'SIGLADES', 'period_day', 'high_season',\n",
+       "       'min_diff', 'delay'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "data.columns"
    ]
@@ -345,10 +496,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 97,
    "metadata": {},
    "outputs": [],
    "source": [
+    "# percentage of delays, groupped by a particular column\n",
+    "\n",
+    "# may get this rate with pandas.groupby functions\n",
     "def get_rate_from_column(data, column):\n",
     "    delays = {}\n",
     "    for _, row in data.iterrows():\n",
@@ -358,28 +512,41 @@
     "            else:\n",
     "                delays[row[column]] += 1\n",
     "    total = data[column].value_counts().to_dict()\n",
-    "    \n",
+    "\n",
     "    rates = {}\n",
+    "    # bad practice of naming iteration vairable as iterable.\n",
+    "    # breaks if the dictionary totals would be used later\n",
     "    for name, total in total.items():\n",
     "        if name in delays:\n",
     "            rates[name] = round(total / delays[name], 2)\n",
     "        else:\n",
     "            rates[name] = 0\n",
-    "            \n",
+    "\n",
     "    return pd.DataFrame.from_dict(data = rates, orient = 'index', columns = ['Tasa (%)'])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 98,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "destination_rate = get_rate_from_column(data, 'SIGLADES')\n",
     "destination_rate_values = data['SIGLADES'].value_counts().index\n",
     "plt.figure(figsize = (20,5))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(destination_rate_values, destination_rate['Tasa (%)'], alpha = 0.75)\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=destination_rate_values, y=destination_rate['Tasa (%)'], alpha = 0.75) # same\n",
     "plt.title('Delay Rate by Destination')\n",
     "plt.ylabel('Delay Rate [%]', fontsize=12)\n",
     "plt.xlabel('Destination', fontsize=12)\n",
@@ -389,15 +556,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "airlines_rate = get_rate_from_column(data, 'OPERA')\n",
     "airlines_rate_values = data['OPERA'].value_counts().index\n",
     "plt.figure(figsize = (20,5))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(airlines_rate_values, airlines_rate['Tasa (%)'], alpha = 0.75)\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=airlines_rate_values, y=airlines_rate['Tasa (%)'], alpha = 0.75) # same\n",
     "plt.title('Delay Rate by Airline')\n",
     "plt.ylabel('Delay Rate [%]', fontsize=12)\n",
     "plt.xlabel('Airline', fontsize=12)\n",
@@ -407,15 +585,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "month_rate = get_rate_from_column(data, 'MES')\n",
     "month_rate_value = data['MES'].value_counts().index\n",
     "plt.figure(figsize = (20,5))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(month_rate_value, month_rate['Tasa (%)'], color = 'blue', alpha = 0.75)\n",
+    "sns.set_theme(style=\"darkgrid\")\n",
+    "sns.barplot(x=month_rate_value, y=month_rate['Tasa (%)'], color = 'blue', alpha = 0.75)\n",
     "plt.title('Delay Rate by Month')\n",
     "plt.ylabel('Delay Rate [%]', fontsize=12)\n",
     "plt.xlabel('Month', fontsize=12)\n",
@@ -426,16 +615,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABkwAAAIMCAYAAAC35YAtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABgOUlEQVR4nO3dd5RV5f0+7PvMUEVBBAWNii2AXxW7xhhrFAvGghoL9t57osYCVjRii2IXW0QwMWLUKLYYS2xYiEbsxKCJKBYUEHBmzvuHb/iFYMyAM7OZOde1lmvBPmc292Hm4xzm3vt5SuVyuRwAAAAAAIAKVlV0AAAAAAAAgKIpTAAAAAAAgIqnMAEAAAAAACqewgQAAAAAAKh4ChMAAAAAAKDiKUwAAAAAAICKpzABAAAAAAAqnsIEAAAAAACoeAoTAACgxSqXy0VHAAAAmolWRQcAAAAaxp577plnn3121u9LpVLat2+fZZddNttvv3123333tGo1d/8E2HPPPZMkt9xyS4Nm/U8nnXRS7rzzzjmOL7DAAllyySXTv3//7LvvvnN1zjfffDOnnXZaRowY8Z2yvffee/nxj3+cwYMHp3///t/pXP+pMT5nAADAvPHOGwAAWpD/+7//y8CBA5MktbW1mTx5ch577LEMHjw4Y8aMySWXXJKqqvnzRvNFF100l19++azfl8vlTJo0KSNGjMh5552Xtm3bZvfdd6/3+e6///68+OKLjRG1QTXnzxkAALQkChMAAGhBFlxwway22mqzHdt0002z3HLL5Zxzzsk999yTbbfdtphw/0ObNm3myJ4kG2+8cTbbbLP87ne/m6vCpLlozp8zAABoSVymBAAAFWCPPfZIt27d5lie6je/+U369euXlVdeORtvvHEuu+yy1NbW/tfzfPLJJznjjDOyySabZOWVV84666yTww8/PO+9916S5NZbb02vXr0yfvz42T7urrvuyoorrph//vOfc529devWad++fUql0qxj06dPz4UXXpi+fftm5ZVXzhprrJF9990348aNS5Jcdtlls+5W6dWrVy677LIkSV1dXa655ppsvvnmWXnllbPFFlvUe7mxiRMn5uCDD06fPn2y0UYb5Ve/+tWsv6vzzz8/ffr0yRdffDHbx1xxxRVZc8018+WXX8716/6mz9n/et2PPvpoevXqlSeeeGK2c40ZMya9evXK888/P9c5AACgUihMAACgAlRVVWW99dbLX/7yl9TU1CRJrr766px22mlZb731ctVVV2XAgAG59tprc9ppp33jOcrlcg4++OA8+eSTOeGEE3L99dfniCOOyFNPPTVrSamf/OQnadu2be66667ZPnbUqFFZb731svjii39rzpqamln/zZw5M++9914GDx6c8ePHZ/vtt5/1vJ///Oe54447ctBBB2XYsGE5+eST8+abb+b4449PuVzOzjvvnJ122ilJMnLkyOy8885JkkGDBuVXv/pVtt1221x11VXZcsstc+6552bo0KH/8+/wsssuS5cuXTJ06NDsuOOOueqqq3L++ecnSXbaaafMmDEj999//2wfc9ddd2XrrbdO+/bt/+f5/9M3fc7+1+veYIMNsthii33j3/8yyyyTNddcc65zAABApbAkFwAAVIiuXbvmq6++ymeffZa2bdvmiiuuyC677JJTTz01SfKjH/0oCy+8cE499dTsu++++f73vz/bx3/44Ydp3759TjzxxKy11lpJknXXXTd///vfM3LkyCRJx44ds/nmm+f3v/99jj766JRKpXzwwQd5+umnc8EFF3xrvvfffz8rrbTSHMeXWWaZDBw4MLvttluSZObMmZk6dWpOPfXUbL311kmSddZZJ1OmTMl5552XSZMmpXv37unevXuSzFruavz48bn99ttz3HHH5aCDDpr1mkulUq6++ursvvvu6dy583/Nt8EGG+Tcc8+d9espU6Zk+PDhOeyww7L88stn9dVXz1133TWrnHnhhRfyt7/9Leedd963vu5v8++fs44dO/7P173oootmhx12yC233JKpU6emQ4cOmT59eu67775ZrxkAAPhm7jABAIAKUS6XkySlUikvvvhipk+fnk033XS2uzo23XTTJMmTTz45x8d369YtN998c9Zcc8289957efLJJ3PLLbfkhRdeyMyZM2c9b6eddsr777+fMWPGJPn67oYOHTpk8803/9Z8iy66aH7729/mt7/9bYYNG5a11loriy22WM4777zsvvvus5bkatOmTa6//vpsvfXWmThxYp5++umMGDEif/zjH5Nktiz/7umnn065XP7G1zxjxoz/uVzVVlttNdvv+/btm6+++ipjx45Nkuy4444ZM2ZM3n///STJnXfemWWXXTarr776t5732/z756y+r3vHHXfMtGnT8uCDDyZJHnzwwUybNm22O3QAAIA5ucMEAAAqxMSJE9OuXbssvPDC+eyzz5Lkv9518OGHH37j8d///ve56KKL8s9//jMLL7xwVlxxxbRr12625/zgBz/IkksumVGjRmXttdfOqFGjsvXWW6dt27bfmq9NmzZZZZVVZv1+jTXWyI477pgDDzwwv/nNb7LsssvOeuzxxx/Pueeem3feeScdOnRI7969s8ACCyT5fyXDf/rXa+7Xr983Pj5x4sRvzbfooovO9vtFFlkkSTJ58uQkydZbb51zzz03d911V/bff/8Guavj3z9nSf1ed48ePbLOOutk1KhR2X777TNq1Kj88Ic/TLdu3b5TFgAAaOkUJgAAUAFqamryzDPPZI011kh1dXU6duyYJBkyZEiWWWaZOZ7ftWvXOY6NGTMmJ554Yvbcc8/sv//+s34A/8tf/nK2uzNKpdKsZaF22223jB8/ftZeH3Ojffv2Oe+887LLLrvk5JNPzm233ZZSqZS///3vOfzww7PZZpvl6quvzlJLLZVSqZRbb701jz/++H89379e80033ZQOHTrM8fgSSyzxrXn+VYz8y6RJk5IkXbp0SZJ06NAhW265Ze6777707Nkz06ZNy3bbbTdXr/nf/efnbG5e94477phf/OIXefvtt/PUU09lyJAh85wDAAAqhSW5AACgAowcOTIfffTRrH1AVl111bRu3ToTJ07MKqusMuu/Vq1a5aKLLsp77703xzlefPHF1NXV5cgjj5xVltTW1ubPf/5zkqSurm7Wc/v375/PP/88559/fpZffvmsuuqq85S7T58++elPf5oXX3wxo0aNSpK88sormTFjRg466KAsvfTSs5bq+ldp8K87LaqqZv/nzr/2Xfn0009ne82ffPJJLr300ll3oPw3jz766Gy/v/fee9O+ffvZXttOO+2UN954IzfddNN3vqvjPz9n9X3dSbLFFlukffv2GTRoUDp06JDNNttsnnMAAEClcIcJAAC0IFOmTMlLL72U5OsC49NPP80TTzyRkSNHZtttt03fvn2TJJ07d84BBxyQSy+9NFOmTMm6666biRMn5tJLL02pVErv3r3nOHefPn2SJGeeeWZ23HHHTJ48Obfeemtee+21JMm0adOy4IILJvn6bo0f/vCHeeKJJ3LCCSd8p9d0zDHH5L777suFF16YzTffPCuttFJatWqVCy64IPvtt19mzpyZ3/3ud7MKjWnTpiX5f3eU3HPPPVl11VXTq1evbLvttjnttNPy/vvvZ+WVV8748eNz8cUXZ8kll/zGO23+3QMPPJBu3brNel0jR47M0UcfPes1J8maa66ZZZddNs8++2wuvvjier2++n7O6vu6k6/vzunXr19GjhyZ3XbbLW3atKlXFgAAqGQKEwAAaEFeffXV7LLLLkm+XhqrQ4cO6dmzZwYNGpSdd955tucec8wxWXTRRTN8+PBcd9116dSpU9Zbb70cd9xxWWihheY497rrrpvTTz89N9xwQ+6///507do16667bi6//PIcfvjhef7557PRRhvNev7GG2+cp5566jstS5V8Xe4cffTROfPMMzN06NCceOKJufDCC3P55Zfn0EMPTadOnbLaaqvllltuyZ577pkxY8akV69e6du3b+66666cdNJJ2WmnnTJo0KAMHjw4V199dUaMGJEPPvggXbp0ydZbb51jjjkm1dXV35rjlFNOyb333psbb7wxiy66aH7xi19kr732muN5G2+8cT755JN639VR389Zjx496vW6/z3HyJEj079//3rlAACASlcq/7cdEQEAAL6DAw44IG3bts3QoUOLjtJkyuVy+vXrlx/96Ef5xS9+UWiWgQMHZuzYsbOWMgMAAL6dO0wAAIAGNXTo0IwfPz5PPPFEhg8fXnScJjFlypTceOONefnllzNhwoTsueeehWW5+eab88477+T222/PBRdcUFgOAABobhQmAABAg3rkkUfy97//PT//+c+zxhprFB2nSbRr1y4jRoxIXV1dzj333Cy11FKFZRkzZkwef/zx7L333tlmm20KywEAAM1NoUtyPfPMM9+45m+SLLnkknn44YebOBEAAAAAAFCJCr3DZPXVV88TTzwx27GXXnopRx55ZA477LCCUgEAAAAAAJVmvtr0fdq0adlmm22y7rrrZvDgwUXHAQAAAAAAKkRV0QH+3VVXXZUvv/wyJ554YtFRAAAAAACACjLfFCaffPJJbrzxxhxyyCFZeOGFi44DAAAAAABUkPmmMBk+fHgWWmih7LLLLt/pPPPRCmMAAAAAAEAzUeim7/9u1KhR2X777dOuXbvvdJ66unI+/3xaA6UCAAAAAACaq44d26e6un73jswXhclrr72WCRMm5Cc/+UmDnK+mpq5BzgMAAAAAAFSG+WJJrjFjxqRLly7p3bt30VEAAAAAAIAKNF8UJq+++mp69epVdAwAAAAAAKBCzReFyUcffZSFF1646BgAAAAAAECFKpXL5XLRIRpSbW1dPvlkatExAAAAAACAgi2ySId6b/o+X9xhAgAAAAAAUCSFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxWtVdAAAAKhUpVIpVS5hohmrq0vK5XLRMQAAoEEoTAAAoAClUinV1W0zfbofNtN8tWtXSm3tDKUJAAAtgsIEAAAKUFWVTJ9ezjXXTM5HH9UWHQfm2qKLVueggzqlbduk1pcwAAAtgMIEAAAK9NFHtfngg5qiYwAAAFQ8KyYDAAAAAAAVzx0mAAAAAAAtQKlUSpVL5GnG6upS6P54ChMAAAAAgGauVCqlurptpk8v7ofN8F21a1dKbe2MwkoThQkAAAAAQDNXVZVMn17ONddMzkcf1RYdB+baootW56CDOqVt26S2oC/h+aIwGTVqVK655ppMmDAhSy+9dI444ohstdVWRccCAAAAAGhWPvqoNh98UFN0DGiWCl/R7q677sopp5ySAQMG5N57780222yT4447Li+++GLR0QAAAAAAgApRaGFSLpdz6aWXZq+99sqAAQOy9NJL59BDD80Pf/jDPPvss0VGAwAAAAAAKkihS3KNHz8+77//fn7yk5/Mdvz6668vKBEAAAAAAFCJCi9MkmTatGnZf//98+qrr2bJJZfMoYcemk033XSez9uqVeErjQEAwLeqqiolKaVUSkqlUtFxYK59/WVbSnV1VUqlctFxAKDieX9Jczc/vL8stDCZMmVKkuTEE0/MEUcckRNOOCGjR4/OYYcdlhtuuCHrrbfeXJ+zqqqUzp07NHRUAABocDNm1KRVq+q0KvRdOcybVq2qU11dSqdOCxQdBQD4/3l/SXM2P7y/LHR0WrdunSTZf//9s8MOOyRJVlxxxbz66qvzXJjU1ZXz+efTGjQnAAA0tKqqUmprW6empjY1NbVFx4G5VlOT1NaWM3nytNTVucMEAIrm/SXNXWO9v+zYsX2qq+u3KlWhhUm3bt2SJD179pzt+AorrJBHH310ns9bU1P3XWIBAECjq64uJSmnXE7KZT9spvn5+su2nNrautTW+hoGgKJ5f0lzNz+8vyx0s4+VVlopHTp0yNixY2c7/sYbb2TppZcuKBUAAAAAAFBpCr3DpF27djnggAMydOjQdOvWLX369Mm9996bJ598MjfeeGOR0QAAAAD4jkqlUqoKvVwXvpu6OndrQCUpfPufww47LO3bt8/FF1+ciRMnZvnll89ll12Wddddt+hoAAAAAMyjUqmU6uq2mT7dD5tpvtq1K6W2dobSBCpE4YVJkuy7777Zd999i44BAAAAQAOpqkqmTy/nmmsm56OPbEBN87PootU56KBOads2qfUlDBVhvihMAAAAoLFZGojmrrkuDfTRR7X54IOaomMAwP+kMAEAAKDFszQQLYGlgQCgcSlMAAAAaPEsDURzZ2kgAGh8ChMAAAAqhqWBAAD4b6zeCgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVrVXSAiRMnZsMNN5zj+ODBg9O/f/8CEgEAAAAAAJWm8MLktddeS9u2bfPQQw+lVCrNOr7QQgsVmAoAAAAAAKgkhRcmb7zxRpZZZpkstthiRUcBAAAAAAAqVOGFyeuvv57ll1++6BjAfKhUKqXKTks0Y3V1SblcLjoGAAAAAPVQeGHyxhtvpHPnzhkwYEDGjx+fHj165NBDD/3GfU3qq1UrP2GF5u7rFfra5Msvi04C8659+ySZGZ0J8E2qqkpJSimVMtvStNBcfP1lW0p1dVVKpfn/m52Zo7lrbjOXmDuav+Y2d2aO5m5+mLlCC5Oampq88847WWGFFXLSSSdlwQUXzL333puDDjooN9xwQ9Zbb725PmdVVSmdO3dohLRAU/vww5oMG/Z5Jk2qLToKzLWuXatz4IEds9hivicB/92MGTVp1ao6rQq/jAnmXqtW1amuLqVTpwWKjlJvZo7mrDnOXGLuaN6a49yZOZqz+WHmCh2dVq1a5Zlnnkl1dXXatWuXJFl55ZXz5ptv5vrrr5+nwqSurpzPP5/W0FGBJlZVVUptbet88MHMfPCBwoTmp6amOrW15UyePC11dfP/lUhA0/vX97qamtrU1PheR/NTU5Nm9b3OzNHcNbeZS8wdzV9zmzszR3PXWDPXsWP7VFfXb1WqwrvGDh3mvPL2+9//fp544ol5PmdNTd13iQTMB6qrS0nKKZftAUHz9PWXbTm1tXWprW0eX8P2DaIlaE57B/leR3PX3L7XmTmau+Y2c4m5o/lrbnNn5mju5oeZK7QwefPNN7PLLrvkyiuvzLrrrjvr+CuvvJIVVlihwGQAUFlKpVKqq9tm+nRvqmne2rUrpbZ2hn8gAgAAMNcKLUyWX375LLfccjnzzDNzxhlnpHPnzrn99tvz0ksv5Y477igyGgBUlKqqZPr0cq65ZnI++sit2zRPiy5anYMO6pS2bZNaX8YAAADMpUILk6qqqlx11VW58MILc8wxx+Tzzz/P//3f/+WGG25Iz549i4wGABXpo49q88EHNUXHAAAAAGhyhe9h0rVr1wwePLjoGAAAAAAAQAWztSsAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFa9V0QGak1KplCoVE81YXV1SLpeLjgEAAAAAMN9RmNRTqVRKdXXbTJ/uh800X+3alVJbO0NpAgAAAADwHxQm9VRVlUyfXs4110zORx/VFh0H5tqii1bnoIM6pW3bpNaXMAAAAADAbOpVmOy1117zdPJSqZSbbrppnj52fvXRR7X54IOaomMAAAAAAAANqF47cjz77LOZMmVKyuVyvf+bMmVKnn322cbODwAAAAAA8J3Ve0muQYMGpU+fPvU+8UsvvZRdd911nkIBAAAAAAA0pXrdYXLIIYekW7duc3XixRdfPIcccsg8hQIAAAAAAGhK9brD5Jhjjvmvj5XL5Xz66adZeOGFU1X1//qXbt26fevHAQAAAAAAzC/qdYfJN/nss89y1FFHZZVVVsn666+fPn365PDDD8+HH37YkPkAAAAAAAAa3TwXJmeddVbatGmT4cOH5/77788NN9yQ6dOn58QTT2zIfAAAAAAAAI2uXoXJPffcM8exV199NYceemj69OmTHj16ZO21185ee+2VV155pcFDAgAAAAAANKZ67WFyww03ZNiwYTn++OOz/vrrJ0k23HDDHHvssdluu+3SqVOnTJo0Kbfffnt+/OMfN2pgAAAAAACAhlavwuSOO+7IPffck4EDB+Z73/tefvazn+XEE0/Mr3/96zzwwAP5+OOP06VLl+y+++7Za6+9GjszAAAAAABAg6pXYZIk22yzTbbYYovceuutOfDAA7POOuvk2GOPVZAAAAAAAADN3lxt+t66devss88+efDBB9OjR4/suOOOGTRoUCZNmtRY+QAAAAAAABpdvQuTt99+O8OHD8+vf/3rTJgwIccdd1z+8Ic/ZObMmdliiy1y8cUXZ8qUKY2ZFQAAAAAAoFHUqzC58847s91222XkyJEZNWpUdt1119xwww3p1q1bzj333IwYMSKvv/56Nttss9x4442NHBkAAAAAAKBh1aswueyyy3LyySfnrrvuym9/+9vcfPPN+dWvfpVyuZwk+f73v5+rrroqv/rVr/KHP/yhUQMDAAAAAAA0tHoVJtOnT8/CCy886/edOnXKV199lZqamtmet8466+T2229v0IAAAAAAAACNrVV9nvTTn/40v/jFL3LPPfekXbt2efbZZ7PTTjuldevWjZ0PAAAAAACg0dWrMDnmmGOy2mqr5amnnkqpVMppp52WLbfcsrGzAQAAAAAANIl6FSYTJkzI+uuvn4033rjeJ545c2YmTpyYpZZaal6zAQAAAAAANIl67WHSt2/fjBs3bq5OPG7cuPTt23eeQgEAAAAAADSlet1hUi6X86c//SnvvPNOvU/87rvvznMoAAAAAACAplSvwiRJhg4dOtcnL5VKc/X88ePHp3///jnttNPSv3//uf7zAAAAAAAA5kW9CpOHH364sXPkq6++ygknnJBp06Y1+p8FAAAAAADw7+pVmHzve99r7By57LLLsuCCCzb6nwMAAAAAAPCf6rXpe2N77rnnMnLkyJx33nlFRwEAAAAAACpQvfcwaSyff/55fv7zn+fUU0/N4osv3iDnbNWq4XugqqpSklJKpbnfmwXmB19/2ZZSXV2VUqlcdJz/yczR3Jk5aHrmDpqWmYOm1dxmLjF3NH/Nbe7MHM3d/DBzhRcmgwYNyuqrr56f/OQnDXK+qqpSOnfu0CDn+k8zZtSkVavqtCr8bw3mXqtW1amuLqVTpwWKjlJvZo7mzMxB0zN30LTMHDSt5jhzibmjeWuOc2fmaM7mh5krdHRGjRqVMWPG5O67726wc9bVlfP55w2/cXxVVSm1ta1TU1ObmpraBj8/NLaamqS2tpzJk6elrq55XBVh5mjOzBw0PXMHTcvMQdNqbjOXmDuav+Y2d2aO5q6xZq5jx/aprq7fqlTzXJhMnjw5Y8aMyYcffpgtttgin332WZZddtm5ut3rjjvuyMcff5yNN954tuMDBw7MH/7wh1x33XXzlK2mpm6ePu7bVFeXkpRTLifl8vz/P0j4T19/2ZZTW1uX2tr5/2vYzNHcmTloeuYOmpaZg6bV3GYuMXc0f81t7swczd38MHPzVJhceeWVufrqqzN9+vSUSqX06dMnl1xyST799NMMGzYsHTt2rNd5hgwZkunTp892rG/fvjnqqKOy7bbbzks0AAAAAACAuTbXu6P/+te/zmWXXZZ99903t99++6y2co899siECRNy6aWX1vtc3bp1S48ePWb7L0m6dOmSbt26zW00AAAAAACAeTLXhcktt9ySgw46KEcffXRWWmmlWcc32mijHHPMMXnkkUcaNCAAAAAAAEBjm+sluf7xj39knXXW+cbHlltuuUyaNOk7BXr99de/08cDAAAAAADMrbm+w2TxxRfPiy+++I2PvfLKK1l88cW/cygAAAAAAICmNNd3mOy000657LLL0q5du2y88cZJkmnTpmX06NG5+uqrs++++zZ0RgAAAAAAgEY114XJgQcemPfeey9DhgzJkCFDkiR77bVXkuQnP/lJDj744IZNCAAAAAAA0MjmujAplUo588wzs99+++Xpp5/OZ599loUWWihrr712evbs2RgZAQAAAAAAGtVcFyaXX355dt555yyzzDJZZpllZnvsvffey7Bhw3L66ac3VD4AAAAAAIBGN9ebvg8dOjQTJ078xsfGjh2b3/zmN985FAAAAAAAQFOq1x0mu+66a8aOHZskKZfL2WWXXf7rc1dZZZWGSQYAAAAAANBE6lWYnH322bn//vtTLpczdOjQ7Ljjjunevftsz6mqqkrHjh3Tt2/fRgkKAAAAAADQWOpVmKywwgo54ogjkny96fvOO++cbt26NWowAAAAAACApjLXm77/qzj5+OOPM3PmzJTL5SRJXV1dvvzyy4wZMya77bZbw6YEAAAAAABoRHNdmLz22ms54YQT8vbbb3/j46VSSWECAAAAAAA0K3NdmPzyl7/M5MmTc+KJJ+aPf/xj2rRpk0022SSPPfZYHnvssdx8882NkRMAAAAAAKDRVM3tB4wdOzZHH3109tlnn2y99db58ssvs/vuu+eqq67KZpttlltuuaUxcgIAAAAAADSauS5MZs6cmWWWWSZJsswyy+S1116b9Vj//v3z0ksvNVQ2AAAAAACAJjHXhckSSyyRCRMmJPm6MJkyZUree++9JEmbNm0yefLkhk0IAAAAAADQyOa6MOnbt28uvPDCjB49Ot26dctyyy2XSy65JK+//nqGDRuWpZZaqjFyAgAAAAAANJq5LkyOOOKIrLHGGvntb3+bJDn55JPz4IMPZvvtt8/TTz+dI488ssFDAgAAAAAANKZWc/sBbdu2za9+9at89dVXSZINNtgg99xzT1555ZWstNJKWXrppRs8JAAAAAAAQGOa6ztM/qV169azfr3UUktlq622SteuXfPLX/6yQYIBAAAAAAA0lXoXJiNGjMhPf/rT7LLLLrntttvmeHzUqFHZYostcsMNNzRoQAAAAAAAgMZWryW5brzxxpx33nnp3r172rdvnzPPPDNVVVXZZZdd8u677+bkk0/Oiy++mI4dO+bUU09t7MwAAAAAAAANql6FyR133JENNtggV155ZVq1apXBgwfnhhtuSO/evXPAAQdk6tSp2WWXXXLMMcdk4YUXbuTIAAAAAAAADateS3K999572WWXXdKq1df9yl577ZW//e1vOeqoo7LYYotlxIgRGTRokLIEAAAAAABolup1h8mXX36ZRRdddNbv//XrpZdeOtdee23atWvXOOkAAAAAAACaQL03fS+VSrN+XV1dnSQ57LDDlCUAAAAAAECzV+/C5Jt07NixoXIAAAAAAAAU5jsVJv9+1wkAAAAAAEBzVa89TJLk8MMPT5s2bWY7dsghh6R169azHSuVSnnooYcaJh0AAAAAAEATqFdhssMOOzR2DgAAAAAAgMLUqzAZPHhwY+cAAAAAAAAozHfawwQAAAAAAKAlUJgAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8ea6MJk4cWJj5AAAAAAAACjMXBcmm2yySQ444ID84Q9/yMyZMxsjEwAAAAAAQJOa68Jk8ODBqaurywknnJAf/ehHOeOMM/Lyyy83RjYAAAAAAIAm0WpuP2C77bbLdtttl4kTJ+bOO+/MXXfdldtuuy0rrLBC+vfvn2233TZdu3ZtjKwAAAAAAACNYp43fe/WrVsOOeSQ3HfffbnjjjvSuXPnXHDBBdl4441z5JFHZuzYsQ2ZEwAAAAAAoNHMc2GSJGPGjMlpp52W/fffP88//3zWX3/9nHTSSfnyyy+z22675cYbb2ygmAAAAAAAAI1nrpfkevfdd3PXXXfl97//fd5///1873vfy5577pn+/ftn8cUXT5LsscceOeGEE3LllVdmn332aejMAAAAAAAADWquC5Mtttgibdu2zWabbZazzjor66233jc+b7nllsvf/va375oPAAAAAACg0c11YXLaaadl2223zUILLfStzzvssMNy2GGHzXMwAAAAAACApjLXe5gMGDDgv5Yl06ZNy2OPPTZX5/v444/zs5/9LD/4wQ+y+uqr56CDDsrbb789t7EAAAAAAADm2VzfYfKPf/wjAwcOzLPPPpuZM2d+43PGjRtX7/MdfvjhqauryzXXXJMOHTrk0ksvzT777JMHHngg7du3n9t4AAAAAAAAc22u7zA599xz88ILL2TnnXfOiiuumDXWWCP77bdfevXqlVKplMsvv7ze55o8eXK+973v5eyzz06fPn2y/PLL57DDDsuHH36YN998c26jAQAAAAAAzJO5Lkyee+65HHvssTn11FPTv3//tG3bNj/72c9yxx13ZO21187DDz9c73N16tQpF154YXr27Jkk+eSTT3LjjTeme/fuWWGFFeY2GgAAAAAAwDyZ6yW5pk6dml69eiVJlltuuVl3lFRXV2f33XfP+eefP09BTjvttNx+++1p06ZNrrzyyiywwALzdJ4kadVqrnug/6mqqpSklFIpKZVKDX5+aGxff9mWUl1dlVKpXHSc/8nM0dyZOWh65g6alpmDptXcZi4xdzR/zW3uzBzN3fwwc3NdmCy22GKZNGlSkqRHjx6ZPHlyPvrooyy66KJZeOGF8/HHH89TkL333ju77LJLbr311hx++OEZPnx4Vlpppbk+T1VVKZ07d5inDP/LjBk1adWqOq3m+m8NiteqVXWqq0vp1Gney8imZuZozswcND1zB03LzEHTao4zl5g7mrfmOHdmjuZsfpi5uR6djTbaKJdcckm6d++e1VdfPd27d8+wYcNy+OGH54477ki3bt3mKci/luA655xzMnbs2Pz617/O4MGD5/o8dXXlfP75tHnK8G2qqkqprW2dmpra1NTUNvj5obHV1CS1teVMnjwtdXXN46oIM0dzZuag6Zk7aFpmDppWc5u5xNzR/DW3uTNzNHeNNXMdO7ZPdXX9VqWa68LkqKOOyiuvvJJLL700N954Y4499ticdNJJufHGG5Mkp59+er3P9cknn+Spp57KFltskVb/f+1ZVVWVFVZYIR9++OHcRpulpqZunj/2v6muLiUpp1xOyuX5/3+Q8J++/rItp7a2LrW18//XsJmjuTNz0PTMHTQtMwdNq7nNXGLuaP6a29yZOZq7+WHm5row6dy5c37zm9/MKjS23XbbLLHEEnnppZfSp0+frLPOOvU+16RJk3LcccfluuuuywYbbJAk+eqrr/Lqq69m0003ndtoAAAAAAAA82SeV7NbbLHFZv16rbXWylprrTXX5+jZs2c23HDDnH322Tn77LPTqVOnXH311fn888+zzz77zGs0AAAAAACAuVKvwmSvvfaq9wlLpVJuuummej//oosuyoUXXphjjz02X3zxRdZaa63ceuutWWKJJep9DgAAAAAAgO+iXoXJ3Kx5N7fr4y200EIZNGhQBg0aNFcfBwAAAAAA0FDqVZjccsstjZ0DAAAAAACgMPO8h8nbb7+dJ598Mh999FH22GOPTJgwIb17986CCy7YkPkAAAAAAAAa3VwXJnV1dTn99NNzxx13pFwup1QqZcstt8wVV1yRd999N7feemu6d+/eGFkBAAAAAAAaRdXcfsAVV1yRu+++O2effXaefPLJWXuW/OxnP0u5XM7FF1/c4CEBAAAAAAAa01wXJnfccUeOOuqo7Ljjjll44YVnHV9xxRVz1FFH5cknn2zIfAAAAAAAAI1urguTSZMmZcUVV/zGx7p165bPP//8O4cCAAAAAABoSnNdmPTo0SN/+tOfvvGxZ599Nj169PjOoQAAAAAAAJrSXG/6vvfee+f000/PV199lU022SSlUinvvvtunnnmmQwbNiwnnXRSY+QEAAAAAABoNHNdmOy888755JNPcuWVV+a2225LuVzOcccdl9atW+eAAw7Ibrvt1hg5AQAAAAAAGs1cFyZJcvDBB2fAgAF58cUX89lnn6Vjx45ZddVVZ9sEHgAAAAAAoLmYp8Kkrq4uM2fOzEorrZTOnTunVCo1dC4AAAAAAIAmM1eFyT333JMRI0Zk7NixqampSZK0a9cua6yxRnbbbbdsttlmjRISAAAAAACgMdWrMKmtrc3xxx+f+++/P926dUu/fv3StWvXlMvlfPDBB3n22Wdz5JFHZrvttst5553X2JkBAAAAAAAaVL0Kk+HDh+eBBx7IKaeckj322GOOJbhqa2szYsSInHvuuVlrrbWy0047NUpYAAAAAACAxlBVnyeNGjUqu+66a/bcc89v3K+kuro6AwYMyE9/+tPceeedDR4SAAAAAACgMdWrMBk/fnw23HDD//m8DTbYIG+88cZ3DgUAAAAAANCU6lWYfPnll+nUqdP/fF7nzp0zderU7xwKAAAAAACgKdWrMCmXy6murv7fJ6uqSrlc/s6hAAAAAAAAmlK9ChMAAAAAAICWrFV9nzho0KAsuOCC3/qcKVOmfOdAAAAAAAAATa1ehcnaa6+dJP9zua0OHTpkrbXW+u6pAAAAAAAAmlC9CpNbbrmlsXMAAAAAAAAUxh4mAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFK7ww+eyzz3L66adnww03zBprrJHddtstY8aMKToWAAAAAABQQQovTI477ri8+OKLueiii3LHHXdkxRVXzP7775933nmn6GgAAAAAAECFKLQweffdd/Pkk09m0KBBWWuttbLsssvmtNNOy2KLLZa77767yGgAAAAAAEAFKbQw6dy5c6655pqsssoqs46VSqWUSqV8/vnnBSYDAAAAAAAqSasi//COHTtmo402mu3Y6NGj8+677+YXv/jFPJ+3VauG74GqqkpJSimVvi51oLn5+su2lOrqqpRK5aLj/E9mjubOzEHTM3fQtMwcNK3mNnOJuaP5a25zZ+Zo7uaHmSu0MPlPL7zwQk4++eT07ds3G2+88Tydo6qqlM6dOzRssP/fjBk1adWqOq3mq781qJ9WrapTXV1Kp04LFB2l3swczZmZg6Zn7qBpmTloWs1x5hJzR/PWHOfOzNGczQ8zN9+MzkMPPZQTTjgha6yxRoYMGTLP56mrK+fzz6c1YLKvVVWVUlvbOjU1tampqW3w80Njq6lJamvLmTx5WurqmsdVEWaO5szMQdMzd9C0zBw0reY2c4m5o/lrbnNn5mjuGmvmOnZsn+rq+q1KNV8UJr/+9a9zzjnnZMstt8z555+fNm3afKfz1dTUNVCy/6e6upSknHI5KZfn//9Bwn/6+su2nNrautTWzv9fw2aO5s7MQdMzd9C0zBw0reY2c4m5o/lrbnNn5mju5oeZK3TT9yQZPnx4zjrrrAwYMCAXXXTRdy5LAAAAAAAA5lahd5iMHz8+5557bjbffPMcfPDBmTRp0qzH2rVrl4UWWqjAdAAAAAAAQKUotDAZPXp0vvrqqzz44IN58MEHZ3tshx12yHnnnVdQMgAAAAAAoJIUWpgccsghOeSQQ4qMAAAAAAAAUPweJgAAAAAAAEVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFQ8hQkAAAAAAFDxFCYAAAAAAEDFU5gAAAAAAAAVT2ECAAAAAABUvPmqMLn66quz5557Fh0DAAAAAACoMPNNYXLrrbfmkksuKToGAAAAAABQgVoVHWDixIkZOHBgnnnmmSyzzDJFxwEAAAAAACpQ4XeY/PWvf03r1q3z+9//PquuumrRcQAAAAAAgApU+B0mm266aTbddNMGPWerVg3fA1VVlZKUUiolpVKpwc8Pje3rL9tSqqurUiqVi47zP5k5mjszB03P3EHTMnPQtJrbzCXmjuavuc2dmaO5mx9mrvDCpKFVVZXSuXOHRjn3jBk1adWqOq1a3N8alaBVq+pUV5fSqdMCRUepNzNHc2bmoOmZO2haZg6aVnOcucTc0bw1x7kzczRn88PMtbjRqasr5/PPpzX4eauqSqmtbZ2amtrU1NQ2+PmhsdXUJLW15UyePC11dc3jqggzR3Nm5qDpmTtoWmYOmlZzm7nE3NH8Nbe5M3M0d401cx07tk91df1WpWpxhUmS1NTUNfg5q6tLScopl5Nyef7/HyT8p6+/bMupra1Lbe38/zVs5mjuzBw0PXMHTcvMQdNqbjOXmDuav+Y2d2aO5m5+mLnCN30HAAAAAAAomsIEAAAAAACoeAoTAAAAAACg4s1Xe5icd955RUcAAAAAAAAqkDtMAAAAAACAiqcwAQAAAAAAKp7CBAAAAAAAqHgKEwAAAAAAoOIpTAAAAAAAgIqnMAEAAAAAACqewgQAAAAAAKh4ChMAAAAAAKDiKUwAAAAAAICKpzABAAAAAAAqnsIEAAAAAACoeAoTAAAAAACg4ilMAAAAAACAiqcwAQAAAAAAKp7CBAAAAAAAqHgKEwAAAAAAoOIpTAAAAAAAgIqnMAEAAAAAACqewgQAAAAAAKh4ChMAAAAAAKDiKUwAAAAAAICKpzABAAAAAAAqnsIEAAAAAACoeAoTAAAAAACg4ilMAAAAAACAiqcwAQAAAAAAKp7CBAAAAAAAqHgKEwAAAAAAoOIpTAAAAAAAgIqnMAEAAAAAACqewgQAAAAAAKh4ChMAAAAAAKDiKUwAAAAAAICKpzABAAAAAAAqnsIEAAAAAACoeAoTAAAAAACg4ilMAAAAAACAiqcwAQAAAAAAKp7CBAAAAAAAqHgKEwAAAAAAoOIpTAAAAAAAgIqnMAEAAAAAACqewgQAAAAAAKh4hRcmdXV1+dWvfpUNNtggq622Wg488MBMmDCh6FgAAAAAAEAFKbwwueKKKzJ8+PCcddZZGTFiROrq6nLAAQdk5syZRUcDAAAAAAAqRKGFycyZMzNs2LAcddRR2XjjjdO7d+9cfPHF+eCDD/LAAw8UGQ0AAAAAAKgghRYmr732WqZOnZr11ltv1rGOHTvm//7v//Lcc88VmAwAAAAAAKgkpXK5XC7qD3/ggQdy5JFHZuzYsWnXrt2s40cffXSmT5+eq6++eq7PWS6XU1fX8C+pVErq6kr54ou61NYW9lcG86y6upSFFqpKVVU5xU19/Zk5mjszB03P3EHTMnPQtJrbzCXmjuavuc2dmaO5a6yZq6oqpVQq1eu5rRruj517X375ZZKkTZs2sx1v27ZtJk+ePE/nLJVKqa6u34ufW1VVSefO1Y1ybmg6jTMfjcHM0TKYOWh65g6alpmDptV8Zi4xd7QUzWfuzBwtQ3EzV+iSXP+6q+Q/N3ifMWNG2rdvX0QkAAAAAACgAhVamCy++OJJkg8//HC24x9++GG6detWRCQAAAAAAKACFVqY9O7dOwsuuGCeeeaZWcc+//zzvPrqq1l77bULTAYAAAAAAFSSQvcwadOmTfbYY48MGTIkiyyySL73ve/lggsuSPfu3dO3b98iowEAAAAAABWk0MIkSY466qjU1NTk1FNPzfTp07P22mvn+uuvT+vWrYuOBgAAAAAAVIhSuVwuFx0CAAAAAACgSIXuYQIAAAAAADA/UJgAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPEUJgAAAAAAQMVTmFCImTNn5qqrrsq7776bJDnllFOy+uqrZ//998+nn35acDpouV544YV88sknSZJRo0bl4IMPztVXX51yuVxwMgAAAID5z8MPP5yf/vSnWW211bLWWmtl1113zYMPPlh0LBqJwoRCDBkyJDfccEOmTJmSxx57LHfeeWcOPvjgTJ06Nb/85S+Ljgct0ogRIzJgwIC8/vrree2113LyySfnq6++yo033pihQ4cWHQ9aJBcIQHHefvvt3HfffXnooYfyzjvvFB0HWrS77747H3zwQZLkiiuuyDbbbJPTTz89M2bMKDgZtDzeX0LTeuCBB3LEEUdkscUWy7HHHpsjjjgiXbp0ydFHH52HH3646Hg0glLZZcUUYMMNN8zgwYOz/vrrZ+DAgXn33Xdz44035pVXXsmBBx6Yp556quiI0OJstdVW2WOPPTJgwIBcdNFFefTRR/P73/8+jz/+eAYOHJhHHnmk6IjQ4px77rm56667MmzYsHz88cc55JBDctRRR+XRRx/Nsssum8GDBxcdEVqcGTNm5Pjjj8/DDz886w7KUqmUTTbZJJdccknatGlTcEJoWa644opcddVVufHGG1MulzNgwIDsvPPOefbZZ7PhhhvmlFNOKToitCjeX0LT2n777bPZZpvliCOOmO345Zdfnj/96U/5zW9+U1AyGos7TCjEZ599luWXXz5J8uSTT2b99ddPkiy88MKZPn16kdGgxXrvvfey6aabJvl67jbccMMkyfLLL59JkyYVGQ1arPvvvz8XXXRRVlpppTz88MNZZ511csghh+TUU0/No48+WnQ8aJEuvvji/OUvf8nll1+e5557Ls8880wuu+yyvPrqq7nsssuKjgctzh133JHzzz8/a6yxRkaPHp3VVlstZ511Vs4555zcf//9RceDFsf7S2ha77zzTn7yk5/McXybbbbJG2+8UUAiGpvChEIsvfTSefnll/PXv/417733XjbYYIMkyUMPPZQll1yy4HTQMnXp0iUffvhhPvroo4wbN25WUfnaa6+la9euBaeDlskFAtD07rnnnpxxxhn58Y9/nIUWWiidOnXKZpttloEDB+buu+8uOh60OB9++GFWX331JMmf//zn/OhHP0qSLL744vn888+LjAYtkveX0LQWW2yxWUvg/bt33303Cy20UAGJaGytig5AZTrggANy3HHHpaqqKj/4wQ/Su3fvDB06NEOHDs25555bdDxokfr165cTTjgh7du3T/fu3bPOOuvkD3/4Q84666zstNNORceDFulfFwh8/PHHLhCAJjJ16tQst9xycxxfdtll88knnxSQCFq27t27Z/z48ZkxY0beeuutWT+8HTNmTLp3715wOmh5vL+EprXNNttk0KBBGThwYNZcc80kyfPPP58zzjgjW2+9dcHpaAwKEwqx/fbbp3fv3nnvvfdmLQu0yiqr5Prrr896661XcDpomY4//vh07949EyZMyIABA1JdXZ2PP/44u+66a4488sii40GL5AIBaHo9e/bM/fffn4MPPni24/fdd1+WXXbZglJBy7XrrrvmmGOOSZs2bdKrV6+svvrqufXWW/PLX/4yRx11VNHxoMXx/hKa1qGHHpo33ngjBx98cEqlUpKkXC5n4403znHHHVdwOhqDTd8p1MyZM/Pee+9l6aWXTrlcTuvWrYuOBAAN6rXXXpt1gUCbNm3y2GOPpXXr1i4QgEby6KOP5rDDDkvfvn2zxhprJPn6KsAHH3wwF154YbbaaquCE0LL88gjj2TChAnZdttt07lz59x9992ZMWOGu5ihkXh/CU3v7bffzuuvv54k6dWr16yl8Wh5FCYUolwu58ILL8wtt9ySr776KqNHj87FF1+c9u3bZ9CgQYoTaCR/+tOfcv311+edd97JyJEj87vf/S5LL710tttuu6KjQYvmAgFoWg8++GCuvfbavPHGGymXy+nVq1cOOOCA9O3bt+ho0KLNnDkzbdq0KToGVATvLwEahyW5KMQtt9ySu+66KwMHDsyZZ56ZJNlss81yxhlnpGvXrjn22GMLTggtz5NPPpkjjjgi/fr1y0svvZS6urrU1NTk5JNPTrlczvbbb190RGhxXCAAxdh8882z+eabFx0DKsZtt92Wa6+9Nh988EFGjx6d6667Lt26dcthhx1WdDRocby/hMbXu3fvWctv/S/jxo1r5DQ0NYUJhRg5cmROP/30bL755jnrrLOSJFtvvXVat26dwYMHK0ygEVx22WU5/vjjs88++2T06NFJkmOPPTYLLrhgrr/+eoUJNAIXCEDTu/zyy7/xeKlUSuvWrdO9e/dsuOGGWXjhhZs2GLRQd999dy688MLsvffeue6665Ikyy+/fIYMGZJ27dplv/32KzghtCzeX0LjO/fcc2cVJu+//36uvfba7LLLLll99dXTunXrvPzyy7n11ltz6KGHFpyUxqAwoRDvvfdeVlxxxTmO9+7dOx999FEBiaDle/311/PLX/5yjuNbbrnlf/3hEvDduEAAmt5zzz2X5557Lq1bt561yfu7776b6dOnZ/HFF89nn32Wtm3b5uabb873v//9gtNC8zds2LCccsop2WGHHTJs2LAkyV577ZUFFlgg1157rcIEGpj3l9D4+vfvP+vXe+yxR0477bTZ9uXabLPNsvzyy+emm27K/vvvX0REGlFV0QGoTN/73vfy8ssvz3H8sccey1JLLVVAImj5FlpooXz44YdzHH/rrbfSqVOnAhJBy+cCAWh6ffr0yZprrplHHnkko0aNyqhRo/LII4/khz/8YXbYYYc888wz2XjjjTNkyJCio0KLMH78+Ky11lpzHF933XXzz3/+s4BE0LJ5fwlN6y9/+UvWXnvtOY736dMnb731VgGJaGwKEwqx//7754wzzsjNN9+ccrmcp556KkOGDMkvf/nL7LnnnkXHgxbpJz/5Sc4999y89tprKZVKmTp1ah577LGcddZZ2XrrrYuOBy2SCwSg6f32t7/NL37xi3Tp0mXWsc6dO+dnP/tZhg8fntatW2f//ffPCy+8UGBKaDm6du2a8ePHz3H8xRdfzGKLLVZAImjZvL+EptWjR4/ce++9cxwfOXJkVlhhhQIS0dgsyUUhdtxxx9TU1OTKK6/M9OnTc/rpp2eRRRbJMccck912263oeNAiHXPMMfnggw9m7VWyww47pFwuZ+ONN3bbNjSSf10g8NFHH826QGDkyJG55ZZbctJJJxUdD1qkmpqafPXVV3McnzFjRqZPn54kadOmTerq6po6GrRIu+yyS84888ycfPLJSZJ33nknTzzxRC655JLsvffeBaeDlsf7S2haRx11VI466qj8+c9/ziqrrJK6urq8+OKLGTduXK699tqi49EISuVyuVx0CCrbJ598knK5PNtVgEDjeffddzNu3LjU1dWlZ8+eroiARjZy5MhceeWV+eCDD5IkiyyySA488MDsu+++BSeDlunYY4/N3//+91x00UXp0aNHkq+XDPr5z3+e7t2755JLLsmQIUMyduzYDB8+vOC00DJcdNFFuemmmzJjxowkSatWrbLrrrvmF7/4RaqqLGwBDc37S2haL7zwQm699da88cYbSZIVV1wx++23X3r37l1wMhqDwoTCvP/++xk7dmxmzpw5x2P/ugIeaDgDBgxI//79s+WWW6ZDhw5Fx4GK4wIBaBqffPJJDj744Lzyyivp2LFjyuVyvvjii6y66qq57LLL8te//jXHHntsrr766qyzzjpFx4UW48svv8xbb72Vcrmc5ZZbLgsuuGDRkaBF+sc//pHu3bunqqpqtveXNTU1efXVV9OnT5+iIwI0awoTCnH77bfnjDPOSG1t7RyPlUqljBs3roBU0LKdfPLJefDBB1NbW5vNN988/fv3zw9+8IOiY0GL5wIBaHrlcjnPPPNMxo0bl+rq6vTu3XtWOfLpp5+mVatWWWihhQpOCc3XP/7xj3o/d4kllmjEJFB5VlxxxTz55JNZZJFFZjv+t7/9Ldttt13Gjh1bUDJouR5++OG88cYbs/0cc+bMmXn55Zdzww03FJiMxqAwoRCbbrppNtlkkxx77LGuPIImNHPmzDz88MO5++6789hjj2WxxRbL9ttvnx122MEGgdAIXCAAQEvUu3fvlEqlb31OuVz2vQ4ayK233pphw4Yl+fpinMUXX3yO5e4+//zzdO3aNffdd18REaHFGjJkSK677rp07do1H3/8cbp165ZJkyaltrY2/fr1y5AhQ4qOSANTmFCIVVZZJffdd1+WXHLJoqNAxZo8eXLuvPPOXHbZZZk2bZp/zEIjcIEANL133nknZ555Zl544YVv3Pzd9zv47p599tl6P9fSd/Ddffnll7n++utTLpczdOjQ7LvvvnMss9yhQ4f07ds33/ve9wpKCS3TRhttlP333z977bVXNtpoo9x2221ZYIEFcvjhh2edddbJ0UcfXXREGlirogNQmVZcccW89dZbChMowIwZM/Lwww/n97//fZ588sksvvjiOeCAA4qOBS3SRx99lH333VdZAk1o4MCB+fjjj3PCCSdYdgsayX8rQT755JO0atUqHTt2bOJE0LK1b98+RxxxRJLkueeey+GHH+79JTSRjz/+OJtuummSpFevXvnLX/6SLbfcMscee2xOOeUUhUkLpDChEAcccEDOPPPMTJgwIcstt1zatGkz2+Nrr712Qcmg5Xr88cdzzz335KGHHkq5XM6WW26ZG264IWuttVbR0aDFcoEANL2xY8fmtttuy0orrVR0FKgYN998c6655pp8/PHHSZKuXbtm//33zz777FNsMGiB3nzzzbz77ru+z0ET6dixY6ZNm5YkWXrppfPWW28l+XqProkTJxYZjUaiMKEQRx11VJLknHPOmeMx69xC4zjooIOy9tpr57TTTssWW2yR9u3bFx0JWjwXCEDT69y5c1q3bl10DKgYI0aMyAUXXJDdd989a6+9dsrlcp577rlcdNFFWXDBBbPTTjsVHRFalEUWWSRffPFF0TGgYqy77roZMmRIzjrrrKy66qq5+uqrs/vuu2f06NFZZJFFio5HI7CHCYWYMGHCHBuU/TtrbkLDe++991zlDk2sd+/e//UxFwhA47j22mvz/PPPZ8iQIZYrgSaw5ZZbZo899sgee+wx2/Fbb701I0aMyN13311QMmiZzj///AwfPjwbbbRRevTokbZt2872+L+W7gIaxj//+c8ceuih2X777bP77rtn1113nfXvuJNOOil77713wQlpaAoTCrHTTjvl7LPP/tYfJAEN77XXXstNN92U8ePH59JLL81DDz2UFVZYIeuuu27R0aBFev/997/1cRcIQMPbd999M2bMmNTW1qZLly5z3Nn18MMPF5QMWqY+ffrknnvuydJLLz3b8b///e/ZZptt8pe//KWgZNAy/WsvhW9SKpV8n4NGMmPGjLRt2zZffvllnnjiiXTr1i19+vQpOhaNwJJcFGLChAlZYIEFio4BFeWVV17JbrvtltVWWy2vvPJKZs6cmXHjxmXw4MEZOnRoNtpoo6IjQoujEIGmt+aaa2bNNdcsOgZUjCWWWCKvvPLKHIXJyy+/nK5duxaUClquRx55pOgIUJFeeOGFvPnmm2nTpk2+//3vK0taMIUJhTjggANyyimnZP/998/SSy+ddu3azfb4EkssUVAyaLkuuOCC7Lfffjn22GOz+uqrJ0nOPvvsdOjQIZdddpnCBBrBXnvt9a2P33zzzU2UBCqHpUigae26664544wz8tlnn2WNNdZIkjz//PP51a9+9T+/DwINZ+bMmXn55ZddNAAN7B//+EeOOOKIvPrqq+nUqVPq6uoyZcqUrLvuurnkkkuy8MILFx2RBqYwoRCXXHJJamtr89xzz6VUKs06Xi6XrekOjeSvf/1rBg0aNMfxAQMG5Pbbb2/6QFAB/vMOk5qamrz77rt54403rHULDejyyy/P/vvvn/bt2+fyyy//r88rlUo5/PDDmzAZtHx77bVX3n///Zx77rmpra1NuVxOq1atsuuuu+bQQw8tOh60OK+88kpOO+20vPHGG6mrq5vjcT9PgYZ15plnpk2bNhk9enR69OiRJHn99ddz4okn5uyzz86QIUMKTkhDU5hQiBtuuKHoCFBxWrdunSlTpsxx/J///Gfat29fQCJo+QYPHvyNx4cOHZoPPvigidNAy/W73/0uAwYMSPv27fO73/3uvz5PYQINr6qqKqecckqOPvrovPPOO0mS5ZdfPh06dCg4GbRMgwcPTnV1dU499dQMHjw4J510Uv7+97/n1ltvzS9/+cui40GL8/TTT2f48OGzypIk6dWrVwYNGpT99tuvwGQ0FoUJhVhnnXVm/XrmzJlzbMYJNLzNNtssl1xySS6++OJZx95+++2cc8452XjjjYsLBhVou+22y/bbb5+zzjqr6CjQIvz7eu7WdoemNX369JxxxhlZZpllcvDBByf5elPq9ddfP6eddpp/60EDe/XVV3PTTTelT58++d3vfpeePXtm9913T/fu3XP77bdnq622KjoitCgdO3bMV199NcfxUqnk4tMWqqroAFSu2267LZtuumlWW221TJgwIQMHDswVV1xRdCxosU488cRMnTo1P/jBD/Lll1+mf//+2WabbVJdXZ2f//znRceDivLiiy+murq66BjQok2aNCn/+Mc/5vgPaFjnnXdexowZM2uPvCQ5+eST88wzz8x2oQ7QMOrq6rLooosmSXr06JE33ngjSfLjH/84r732WpHRoEU68sgjc/rpp+fNN9+cdWzChAk566yzcsghhxSYjMbiDhMKcffdd+fCCy/M3nvvneuuuy7J17dtDxkyJO3atXNLGzSCBRdcMCNGjMhTTz2VV199NXV1denZs2c22GCDVFXpz6ExfNNmt1OmTMnrr7+e3XbbrYBE0PL96U9/ysknn5xPP/10tuP2yoPG8dBDD+Wyyy6brTDZfPPNs/DCC+f444/PiSeeWGA6aHl69OiR559/Pttss02WW265vPzyy0mSL774IjNnziw4HbQMvXv3nmPP5W233TYdOnRIdXV1Pv/885RKpXzwwQfZc889C0xKY1CYUIhhw4bllFNOyQ477JBhw4Yl+fqHSgsssECuvfZahQk0ovXWWy/rrbde0TGgIvznpu/J1/sJ7bHHHtluu+0KSAQt3znnnJM+ffpk9913T7t27YqOAy3e1KlT07FjxzmOL7LIIpk8eXIBiaBl23PPPfOLX/wiSbLFFltku+22S7t27fLCCy9k1VVXLTgdtAznnnvubIUJlUVhQiHGjx+ftdZaa47j6667bs4888wCEkHLt+mmm37rN/yHH364CdNAZfhvm74/99xz6du3r7mDRvDhhx/mqquuynLLLVd0FKgIq622Wq677rqcc845s+5aLpfLuemmm7LKKqsUnA5anp133jmdO3fOwgsvnOWXXz7nnXderrnmmiyxxBI57bTTio4HLUL//v2LjkCBFCYUomvXrhk/fnyWWmqp2Y6/+OKLWWyxxQpKBS3bDjvsMFthUlNTk7/97W95/PHHc9RRRxWYDCrP9OnT7aUAjeQHP/hB/vrXvypMoIkce+yx2XvvvfPMM89k5ZVXTpL89a9/zWeffTZrNQHgu7n88su/8fjTTz+dJOnbt2+S5M4778wRRxzRZLmgUjz88MN54403UltbO+vYzJkz8/LLL+eGG24oMBmNQWFCIXbZZZeceeaZOfnkk5Mk77zzTp544olccskl2XvvvQtOBy3TkUce+Y3HR4wYkT//+c9mD4AWYdCgQdlpp53y+OOPZ6mllprj7ko/SIKG1adPn9x9990ZOXJk3nzzzbRq1SrbbLNNBgwY4GI4aCCXX355qqqq0r179299XqlU8n0OGtiQIUNy3XXXpWvXrvn444/TrVu3TJo0KbW1tenXr1/R8WgEChMKceCBB+aLL77IcccdlxkzZuTggw9Oq1atsuuuu+aQQw4pOh5UlA022CDnn39+0TEAoEFcccUVmTRpUh5//PG0b99+tsf8IAka3tlnn5299torxx9/fNFRoMX66U9/mgcffDBJ0q9fv/Tr1y+9e/cuOBVUhrvvvju/+MUvstdee2WjjTbK8OHDs8ACC+Twww+fY+UcWoZSuVwuFx2CyvXll1/mrbfeSrlcznLLLZcFF1yw6EhQcYYNG5Zhw4bliSeeKDoKVIzHH388Bx10UMaNG1d0FGhx1lhjjZx22mnZYYcdio4CFWHNNdfMXXfdlSWXXLLoKNCi1dbW5umnn84f/vCHPPTQQ+nSpcus8mSZZZYpOh60WCuvvHLuv//+LLnkkjnooIPSv3//bLnllhkzZkxOOeWUjB49uuiINDB3mNBknnvuuay++upp1apVnnvuuTke//cfGq299tpNGQ0qwjdt+j516tRMnjz5vy7XBcy9/7bG9L979913myAJVKb27dtnjTXWKDoGVIyNNtoov/71r3PEEUe4AA4aUXV1ddZff/2sv/76GTRoUJ544oncd9992XHHHbP00ktn6623Tr9+/bLEEksUHRValI4dO2batGlJkqWXXjpvvfVWkmSJJZbIxIkTi4xGI3GHCU1mxRVXzJNPPplFFlnkW28dLZVKrriFRvBNP8Rt3bp1Vltttay77roFJIKWadNNN633cx955JFGTAKVaejQoRk/fnzOOuusOZbkAhrennvumeeeey6lUildunRJ27ZtZ3v84YcfLigZVIaZM2fmjjvuyIUXXpipU6f6eQo0sGOPPTZTp07NWWedlWeffTZXX311br755tx111255ZZb/JuuBXKHCU2mVatWufPOO7P99tt70wxNZNSoUbN+/Z/LJFRXV2eRRRbJyiuv3MSpoGXzhhmKNWbMmDz33HO5//7706VLl7RqNfs/ebwPhYa17rrruvgGCvDhhx/mgQceyP3335/nn38+PXr0yJ577ll0LGhxfv7zn+fQQw/Nfffdl9133z033HBD1l9//STJSSedVHA6GoM7TGgyp556akaPHp0vv/wym2yySXbaaadsuOGGcywRBDSc+mwE2KlTp1x11VVZffXVmyARADSu/7Usnk3fAWiuJk6cmNGjR+f+++/Piy++mKWWWipbbbVVttpqK5vAQyObMWNGpk6dmsceeyzvv/9+Ntxww6yyyipFx6IRKExoUjNnzsyDDz6YUaNG5c9//nO6du2aHXbYITvuuGOWWmqpouNBxfnss8/yq1/9Kq+88kpuv/32ouMAANAMvfbaa7npppsyfvz4XHrppXnooYfy/e9/P+uss07R0aBFuPHGGzN69OiMHTs2SyyxRLbaaqtsueWWWWmllYqOBi3W0KFDc/PNN+f2229Pjx498sILL+Sggw7K1KlTUy6Xs9566+XKK69Mu3btio5KA1OYUJhJkyblrrvuyl133ZW33nora6+9dnbaaadsscUWadOmTdHxoGK899572WabbfLSSy8VHQUAGsQrr7yS66+/Pm+88UZatWqVFVZYIXvvvXf69OlTdDRocV555ZXstttuWW211fLiiy/mvvvuy9VXX51Ro0Zl6NCh2WijjYqOCM1e796907p16/zwhz/8n1e0u5MSvruRI0fm7LPPzj777JODDz44Cy64YLbccstMmTIlN954YxZaaKEceeSR+dGPfpSjjjqq6Lg0MIUJ84Vx48bl3nvvzQMPPJDJkyfnmWeeKToSVIxRo0bl8ssvz0MPPVR0FAD4zp599tnst99+6dmzZ9Zaa63U1dXlhRdeyBtvvJGbbropa665ZtERoUXZZ599suqqq+bYY4/N6quvnt///vdZaqmlMnjw4Dz//PP57W9/W3REaPY23XTTej2vVCrZqwsawE477ZQddtghAwYMSJK8/PLL2XnnnXPsscfm4IMPTpL88Y9/zHnnnZfRo0cXGZVGYNN3CldXV5ePPvookyZNyuTJk7PAAgsUHQkqwhtvvJHjjjsub7/9dk488cSi4wBAg7j44ouz44475owzzpjt+BlnnJFLLrkkt9xyS0HJoGV65ZVXMnDgwDmODxgwwJKv0EAeeeSRoiNARXn77bdnbeyeJE8//XRKpdJsd02usMIK+cc//lFEPBqZwoTCjB07NnfffXfuu+++fPHFF9lkk00yZMiQ/OhHPyo6GlSELl26ZMMNN8xJJ51k7gBoMV599dWcffbZcxzfY489stNOOxWQCFq21q1bZ8qUKXMc/+c//5n27dsXkAgAvrtSqTTr12PGjEmnTp3Su3fvWcemTp3q+1wLpTChSY0fPz5333137rnnnkyYMCHf//73c9BBB2XbbbdN586di44HFaVLly75+c9/XnQMAGhQnTt3zqeffjrH8U8++cQ+edAINttss1xyySW5+OKLZx17++23c84552TjjTcuLhgAzKOePXvmhRdeSI8ePfL555/nmWeeyY9//OPZnnPfffelZ8+eBSWkMSlMaDL9+/fPuHHjsuCCC6Zfv37Zcccd/+dmZQAAMDc22WSTnHXWWbnooouy/PLLJ0neeuutnH322fVeAx6ovxNPPDEHHHBAfvCDH6Suri79+/fPlClT0rt3bxfnANAsDRgwIAMHDsy4cePy4osvZubMmdl7772TJBMnTszdd9+d66+/Puecc07BSWkMNn2nyey1117ZaaedssUWW6Rt27ZFxwEAoAWaPHly9t1334wbNy4LLbRQkuSLL75I7969M2zYMHc1QyN56qmn8uqrr6auri49e/bMBhtskKqqqqJjAcA8+e1vf5vbbrstVVVVOeCAA7LFFlskSc4888zcfvvtOfDAA3P00UcXnJLGoDABAABalClTpuSPf/xj/v73v6dNmzbp1atXfvSjH/nhLQAA38nEiRPTpk0bF+G0YJbkAgAAmr0pU6bk+uuvz7333psJEybMOt6jR49su+22WXvttW3MCQ1kxRVXzBNPPJEuXbqkd+/es22M+5/GjRvXhMkAoHF169at6Ag0MneYAAAAzdqnn36aPfbYI//85z+z+eabp2fPnunYsWO++OKL/PWvf83DDz+cpZZaKsOHD5+1TBcw7+68887069cvbdq0yZ133vmtz91hhx2aKBUAwHfnDhMAAKBZu/TSS1NXV5d77703iy+++ByPf/DBBznwwAMzbNgwa01DA3j//fdzzTXXFB0DAKDBucMEAABo1jbZZJOcfvrp2WSTTf7rcx566KFccMEFGT16dBMmg5apd+/eqaqqSvfu3b/1eaVSKQ8//HATpQIA+O7cYQIAADRrkyZNSs+ePb/1Ob17984//vGPJkoELdtPf/rTPPjgg0mSfv36pV+/fundu3fBqQAAvjt3mAAAAM1a79698+STT6ZLly7/9TmTJk3KBhtsYANqaCC1tbV5+umn84c//CEPPfRQunTpMqs8WWaZZYqOBwAwTxQmAABAs6YwgWJ99dVXeeKJJ3Lffffl4YcfztJLL52tt946/fr1yxJLLFF0PACAelOYAAAAzVrv3r2z//77p3379v/1OdOmTcsNN9ygMIFGNnPmzNxxxx258MILM3XqVDMHADQr9jABAACatSWWWCL33Xff/3ze4osv3gRpoDJ9+OGHeeCBB3L//ffn+eefT48ePbLnnnsWHQsAYK64wwQAAACYaxMnTszo0aNz//3358UXX8xSSy2VrbbaKltttZVN4AGAZklhAgAAANTbjTfemNGjR2fs2LFZYoklstVWW2XLLbfMSiutVHQ0AIDvRGECAAAA1Fvv3r3TunXr/PCHP8wqq6zyrc894ogjmigVAMB3pzABAAAA6m3TTTet1/NKpVIefvjhRk4DANBwFCYAAAAAAEDFqyo6AAAAAAAAQNEUJgAAAAAAQMVTmAAAAAAAABVPYQIAAAAAAFS8VkUHAAAA+E977rlnnn322Vm/L5VKad++fZZddtlsv/322X333dOqlX/OAAAADce/MAAAgPnS//3f/2XgwIFJktra2kyePDmPPfZYBg8enDFjxuSSSy5JVZWb5gEAgIahMAEAAOZLCy64YFZbbbXZjm266aZZbrnlcs455+See+7JtttuW0w4AACgxXE5FgAA0Kzsscce6datW0aMGJEkmT59ei688ML07ds3K6+8ctZYY43su+++GTduXJLk0UcfTa9evfLEE0/Mdp4xY8akV69eef7555MkN910U7bccsusssoq2WCDDTJo0KBMmTKlaV8cAABQGHeYAAAAzUpVVVXWW2+93HvvvampqcnPf/7zjBkzJscdd1yWXnrpvPvuu7n00ktz/PHH5957780GG2yQxRZbLHfddVd+9KMfzTrPqFGjsswyy2TNNdfMPffckwsuuCAnnnhievXqlXfeeSfnn39+vvzyy5x//vkFvloAAKCpKEwAAIBmp2vXrvnqq6/y2WefZerUqTn11FOz9dZbJ0nWWWedTJkyJeedd14mTZqURRddNDvssENuueWWTJ06NR06dMj06dNz33335aCDDkqSPPvss1lyySUzYMCAVFVVZZ111skCCyyQyZMnF/kyAQCAJqQwAQAAmp1yuZwkKZVKuf7665MkEydOzPjx4/O3v/0tf/zjH5MkM2fOTJLsuOOOufrqq/Pggw9m++23z4MPPphp06Zl++23T5L84Ac/yMiRI9O/f/9sttlm2WijjfKTn/wkpVKp6V8cAABQCHuYAAAAzc7EiRPTrl27LLzwwnn88cez1VZbZcMNN8xhhx2W3//+92nTpk2S/1es9OjRI+uss05GjRqV5OvluH74wx+mW7duSZKtt946F154YRZYYIFcccUV2WmnnfLjH/84f/jDHwp5fQAAQNNTmAAAAM1KTU1Nnnnmmayxxhp5//33c/jhh2fFFVfMgw8+mOeffz7Dhw/PJptsMsfH7bjjjnn22Wfz9ttv56mnnsqOO+442+PbbLNNhg8fnmeeeSaXXHJJFl544fzsZz/LxIkTm+qlAQAABVKYAAAAzcrIkSPz0UcfZbfddssrr7ySGTNm5KCDDsrSSy89awmtxx9/PMn/u8MkSbbYYou0b98+gwYNSocOHbLZZpvNeuyYY47J4YcfniRZaKGFstVWW+Wwww5LTU1NPvzwwyZ8dQAAQFHsYQIAAMyXpkyZkpdeeilJUldXl08//TRPPPFERo4cmW233TZ9+/bNu+++m1atWuWCCy7Ifvvtl5kzZ+Z3v/tdHn300STJtGnTZp2vffv26devX0aOHJnddttt1rJdydd7mAwcODDnn39+Ntxww3z++ee5/PLLs8wyy6R3795N+bIBAICClMr/fskVAADAfGDPPffMs88+O+v3pVIpHTp0SM+ePbPDDjtk5513nnU3yf3335/LL788f//739OpU6esttpq2WuvvbLnnnvmtNNOy4ABA2ad55FHHsmhhx6a3/zmN+nTp89sf+Ytt9ySESNG5L333ku7du2y3nrr5Wc/+1m+973vNc2LBgAACqUwAQAAKsbAgQMzduzYWZu/AwAA/IsluQAAgBbv5ptvzjvvvJPbb789F1xwQdFxAACA+ZDCBAAAaPHGjBmTxx9/PHvvvXe22WabouMAAADzIUtyAQAAAAAAFa+q6AAAAAAAAABFU5gAAAAAAAAVT2ECAAAAAABUPIUJAAAAAABQ8RQmAAAAAABAxVOYAAAAAAAAFU9hAgAAAAAAVDyFCQAAAAAAUPH+P2sFDQLUbvQRAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 2000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "days_rate = get_rate_from_column(data, 'DIANOM')\n",
     "days_rate_value = data['DIANOM'].value_counts().index\n",
     "\n",
-    "sns.set(style=\"darkgrid\")\n",
+    "sns.set_theme(style=\"darkgrid\")\n",
     "plt.figure(figsize = (20, 5))\n",
-    "sns.barplot(days_rate_value, days_rate['Tasa (%)'], color = 'blue', alpha = 0.75)\n",
+    "sns.barplot(x=days_rate_value, y=days_rate['Tasa (%)'], color = 'blue', alpha = 0.75)\n",
     "plt.title('Delay Rate by Day')\n",
     "plt.ylabel('Delay Rate [%]', fontsize=12)\n",
     "plt.xlabel('Days', fontsize=12)\n",
@@ -446,16 +646,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "high_season_rate = get_rate_from_column(data, 'high_season')\n",
     "high_season_rate_values = data['high_season'].value_counts().index\n",
     "\n",
     "plt.figure(figsize = (5, 2))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot([\"no\", \"yes\"], high_season_rate['Tasa (%)'])\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=[\"no\", \"yes\"], y=high_season_rate['Tasa (%)'])\n",
     "plt.title('Delay Rate by Season')\n",
     "plt.ylabel('Delay Rate [%]', fontsize=12)\n",
     "plt.xlabel('High Season', fontsize=12)\n",
@@ -466,15 +677,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcEAAADyCAYAAAA1In5fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAApbElEQVR4nO3de1RU9cI+8GcGuYWieAEUBTULBSFQwBe8RLwKHk28oCEgeANFS/KWgIrQDbwTEKSWoOIFSAzS1LROpXIEQom3Dnk6S9GEYyAqcAABZeb3h4v5NYE6M8wFneez1iyZPXu+82xheNjf2XtGIBaLxSAiItJCQk0HICIi0hSWIBERaS2WIBERaS2WIBERaS2WIBERaS2WIBERaS2WIBERaS2WIBERaS2WIJGa8f0p5Mf/M1IVliCpVGBgIKytrSWX4cOHw9HREbNmzcKBAwfw8OFDhcYMDAxUQVppERERUtnbLo6Ojpg2bRrS0tLkHvPf//43/Pz8Op2tvLwc1tbWOHbsWKfH+qvHbXfb5fTp0wAADw8PREREKJxH1vt8++23CA8PVzivtbW1Wn5e6NnUTdMB6PlnY2OD6OhoAEBraytqa2tx7tw5xMXFoaioCB999BGEwq7591i/fv3w8ccfS66LxWJUV1cjIyMDmzdvhr6+Pvz9/WUe7/Tp0yguLlZFVKX663b/2eDBg9stMzU1RWZmJiwtLZWeZd++fU+8ffny5Zg7d67kekpKCkpLS6Xyd+/eXem56PnAEiSV6969OxwcHKSWeXh4YOjQofjwww9x4sQJeHt7aybcU+jp6bXLDgDu7u6YOHEijh07JlcJPiset93KWl+ZLC0tpcq3d+/eGs1Dz5au+ec3aYV58+bBzMwMGRkZUss///xzTJ06FSNHjoS7uzuSkpLQ2tr62HHu3r2Ld999F6+99hpGjhwJFxcXvPnmmygvLwcAHDp0CNbW1igrK5O6X25uLkaMGIFbt27JnV1XVxeGhoYQCASSZU1NTdixYwc8PT0xcuRIjBo1CgsXLsSvv/4KAEhKSpLsnVhbWyMpKQkAIBKJsGfPHkyaNAkjR46El5cX0tPTZcpRWVmJpUuXwt7eHq+++ioSExMl/1dbtmyBvb09/vvf/0rdJyUlBaNHj8b9+/fl3u7H6Whqs7i4GAEBAXBwcIC7uzv279+PBQsWSKZQ29y+fRthYWFwdHSEi4sLoqKi0NDQAODR1HdhYSEKCwthbW2NgoIChfJ9//33sLa2xoULF6SWFxUVwdraGpcuXUJBQYFknYCAANjb28PT0xOHDx+Wuk9nvl/U9bAESWOEQiFcXV3xf//3f5LXBnfv3o2oqCi4urpi165dCAgIwKeffoqoqKgOxxCLxVi6dCny8vKwdu1a7N27F2+99RYuXrwomYKdNm0a9PX1kZubK3XfnJwcuLq6on///k/M+fDhQ8mlpaUF5eXliIuLQ1lZGWbMmCFZb926dcjOzsaSJUuQmpqKyMhI/Pvf/8aaNWsgFosxZ84czJ49GwCQmZmJOXPmAABiYmKQmJgIb29v7Nq1C5MnT0ZsbCySk5Of+n+YlJSEPn36IDk5GT4+Pti1axe2bNkCAJg9ezaam5slr+G1yc3NxZQpU2BoaCjzdrddZD1A5erVq1iwYAEAYOfOnVixYgX27NmDS5cutVs3ISEB/fv3R0pKCubPn4+srCzJHwvR0dGwsbGBjY0NMjMzYWtrK9Pj/9X48eNhamra4c/A4MGDMXr0aMmyVatWwcbGBsnJyXBzc8O7774rVYSd+X5R18PpUNKovn374sGDB6ipqYG+vj5SUlLg6+uLjRs3AgDGjRuHXr16YePGjVi4cCFeeuklqftXVVXB0NAQ4eHhcHJyAgCMGTMGv//+OzIzMwEAxsbGmDRpEr788ku8/fbbEAgE+OOPP5Cfn49t27Y9MV9FRUWHv3gHDx6M6OhoyUEuLS0taGhowMaNGzFlyhQAgIuLC+rr67F582ZUV1fD3Nwc5ubmACCZqisrK0NWVhZWr16NJUuWSLZZIBBg9+7d8Pf3h4mJyWPzjR8/HrGxsZKv6+vrcfjwYSxfvhwvvvgiHB0dkZubKyncy5cv4/r169i8ebNC271mzRpJzifZvXs3evTogc8++0xStkOHDpV67a6Nl5cXIiMjAQCurq7Iy8tDfn4+AGDYsGGS1/M6M72po6ODmTNnIj09HQ0NDTAyMkJTUxNOnTrVbnsmTZqEDRs2AHj0f1pVVYWUlBT4+fnh+vXrnfp+UdfDPUHSqLY9C4FAgOLiYjQ1NcHDw0Nq78PDwwMAkJeX1+7+ZmZmOHDgAEaPHo3y8nLk5eUhPT0dly9fRktLi2S92bNno6KiAkVFRQAe7QEYGRlh0qRJT8zXr18/HD16FEePHkVqaiqcnJxgamqKzZs3w9/fXzIdqqenh71792LKlCmorKxEfn4+MjIy8N133wGAVJY/y8/Ph1gs7nCbm5ubO9xz+rO//e1vUtc9PT3x4MEDlJSUAAB8fHxQVFSEiooKAMAXX3yBIUOGwNHRUebt/vNl5syZT7zfn7drwoQJUnubjo6OsLCwaLdu2x8vbQYOHIi6ujqZHkcePj4+aGxsxNmzZwEAZ8+eRWNjo9TePIB22+jp6Ynbt2+jrKys098v6nq4J0gaVVlZCQMDA/Tq1Qs1NTUA8Ng9jaqqqg6Xf/nll9i5cydu3bqFXr16YcSIETAwMJBa53/+538wcOBA5OTkwNnZGTk5OZgyZQr09fWfmE9PTw92dnaS66NGjYKPjw9CQkLw+eefY8iQIZLbzp8/j9jYWFy7dg1GRkYYPnw4XnjhBQCPP8+tbZunTp3a4e2VlZVPzNevXz+p67179wYA1NbWAgCmTJmC2NhY5ObmYvHixR3u+XTkr9str7t376JPnz7tlvft27fdsr9OywqFQpWcF2hlZQUXFxfk5ORgxowZyMnJgZubG8zMzKTW++v1tu2ora3t9PeLuh6WIGnMw4cPUVBQgFGjRkFHRwfGxsYAgO3bt3d4GH5Hv0CLiooQHh6OwMBALF68WPILbOvWrVJ/lQsEAsl0mJ+fH8rKyiSvncnD0NAQmzdvhq+vLyIjI3HkyBEIBAL8/vvvePPNNzFx4kTs3r0bgwYNgkAgwKFDh3D+/PnHjte2zfv374eRkVG72wcMGPDEPG1l16a6uhrA///FbWRkhMmTJ+PUqVN4+eWX0djYiOnTp8u1zYowNzeXZPmzO3fuYOjQoSp//Mfx8fHB+vXrcfXqVVy8eBHbt29vt869e/ekjja9c+cOgEf/p539flHXw+lQ0pjMzEzcvn1b8rraK6+8Al1dXVRWVsLOzk5y6datG3bu3Ck52vPPiouLIRKJsGLFCkkBtra24h//+AeAR0fytZk1axbq6uqwZcsWvPjii3jllVcUym1vb4833ngDxcXFyMnJAQD88ssvaG5uxpIlS2BpaSmZJm0rwLY9m7+eD9k2FXjv3j2pbb579y4SEhIkex6P8/3330td/+qrr2BoaCi1bbNnz8Zvv/2G/fv3d7jnowrOzs44f/48mpubJctKS0s7/B4+jTLPIfXy8oKhoSFiYmJgZGSEiRMntlvnm2++kbp++vRpWFhYwNLSstPfL+p6uCdIKldfX4+ffvoJwKNSunfvHi5cuIDMzEx4e3vD09MTAGBiYoLg4GAkJCSgvr4eY8aMQWVlJRISEiAQCDB8+PB2Y9vb2wMA3nvvPfj4+KC2thaHDh3ClStXAACNjY2SAysGDBgANzc3XLhwAWvXru3UNq1cuRKnTp3Cjh07MGnSJNja2qJbt27Ytm0bFi1ahJaWFhw7dkxSUo2NjQD+/57fiRMn8Morr8Da2hre3t6IiopCRUUFRo4cibKyMsTHx2PgwIEd7hH/2ZkzZ2BmZibZrszMTLz99ttSJ4ePHj0aQ4YMQWFhIeLj4zu13bIKDQ3FyZMnERwcjEWLFqGurg4JCQkQCoVSp5XIwtjYGMXFxbh48SJsbGzQs2dPhXMZGhpi6tSpyMzMhJ+fH/T09Nqtk5aWBn19fTg4OODMmTP47rvvsGPHDgDo9PeLuh7uCZLKlZaWwtfXF76+vvD398e6detw5coVxMTEYOvWrVLrrly5EhERETh79ixCQkKwbds2jB49GgcPHkSPHj3ajT1mzBhs2rQJxcXFCAkJwebNmzFgwADJIfZ/PVDB3d0dOjo6nZ4SNDExwdtvv43bt28jOTkZVlZW2LFjByorK7Fs2TJs2rQJAJCeng6BQCA5IMfT0xN2dnaIiIjA3r17AQBxcXFYuHAhMjIyEBwcjF27dmHKlClITU2Fjo7OE3Ns2LABP//8M5YsWYJTp05h/fr1WLZsWbv13N3d0bNnzw73fFTBysoKe/fuRXNzM8LCwhAfH4+QkBD069evw2nEJwkICICuri5CQkJw7ty5Tmdzd3cH8GhmoCPr16/HDz/8gGXLlqGkpASJiYl4/fXXJbd35vtFXY9AzHemJS0SHBwMfX19rTqnSywWY+rUqRg3bhzWr1+vlse8ePEidHV1pY78rKurg5ubG9atW4egoCC15OhIdHQ0SkpKJFPZbQoKChAUFIQDBw5gzJgxmglHasfpUNIKycnJKCsrw4ULF9q9A8jzqr6+Hvv27cPPP/+MmzdvqvVNpP/5z38iMTERq1evhq2tLWpqapCWloYePXpI7VWp04EDB3Dt2jVkZWU99fxQ0h4sQdIKf//73/H7779j3bp1GDVqlKbjqIWBgQEyMjIgEokQGxuLQYMGqe2x214XPXLkCG7duoUXXngBLi4uiIuLk5zGoW5FRUU4f/485s+fr7Eipq6H06FERKS1eGAMERFpLZYgERFpLZYgERFpLZYgERFprefu6FCxWAyRiMf6EBFpM6FQINO7Ez13JSgSiXH3boOmYxARkQb17m0EHZ2nlyCnQ4mISGuxBImISGuxBImISGuxBImISGuxBImISGs9d0eHKptQKIBQKN+HgBIpQiTi6T1E6sYSfAKhUIBevV6Ajg53mEn1WltFqKlpZBESqRFL8AmEQgF0dIRIPpKHiqpaTceh55iFaU+86TcWQqGAJUikRixBGVRU1eJ6xT1NxyAiIiXjPB8REWktliAREWktliAREWktliAREWktliAREWktliAREWmtLlGCOTk5mDJlCuzs7DB16lScOnVK05GIiEgLaLwEc3NzsWHDBgQEBOCrr77C66+/jtWrV6O4uFjT0YiI6Dmn0RIUi8VISEhAUFAQAgICYGlpiWXLlsHNzQ2FhYWajEZERFpAo+8YU1ZWhoqKCkybNk1q+d69ezWUiIiItInGSxAAGhsbsXjxYpSWlmLgwIFYtmwZPDw8FB63Wzfl7ODyjbNJ3fgzR6ReGi3B+vp6AEB4eDjeeustrF27Fl9//TWWL1+OtLQ0uLq6yj2mUCiAiYmRsqMSqYWxsaGmIxBpFY2WoK6uLgBg8eLFmDlzJgBgxIgRKC0tVbgERSIx6uoalZJPR0fIX0qkVnV199HaKtJ0DKJnnrGxoUwzKzKVYFBQkEIhBAIB9u/f/9jbzczMAAAvv/yy1PJhw4bh+++/V+gxAeDhQ/4SoWdTa6uIP79EaiTTCxCFhYWor6+HWCyW+VJfX//UIzxtbW1hZGSEkpISqeW//fYbLC0tFd8qIiIiGcg8HRoTEwN7e3uZB/7pp58wd+7cJ65jYGCA4OBgJCcnw8zMDPb29vjqq6+Ql5eHffv2yfxYREREipCpBENDQyVTl7Lq378/QkNDn7re8uXLYWhoiPj4eFRWVuLFF19EUlISxowZI9fjERERyUsgFovFnRlALBbj3r176NWrF4RCzR/e3doqwt27DUoZq1s3IUxMjLA+4SQ/WZ5UarCFCWLfnoJ79xr4miCREvTubSTTgTEKt1ZNTQ3CwsJgZ2eHsWPHwt7eHm+++SaqqqoUHZKIiEitFC7B999/H3p6ejh8+DBOnz6NtLQ0NDU1ITw8XJn5iIiIVEamEjxx4kS7ZaWlpVi2bBns7e1hZWUFZ2dnBAUF4ZdfflF6SCIiIlWQ6cCYtLQ0pKamYs2aNRg7diwAYMKECVi1ahWmT5+Onj17orq6GllZWfjf//1flQYmIiJSFplKMDs7GydOnEB0dDQsLCzwzjvvIDw8HAcPHsSZM2dw584d9OnTB/7+/gqfWE9ERKRuMp8n+Prrr8PLywuHDh1CSEgIXFxcsGrVKpYeERE9s+Q6MEZXVxcLFizA2bNnYWVlBR8fH8TExKC6ulpV+YiIiFRG5hK8evUqDh8+jIMHD+LmzZtYvXo1Tp48iZaWFnh5eSE+Pl7yqRBERETPAplK8IsvvsD06dORmZmJnJwczJ07F2lpaTAzM0NsbCwyMjLwr3/9CxMnTuTbnRER0TNDphJMSkpCZGQkcnNzcfToURw4cACJiYloe7OZl156Cbt27UJiYiJOnjyp0sBERETKIlMJNjU1oVevXpLrPXv2xIMHD/Dw4UOp9VxcXJCVlaXUgERERKoi09Ghb7zxBtavX48TJ07AwMAAhYWFmD17tuRDcYmIiJ5FMpXgypUr4eDggIsXL0IgECAqKgqTJ09WdTYiIiKVkqkEb968ibFjx8Ld3V3mgVtaWlBZWYlBgwYpmo2IiEilZHpN0NPTE7/++qtcA//666/w9PRUKBQREZE6yLQnKBaL8cMPP+DatWsyD3zjxg2FQxEREamDzG+blpycLPfgAoFA7vsQERGpi0wl+O2336o6BxERkdrJVIIWFhaqzkFERKR2Cn+yPBER0bOOJUhERFqLJUhERFqLJUhERFpL5lMk/qq2thZFRUWoqqqCl5cXampqMGTIEJ4WQUREzwyFSvCTTz7B7t270dTUBIFAAHt7e3z00Ue4d+8eUlNTYWxsrOycRERESif3dOjBgweRlJSEhQsXIisrS/KZgvPmzcPNmzeRkJCg9JBERESqIHcJpqenY8mSJXj77bdha2srWf7qq69i5cqV+Pvf/67UgERERKoi93Tof/7zH7i4uHR429ChQ1FdXd3pUETUtQiFAgiFfL2fVE8kEkMkEqvt8eQuwf79+6O4uBhubm7tbvvll1/Qv39/pQQjoq5BKBTAxMQQQqGOpqOQFhCJWnHv3n21FaHcJTh79mwkJSXBwMBA8vmCjY2N+Prrr7F7924sXLhQ2RmJSIMe7QXqoOzEp7h/55am49BzzLBPfwx5PQRCoaDrlmBISAjKy8uxfft2bN++HQAQFBQEAJg2bRqWLl2q3IRE1CXcv3ML9yt/13QMIqWSuwQFAgHee+89LFq0CPn5+aipqUGPHj3g7OyMl19+WRUZiYiIVELuo0M//vhjVFZWYvDgwZg7dy5CQ0MREBCAl19+GeXl5XjvvfcUDlNWVgZHR0ccO3ZM4TGIiIhkJXcJJicno7KyssPbSkpK8PnnnysU5MGDB1i7di0aGxsVuj8REZG8ZJoOnTt3LkpKSgAAYrEYvr6+j13Xzs5OoSBJSUno3r27QvclIiJShEwl+MEHH+D06dMQi8VITk6Gj48PzM3NpdYRCoUwNjaGp6en3CF+/PFHZGZmIicnR3LEKRERkarJVILDhg3DW2+9BeDRgTFz5syBmZmZUgLU1dVh3bp12Lhxo9LOMezWTTkfjqGjww/ZIPXqij9zXTETPd/U+TMn99GhbWV4584dtLS0SN47VCQS4f79+ygqKoKfn5/M48XExMDR0RHTpk2TN0qHHp3Ya6SUsYjUzdjYUNMRiDROnc8DuUvwypUrWLt2La5evdrh7QKBQOYSzMnJQVFREY4fPy5vjMcSicSoq1POwTU6OkL+UiK1qqu7j9ZWkaZjSOHzgNRNGc8DY2NDmfYo5S7BrVu3ora2FuHh4fjuu++gp6eH1157DefOncO5c+dw4MABmcfKzs7GnTt32r0OGB0djZMnT+Kzzz6TNx4A4OHDrvVLhEhWra0i/vyS1lPn80DuEiwpKUFkZCRmz54NQ0NDHD9+HP7+/vD390dYWBjS09Ph5OQk01jbt29HU1OT1DJPT0+EhYXB29tb3mhERERykbsEW1paMHjwYADA4MGDceXKFclts2bNQnR0tMxjPe7gmj59+ijtwBsiIqLHkfsQnAEDBuDmzZsAHpVgfX09ysvLAQB6enqora1VbkIiIiIVkXtP0NPTEzt27MALL7wALy8vDB06FB999BFCQkKQmpqKQYMGdSrQv/71r07dn4iISFZy7wm+9dZbGDVqFI4ePQoAiIyMxNmzZzFjxgzk5+djxYoVSg9JRESkCnLvCerr6yMxMREPHjwAAIwfPx4nTpzAL7/8AltbW1haWio9JBERkSoofFq+rq6u5OtBgwbhb3/7G/r27YutW7cqJRgREZGqyVyCGRkZeOONN+Dr64sjR460uz0nJwdeXl5IS0tTakAiIiJVkWk6dN++fdi8eTPMzc1haGiI9957D0KhEL6+vrhx4wYiIyNRXFwMY2NjbNy4UdWZiYiIlEKmEszOzsb48ePxySefoFu3boiLi0NaWhqGDx+O4OBgNDQ0wNfXFytXrkSvXr1UHJmIiEg5ZJoOLS8vh6+vL7p1e9SZQUFBuH79OsLCwmBqaoqMjAzExMSwAImI6Jki057g/fv30a9fP8n1tq8tLS3x6aefwsDAQDXpiIiIVEjmA2MEAoHkax0dHQDA8uXLWYBERPTM6tQnFxobGysrBxERkdp1qgT/vHdIRET0rJH5HWPefPNN6OnpSS0LDQ2VOmkeeFSM33zzjXLSERERqZBMJThz5kxV5yAiIlI7mUowLi5O1TmIiIjUrlOvCRIRET3LWIJERKS1WIJERKS1WIJERKS15C7ByspKVeQgIiJSO7lL8LXXXkNwcDBOnjyJlpYWVWQiIiJSC7lLMC4uDiKRCGvXrsW4cePw7rvv4ueff1ZFNiIiIpWS+R1j2kyfPh3Tp09HZWUlvvjiC+Tm5uLIkSMYNmwYZs2aBW9vb/Tt21cVWYmIiJRK4QNjzMzMEBoailOnTiE7OxsmJibYtm0b3N3dsWLFCpSUlCgzJxERkdJ16ujQoqIiREVFYfHixbh06RLGjh2LiIgI3L9/H35+fti3b5+SYhIRESmf3NOhN27cQG5uLr788ktUVFTAwsICgYGBmDVrFvr37w8AmDdvHtauXYtPPvkECxYsUHZmIiIipZC7BL28vKCvr4+JEyfi/fffh6ura4frDR06FNevX+9sPiIiIpWRuwSjoqLg7e2NHj16PHG95cuXY/ny5QoHIyIiUjW5XxMMCAh4bAE2Njbi3LlznQ5FRESkDnLvCf7nP/9BdHQ0CgsLH3uy/K+//trpYERERKomdwnGxsbi8uXLmDNnDi5fvgxDQ0M4ODggLy8Pv/32G5KSklSRk4iISOnkng798ccfsWrVKmzcuBGzZs2Cvr4+3nnnHWRnZ8PZ2RnffvutKnISEREpndwl2NDQAGtrawCPjgAtLS0FAOjo6MDf3x/5+fnKTUhERKQicpegqakpqqurAQBWVlaora3F7du3AQC9evXCnTt35BqvpqYGmzZtwoQJEzBq1Cj4+fmhqKhI3lhERERyk7sEX331VXz00UcoLi6GhYUFzM3NkZqaivr6emRnZ8PMzEyu8VavXo3i4mLs3LkT2dnZGDFiBBYvXoxr167JG42IiEgucpdgWFgYjI2NkZCQAABYtWoV9u/fD2dnZxw/fhwLFy6UeawbN24gLy8PMTExcHJywpAhQxAVFQVTU1McP35c3mhERERykfvoUBMTE3z++eeoqqoCAHh7e2PAgAH46aefYG9vDxcXF7nG2rNnD+zs7CTLBAIBBAIB6urq5I1GREQkF7lLsI2pqankaycnJzg5Ock9hrGxMV599VWpZV9//TVu3LiB9evXKxoN3bp16n3BJXR0lDMOkay64s9cV8xEzzd1/szJVIJBQUEyDygQCLB//36Fwly+fBmRkZHw9PSEu7u7QmMIhQKYmBgpdF8iTTM2NtR0BCKNU+fzQKYSFIvFMg8oz7p/9s0332Dt2rUYNWoUtm/frtAYACASiVFX16jw/f9MR0fIX0qkVnV199HaKtJ0DCl8HpC6KeN5YGxsKNMepUwlmJ6e3qkwT3Pw4EF8+OGHmDx5MrZs2QI9Pb1OjffwYdf6JUIkq9ZWEX9+Seup83mg8GuCV69eRV5eHm7fvo158+bh5s2bGD58OLp37y7XOIcPH8b777+PwMBAbNiwAQKBQNFIREREcpG7BEUiETZt2oTs7GyIxWIIBAJMnjwZKSkpuHHjBg4dOgRzc3OZxiorK0NsbCwmTZqEpUuXSk7CBwADA4OnflwTERFRZ8h9CE5KSgqOHz+ODz74AHl5eZLXAN955x2IxWLEx8fLPNbXX3+NBw8e4OzZsxg3bpzU5cMPP5Q3GhERkVzk3hPMzs5GWFgYfHx80NraKlk+YsQIhIWFyXVQS2hoKEJDQ+WNQEREpBRy7wlWV1djxIgRHd5mZmbGk9yJiOiZIXcJWllZ4YcffujwtsLCQlhZWXU6FBERkTrIPR06f/58bNq0CQ8ePMBrr70GgUCAGzduoKCgAKmpqYiIiFBFTiIiIqWTuwTnzJmDu3fv4pNPPsGRI0cgFouxevVq6OrqIjg4GH5+fqrISUREpHQKnSe4dOlSBAQEoLi4GDU1NTA2NsYrr7yCXr16KTkeERGR6ihUgiKRCC0tLbC1tYWJiQlPcCciomeSXCV44sQJZGRkoKSkBA8fPgTw6KT2tk+EnzhxokpCEhERqYJMJdja2oo1a9bg9OnTMDMzw9SpU9G3b1+IxWL88ccfKCwsxIoVKzB9+nRs3rxZ1ZmJiIiUQqYSPHz4MM6cOYMNGzZg3rx57aY/W1tbkZGRgdjYWDg5OWH27NkqCUtERKRMMp0nmJOTg7lz5yIwMLDD1/90dHQQEBCAN954A1988YXSQxIREamCTCVYVlaGCRMmPHW98ePH47fffut0KCIiInWQqQTv37+Pnj17PnU9ExMTNDQ0dDoUERGROshUgmKxGDo6Ok8fTChU+JPliYiI1E3u9w4lIiJ6Xsh8nmBMTMxTPzW+vr6+04GIiIjURaYSdHZ2BoCnTnUaGRnBycmp86mIiIjUQKYSTE9PV3UOIiIiteNrgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLU0XoIikQiJiYkYP348HBwcEBISgps3b2o6FhERaQGNl2BKSgoOHz6M999/HxkZGRCJRAgODkZLS4umoxER0XNOoyXY0tKC1NRUhIWFwd3dHcOHD0d8fDz++OMPnDlzRpPRiIhIC2i0BK9cuYKGhga4urpKlhkbG8PGxgY//vijBpMREZE26KbJB//jjz8AAP3795dabmpqKrlNXkKhAL17G3U6GwAIBI/+DV/sgdZWkVLGJOqIjs6jv0d79jSEWKzhMH/R9jx4afZKiEWtmg1DzzWBUAeAcp4HQqFApvU0WoL3798HAOjp6Ukt19fXR21trUJjCgQC6OjItvGy6tndQKnjET2OUKjxl+kfS9fIWNMRSEuo83mg0WecgcGjcvnrQTDNzc0wNDTURCQiItIiGi3BtmnQqqoqqeVVVVUwMzPTRCQiItIiGi3B4cOHo3v37igoKJAsq6urQ2lpKZydnTWYjIiItIFGXxPU09PDvHnzsH37dvTu3RsWFhbYtm0bzM3N4enpqcloRESkBTRaggAQFhaGhw8fYuPGjWhqaoKzszP27t0LXV1dTUcjIqLnnEAs7moHZBMREalH1z0em4iISMVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgkREpLVYgtRpHh4e8PDwQH19fbvbIiIiEBgYqIFURJrDn/tnB0uQlKKiogJbt27VdAwiIrmwBEkpBg0ahMzMTPzjH//QdBQiIpmxBEkpvL294erqig0bNnQ4LUpE1BWxBEkpBAIBPvzwQ9TW1mLLli2ajkNEJBOWICmNhYUFwsPDkZWVhQsXLmg6DhHRU7EESal8fX0xduxYbNy4kdOiRNTlsQRJ6T744AP897//RVxcnKajEBE9EUuQlG7AgAGIiIjA0aNHUVRUpOk4RESPxRIklZgzZw7GjRuHmzdvajoKEdFjsQRJZT744AP06NFD0zGIiB5LIBaLxZoOQUREpAncEyQiIq3FEiQiIq3FEiQiIq3FEiQiIq3FEiQiIq3FEiQiIq3FEiR6jvCMJyL5sASJFBQREQFra+vHXk6fPg0A8PDwQEREBACgvLwc1tbWOHbsmMyPI+t9vv32W4SHhyuc19raGoGBgTLnInoedNN0AKJnWb9+/fDxxx93eNvgwYPbLTM1NUVmZiYsLS2VnmXfvn1PvH358uWYO3eu5HpKSgpKS0ul8nfv3l3puYi6MpYgUSfo6enBwcFBZesrk6WlpVT59u7dW6N5iLoCTocSqVFHU5vFxcUICAiAg4MD3N3dsX//fixYsEAyhdrm9u3bCAsLg6OjI1xcXBAVFYWGhgYAQGBgIAoLC1FYWAhra2sUFBQolO/777+HtbV1uw9FLioqgrW1NS5duoSCggLJOgEBAbC3t4enpycOHz4sdR+RSIQ9e/Zg0qRJGDlyJLy8vJCenq5QLiJVYQkSddLDhw/bXWQ9QOXq1atYsGABAGDnzp1YsWIF9uzZg0uXLrVbNyEhAf3790dKSgrmz5+PrKwsyVRmdHQ0bGxsYGNjg8zMTNja2iq0LePHj4epqSlyc3Ollufk5GDw4MEYPXq0ZNmqVatgY2OD5ORkuLm54d1335UqwpiYGCQmJsLb2xu7du3C5MmTERsbi+TkZIWyEakCp0OJOqGioqLDwlmzZg2WLFny1Pvv3r0bPXr0wGeffQZDQ0MAwNChQ6Veu2vj5eWFyMhIAICrqyvy8vKQn58PABg2bJjk9bzOTG/q6Ohg5syZSE9PR0NDA4yMjNDU1IRTp061255JkyZhw4YNAB6VZ1VVFVJSUuDn54fr168jKysLq1evltxv3LhxEAgE2L17N/z9/WFiYqJwTiJl4Z4gUSf069cPR48ebXeZOXOmTPfPz8/HhAkTJAUIAI6OjrCwsGi3rpOTk9T1gQMHoq6urnMb0AEfHx80Njbi7NmzAICzZ8+isbERM2bMkFrvr9vo6emJ27dvo6ysDPn5+RCLxfDw8JDaQ/bw8EBzc3OHe7pEmsA9QaJO0NPTg52dncL3v3v3Lvr06dNued++fdst+3NRAoBQKFTJeYFWVlZwcXFBTk4OZsyYgZycHLi5ucHMzExqvb9eb9uO2tpa1NTUAACmTp3a4WNUVlYqPTeRIliCRBpkbm6O6urqdsvv3LmDoUOHaiDRIz4+Pli/fj2uXr2KixcvYvv27e3WuXfvntTRpnfu3AHwqAyNjY0BAPv374eRkVG7+w4YMEBFyYnkw+lQIg1ydnbG+fPn0dzcLFlWWlqK8vJyuccSCpX3dPby8oKhoSFiYmJgZGSEiRMntlvnm2++kbp++vRpWFhYwNLSUjJ1e+/ePdjZ2Ukud+/eRUJCgmRPkUjTuCdIpEGhoaE4efIkgoODsWjRItTV1SEhIQFCoRACgUCusYyNjVFcXIyLFy/CxsYGPXv2VDiXoaEhpk6diszMTPj5+UFPT6/dOmlpadDX14eDgwPOnDmD7777Djt27AAAWFtbw9vbG1FRUaioqMDIkSNRVlaG+Ph4DBw4sMM3EiDSBO4JEmmQlZUV9u7di+bmZoSFhSE+Ph4hISHo169fh9OITxIQEABdXV2EhITg3Llznc7m7u4OAJg1a1aHt69fvx4//PADli1bhpKSEiQmJuL111+X3B4XF4eFCxciIyMDwcHB2LVrF6ZMmYLU1FTo6Oh0Oh+RMgjEfMddIo25ePEidHV1pY78rKurg5ubG9atW4egoCCNZYuOjkZJSQlycnKklhcUFCAoKAgHDhzAmDFjNBOOSEk4HUqkQf/85z+RmJiI1atXw9bWFjU1NUhLS0OPHj2k9qrU6cCBA7h27RqysrKwbds2jWQgUheWIJEGLVq0CC0tLThy5Ahu3bqFF154AS4uLoiLi0Pv3r01kqmoqAjnz5/H/PnzNVbEROrC6VAiItJaPDCGiIi0FkuQiIi0FkuQiIi0FkuQiIi0FkuQiIi0FkuQiIi0FkuQiIi0FkuQiIi0FkuQiIi01v8Dj4yQ8unjnOYAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 500x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "flight_type_rate = get_rate_from_column(data, 'TIPOVUELO')\n",
     "flight_type_rate_values = data['TIPOVUELO'].value_counts().index\n",
     "plt.figure(figsize = (5, 2))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(flight_type_rate_values, flight_type_rate['Tasa (%)'])\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=flight_type_rate_values, y=flight_type_rate['Tasa (%)'])\n",
     "plt.title('Delay Rate by Flight Type')\n",
     "plt.ylabel('Delay Rate [%]', fontsize=12)\n",
     "plt.xlabel('Flight Type', fontsize=12)\n",
@@ -484,15 +706,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "period_day_rate = get_rate_from_column(data, 'period_day')\n",
     "period_day_rate_values = data['period_day'].value_counts().index\n",
     "plt.figure(figsize = (5, 2))\n",
-    "sns.set(style=\"darkgrid\")\n",
-    "sns.barplot(period_day_rate_values, period_day_rate['Tasa (%)'])\n",
+    "sns.set_theme(style=\"darkgrid\") # same\n",
+    "sns.barplot(x=period_day_rate_values, y=period_day_rate['Tasa (%)'])\n",
     "plt.title('Delay Rate by Period of Day')\n",
     "plt.ylabel('Delay Rate [%]', fontsize=12)\n",
     "plt.xlabel('Period', fontsize=12)\n",
@@ -518,7 +751,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -529,31 +762,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
+    "# doesn't use this again whatsoever\n",
     "training_data = shuffle(data[['OPERA', 'MES', 'TIPOVUELO', 'SIGLADES', 'DIANOM', 'delay']], random_state = 111)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
-    "features = pd.concat([\n",
-    "    pd.get_dummies(data['OPERA'], prefix = 'OPERA'),\n",
-    "    pd.get_dummies(data['TIPOVUELO'], prefix = 'TIPOVUELO'), \n",
-    "    pd.get_dummies(data['MES'], prefix = 'MES')], \n",
+    "# only uses operator, flight type and month for prediction?\n",
+    "features = pd.concat(\n",
+    "    [\n",
+    "        pd.get_dummies(data['OPERA'], prefix = 'OPERA'),\n",
+    "        pd.get_dummies(data['TIPOVUELO'], prefix = 'TIPOVUELO'), # as it is intrinsically binary, it would make sense to encode it as 0/1, to reduce number of features.\n",
+    "        pd.get_dummies(data['MES'], prefix = 'MES'), # maybe an cyclical encoding would work best for this to reduce number of features.\n",
+    "    ],\n",
     "    axis = 1\n",
     ")\n",
+    "\n",
+    "# this target isn't a probability right? hereon we are predicting whether we expect the flight to be\n",
+    "# delayed more than 15 minutes or not, with no in betweens.\n",
     "target = data['delay']"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -562,27 +802,61 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train shape: (45698, 37) | test shape: (22508, 37)\n"
+     ]
+    }
+   ],
    "source": [
     "print(f\"train shape: {x_train.shape} | test shape: {x_test.shape}\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    81.618452\n",
+       "1    18.381548\n",
+       "Name: delay, dtype: float64"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "y_train.value_counts('%')*100"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    81.277768\n",
+       "1    18.722232\n",
+       "Name: delay, dtype: float64"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "y_test.value_counts('%')*100"
    ]
@@ -605,7 +879,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 105,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -615,9 +889,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-7 {color: black;}#sk-container-id-7 pre{padding: 0;}#sk-container-id-7 div.sk-toggleable {background-color: white;}#sk-container-id-7 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-7 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-7 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-7 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-7 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-7 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-7 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-7 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-7 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-7 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-7 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-7 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-7 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-7 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-7 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-7 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-7 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-7 div.sk-item {position: relative;z-index: 1;}#sk-container-id-7 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-7 div.sk-item::before, #sk-container-id-7 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-7 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-7 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-7 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-7 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-7 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-7 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-7 div.sk-label-container {text-align: center;}#sk-container-id-7 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-7 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-7\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-7\" type=\"checkbox\" checked><label for=\"sk-estimator-id-7\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">XGBClassifier</label><div class=\"sk-toggleable__content\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)"
+      ]
+     },
+     "execution_count": 106,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "xgb_model = xgb.XGBClassifier(random_state=1, learning_rate=0.01)\n",
     "xgb_model.fit(x_train, y_train)"
@@ -625,28 +943,58 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [],
    "source": [
     "xgboost_y_preds = xgb_model.predict(x_test)\n",
+    "# would parametrized threshold here and onwards. Does not predict probability yet though.\n",
+    "# also, as it is a classification model, this threshold is unnecessary.\n",
     "xgboost_y_preds = [1 if y_pred > 0.5 else 0 for y_pred in xgboost_y_preds]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[18294,     0],\n",
+       "       [ 4214,     0]])"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "confusion_matrix(y_test, xgboost_y_preds)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.81      1.00      0.90     18294\n",
+      "           1       0.00      0.00      0.00      4214\n",
+      "\n",
+      "    accuracy                           0.81     22508\n",
+      "   macro avg       0.41      0.50      0.45     22508\n",
+      "weighted avg       0.66      0.81      0.73     22508\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "print(classification_report(y_test, xgboost_y_preds))"
    ]
@@ -660,7 +1008,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 111,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -669,9 +1017,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-8 {color: black;}#sk-container-id-8 pre{padding: 0;}#sk-container-id-8 div.sk-toggleable {background-color: white;}#sk-container-id-8 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-8 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-8 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-8 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-8 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-8 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-8 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-8 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-8 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-8 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-8 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-8 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-8 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-8 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-8 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-8 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-8 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-8 div.sk-item {position: relative;z-index: 1;}#sk-container-id-8 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-8 div.sk-item::before, #sk-container-id-8 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-8 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-8 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-8 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-8 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-8 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-8 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-8 div.sk-label-container {text-align: center;}#sk-container-id-8 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-8 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-8\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LogisticRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-8\" type=\"checkbox\" checked><label for=\"sk-estimator-id-8\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression()</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "LogisticRegression()"
+      ]
+     },
+     "execution_count": 112,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "reg_model = LogisticRegression()\n",
     "reg_model.fit(x_train, y_train)"
@@ -679,7 +1041,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 113,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -688,18 +1050,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[18193,   101],\n",
+       "       [ 4086,   128]])"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "confusion_matrix(y_test, reg_y_preds)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.82      0.99      0.90     18294\n",
+      "           1       0.56      0.03      0.06      4214\n",
+      "\n",
+      "    accuracy                           0.81     22508\n",
+      "   macro avg       0.69      0.51      0.48     22508\n",
+      "weighted avg       0.77      0.81      0.74     22508\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "print(classification_report(y_test, reg_y_preds))"
    ]
@@ -722,9 +1112,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Feature importance'}, xlabel='F score', ylabel='Features'>"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1000x500 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.figure(figsize = (10,5))\n",
     "plot_importance(xgb_model)"
@@ -732,12 +1152,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 52,
    "metadata": {},
    "outputs": [],
    "source": [
     "top_10_features = [\n",
-    "    \"OPERA_Latin American Wings\", \n",
+    "    \"OPERA_Latin American Wings\",\n",
     "    \"MES_7\",\n",
     "    \"MES_10\",\n",
     "    \"OPERA_Grupo LATAM\",\n",
@@ -760,9 +1180,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4.4402380952380955\n"
+     ]
+    }
+   ],
    "source": [
     "n_y0 = len(y_train[y_train == 0])\n",
     "n_y1 = len(y_train[y_train == 1])\n",
@@ -788,7 +1216,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 54,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -813,9 +1241,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-3 {color: black;}#sk-container-id-3 pre{padding: 0;}#sk-container-id-3 div.sk-toggleable {background-color: white;}#sk-container-id-3 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-3 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-3 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-3 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-3 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-3 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-3 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-3 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-3 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-3 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-3 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-3 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-3 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-3 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-3 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-3 div.sk-item {position: relative;z-index: 1;}#sk-container-id-3 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-3 div.sk-item::before, #sk-container-id-3 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-3 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-3 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-3 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-3 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-3 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-3 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-3 div.sk-label-container {text-align: center;}#sk-container-id-3 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-3 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-3\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" checked><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">XGBClassifier</label><div class=\"sk-toggleable__content\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "xgb_model_2 = xgb.XGBClassifier(random_state=1, learning_rate=0.01, scale_pos_weight = scale)\n",
     "xgb_model_2.fit(x_train2, y_train2)"
@@ -823,7 +1295,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -832,18 +1304,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[9556, 8738],\n",
+       "       [1313, 2901]])"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "confusion_matrix(y_test2, xgboost_y_preds_2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.88      0.52      0.66     18294\n",
+      "           1       0.25      0.69      0.37      4214\n",
+      "\n",
+      "    accuracy                           0.55     22508\n",
+      "   macro avg       0.56      0.61      0.51     22508\n",
+      "weighted avg       0.76      0.55      0.60     22508\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "print(classification_report(y_test2, xgboost_y_preds_2))"
    ]
@@ -858,9 +1358,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-4 {color: black;}#sk-container-id-4 pre{padding: 0;}#sk-container-id-4 div.sk-toggleable {background-color: white;}#sk-container-id-4 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-4 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-4 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-4 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-4 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-4 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-4 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-4 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-4 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-4 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-4 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-4 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-4 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-4 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-4 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-4 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-4 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-4 div.sk-item {position: relative;z-index: 1;}#sk-container-id-4 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-4 div.sk-item::before, #sk-container-id-4 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-4 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-4 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-4 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-4 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-4 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-4 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-4 div.sk-label-container {text-align: center;}#sk-container-id-4 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-4 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-4\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" checked><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">XGBClassifier</label><div class=\"sk-toggleable__content\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=0.01, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=1, ...)"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "xgb_model_3 = xgb.XGBClassifier(random_state=1, learning_rate=0.01)\n",
     "xgb_model_3.fit(x_train2, y_train2)"
@@ -868,7 +1412,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -877,18 +1421,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[18286,     8],\n",
+       "       [ 4188,    26]])"
+      ]
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "confusion_matrix(y_test2, xgboost_y_preds_3)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.81      1.00      0.90     18294\n",
+      "           1       0.76      0.01      0.01      4214\n",
+      "\n",
+      "    accuracy                           0.81     22508\n",
+      "   macro avg       0.79      0.50      0.45     22508\n",
+      "weighted avg       0.80      0.81      0.73     22508\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "print(classification_report(y_test2, xgboost_y_preds_3))"
    ]
@@ -903,9 +1475,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-5 {color: black;}#sk-container-id-5 pre{padding: 0;}#sk-container-id-5 div.sk-toggleable {background-color: white;}#sk-container-id-5 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-5 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-5 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-5 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-5 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-5 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-5 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-5 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-5 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-5 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-5 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-5 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-5 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-5 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-5 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-5 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-5 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-5 div.sk-item {position: relative;z-index: 1;}#sk-container-id-5 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-5 div.sk-item::before, #sk-container-id-5 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-5 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-5 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-5 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-5 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-5 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-5 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-5 div.sk-label-container {text-align: center;}#sk-container-id-5 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-5 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-5\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LogisticRegression(class_weight={0: 0.18381548426626987, 1: 0.8161845157337302})</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" checked><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(class_weight={0: 0.18381548426626987, 1: 0.8161845157337302})</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "LogisticRegression(class_weight={0: 0.18381548426626987, 1: 0.8161845157337302})"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "reg_model_2 = LogisticRegression(class_weight={1: n_y0/len(y_train), 0: n_y1/len(y_train)})\n",
     "reg_model_2.fit(x_train2, y_train2)"
@@ -913,7 +1499,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -922,18 +1508,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[9487, 8807],\n",
+       "       [1314, 2900]])"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "confusion_matrix(y_test2, reg_y_preds_2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.88      0.52      0.65     18294\n",
+      "           1       0.25      0.69      0.36      4214\n",
+      "\n",
+      "    accuracy                           0.55     22508\n",
+      "   macro avg       0.56      0.60      0.51     22508\n",
+      "weighted avg       0.76      0.55      0.60     22508\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "print(classification_report(y_test2, reg_y_preds_2))"
    ]
@@ -948,9 +1562,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-6 {color: black;}#sk-container-id-6 pre{padding: 0;}#sk-container-id-6 div.sk-toggleable {background-color: white;}#sk-container-id-6 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-6 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-6 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-6 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-6 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-6 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-6 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-6 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-6 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-6 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-6 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-6 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-6 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-6 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-6 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-6 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-6 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-6 div.sk-item {position: relative;z-index: 1;}#sk-container-id-6 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-6 div.sk-item::before, #sk-container-id-6 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-6 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-6 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-6 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-6 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-6 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-6 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-6 div.sk-label-container {text-align: center;}#sk-container-id-6 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-6 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-6\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LogisticRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" checked><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression()</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "LogisticRegression()"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "reg_model_3 = LogisticRegression()\n",
     "reg_model_3.fit(x_train2, y_train2)"
@@ -958,7 +1586,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -967,18 +1595,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[18246,    48],\n",
+       "       [ 4160,    54]])"
+      ]
+     },
+     "execution_count": 69,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "confusion_matrix(y_test2, reg_y_preds_3)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.81      1.00      0.90     18294\n",
+      "           1       0.53      0.01      0.03      4214\n",
+      "\n",
+      "    accuracy                           0.81     22508\n",
+      "   macro avg       0.67      0.51      0.46     22508\n",
+      "weighted avg       0.76      0.81      0.73     22508\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "print(classification_report(y_test2, reg_y_preds_3))"
    ]
@@ -1027,7 +1683,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.10.8"
   },
   "orig_nbformat": 4
  },
diff --git a/challenge/model.py b/challenge/model.py
index 173ac6c..5358195 100644
--- a/challenge/model.py
+++ b/challenge/model.py
@@ -1,19 +1,70 @@
+import os
+import pickle
+from datetime import datetime
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
 import pandas as pd
+from sklearn.linear_model import LogisticRegression
 
-from typing import Tuple, Union, List
+FEATURES_COLS = [
+    "OPERA_Latin American Wings",
+    "MES_7",
+    "MES_10",
+    "OPERA_Grupo LATAM",
+    "MES_12",
+    "TIPOVUELO_I",
+    "MES_4",
+    "MES_11",
+    "OPERA_Sky Airline",
+    "OPERA_Copa Air",
+]
 
-class DelayModel:
 
-    def __init__(
-        self
-    ):
-        self._model = None # Model should be saved in this attribute.
+def get_min_diff(data):
+    fecha_o = datetime.strptime(data["Fecha-O"], "%Y-%m-%d %H:%M:%S")
+    fecha_i = datetime.strptime(data["Fecha-I"], "%Y-%m-%d %H:%M:%S")
+    min_diff = ((fecha_o - fecha_i).total_seconds()) / 60
+    return min_diff
+
+
+def get_delay_target(data: pd.DataFrame) -> pd.Series:
+    data["min_diff"] = data.apply(get_min_diff, axis=1)
+    threshold_in_minutes = 15
+    data["delay"] = np.where(data["min_diff"] > threshold_in_minutes, 1, 0)
+
+    return data["delay"].to_frame()
+
+
+def get_features(data: pd.DataFrame) -> pd.DataFrame:
+    # get the one hot enconding of the columns suggested by the DS
+    features = pd.concat(
+        [
+            pd.get_dummies(data["OPERA"], prefix="OPERA"),
+            pd.get_dummies(data["TIPOVUELO"], prefix="TIPOVUELO"),
+            pd.get_dummies(data["MES"], prefix="MES"),
+        ],
+        axis=1,
+    )
+    present_features = list(set(FEATURES_COLS).intersection(set(features.columns)))
+    missing_features = list(set(FEATURES_COLS).difference(set(features.columns)))
+
+    features = features[present_features]
+
+    # fill missing features with 0 due to one-hot encoding of features
+    for feature in missing_features:
+        features[feature] = 0
+
+    return features
+
+
+class DelayModel:
+    def __init__(self):
+        self._model = LogisticRegression()
 
     def preprocess(
-        self,
-        data: pd.DataFrame,
-        target_column: str = None
-    ) -> Union(Tuple[pd.DataFrame, pd.DataFrame], pd.DataFrame):
+        self, data: pd.DataFrame, target_column: Optional[str] = None
+    ) -> Union[Tuple[pd.DataFrame, pd.Series], pd.DataFrame]:
         """
         Prepare raw data for training or predict.
 
@@ -26,13 +77,19 @@ def preprocess(
             or
             pd.DataFrame: features.
         """
-        return
+        # retrieve features from the data
+        x = get_features(data)
 
-    def fit(
-        self,
-        features: pd.DataFrame,
-        target: pd.DataFrame
-    ) -> None:
+        # return different sets, depending on the target
+        if target_column is None:
+            return x
+        elif target_column == "delay":
+            y = get_delay_target(data)
+            return (x, y)
+        else:
+            raise NotImplementedError("Only implemented 'delay' as target column")
+
+    def fit(self, features: pd.DataFrame, target: pd.DataFrame) -> None:
         """
         Fit model with preprocessed data.
 
@@ -40,19 +97,87 @@ def fit(
             features (pd.DataFrame): preprocessed data.
             target (pd.DataFrame): target.
         """
-        return
+        # target is assume to only have one column (uni-dimensional target)
+        target_column = target.columns[0]
+
+        # get values to compensate unbalancing
+        n_y0 = len(target[target[target_column] == 0])
+        n_y1 = len(target[target[target_column] == 1])
 
-    def predict(
-        self,
-        features: pd.DataFrame
-    ) -> List[int]:
+        # instantiate model and fit
+        self._model = LogisticRegression(
+            class_weight={1: n_y0 / len(target), 0: n_y1 / len(target)}
+        )
+        self._model.fit(features, target[target_column])
+
+        # for scikitlearn compatibility
+        return self
+
+    def save_model(self, path: str):
+        """
+        Store trained model in given path
+        """
+        os.makedirs(path, exist_ok=True)
+        with open(f"{path}/model.pkl", "wb") as f:
+            pickle.dump(self._model, f)
+
+    def load_model(self, path: str):
+        """
+        Load trained model from given path
+        """
+        with open(f"{path}/model.pkl", "rb") as f:
+            self._model = pickle.load(f)
+
+    def predict(self, features: pd.DataFrame) -> List[int]:
         """
         Predict delays for new flights.
 
         Args:
             features (pd.DataFrame): preprocessed data.
-        
+
         Returns:
             (List[int]): predicted targets.
         """
-        return
\ No newline at end of file
+        try:
+            pred = self._model.predict(features).tolist()
+        except Exception as e:
+            raise e
+
+        return pred
+
+
+if __name__ == "__main__":
+    from sklearn.metrics import classification_report, mean_squared_error
+    from sklearn.model_selection import train_test_split
+
+    # perform a training of the model for production deployment
+    model = DelayModel()
+    data = pd.read_csv(filepath_or_buffer="data/data.csv")
+
+    features, target = model.preprocess(data=data, target_column="delay")
+
+    _, features_validation, _, target_validation = train_test_split(
+        features, target, test_size=0.33, random_state=42
+    )
+
+    model.fit(features=features, target=target)
+
+    predicted_target = model.predict(features_validation)
+
+    report = classification_report(
+        target_validation, predicted_target, output_dict=True
+    )
+
+    # save
+    model.save_model("models")
+
+    # re instantiate to override model
+    model = DelayModel()
+    model.load_model("models")
+
+    predicted_target_load = model.predict(features_validation)
+
+    print(
+        "The difference in prediction is:"
+        f" {mean_squared_error(predicted_target, predicted_target_load)}"
+    )
diff --git a/docs/challenge.md b/docs/challenge.md
index e69de29..73ad61c 100644
--- a/docs/challenge.md
+++ b/docs/challenge.md
@@ -0,0 +1,64 @@
+# Challange Notes
+
+## Reviewing the notebook
+
+### Generalities
+
+In the documentation (README) it is said that the data has a column named
+DATA-I when talking about the additional DS features, but this column does not
+exist. Instead, from the code and the description, we can assume this column
+name should be FECHA-I.
+
+### Feedback to the DS
+
+I would like to ask a few things to the DS as it seems unclear why he did some
+of the selections he did. I am supposing this is a kind of summary notebook, so
+some details may have been missed in the condensation of his/her analysis.
+
+1. I see that at the data splitting step, you decided to keep just three
+features. Why keep these features specifically? It seems to me that other
+features, as the destination, may encode some information on the delay process;
+but maybe I am missing something.
+2. On the target encoding, I understood that we wanted to predict the
+probability of a delay on a specific flight. Your encoding just predicts whether
+the flight would be more than 15 minutes delayed or not. Have you came up with
+this threshold from a business perspective, or it was it from some modelling
+reason? Have you tried to predict a continuous variable, as delay time, or prob
+to be delayed? I know I can get the probabilities from the models, but asking
+if you performed an evaluation on them.
+3. I would say it's unfair to compare the initial xgboost and linear regression
+feature-wise, given their poor initial performance, and the great increase in
+performance that happened only by addressing the dataset unbalance. May need a
+revision on feature analysis after the balancing or a better exlpanation of
+this decision.
+4. The 10 features you selected to train with, are not the top 10 I am seeing in
+the graph of feature importance from the xgboost. I think it might be due to
+some random see issue. Would you care to go over it?
+
+Also pointed out some comments in the code, but wouldn't bother the DS with
+them, as it was not the main focus of the work.
+
+
+### How to continue
+
+I will proceed by moving the pipeline the DS implemented here as similar as
+possible to the production pipeline, as this is the best predictions we have
+yet. Though, I will also try to make it as versatile as possible in the feature
+selection stage, that I think was the one that may need a revision from his
+side; though, without compromising the time-to-production of the system.
+
+#### On the model selection
+The final model might be modified if another stage of experimenting would be
+done by the DS but, as both linear regression and xgboost support the same
+interface for prediction, it shouldn't be that much of an issue to change it
+afterwards if implemented appropriately.
+
+I will go with the linear regression, as it's execution time is determined only
+by the number of features, and not on a highly tunned hyperparameter (as the
+number of trees in xgboost). Also, it has the advantage that we can limit
+ourselves to only one framework (scikit learn), and have less imcompatibility
+issues when trying to move our model to production.
+
+## deployment
+
+application deployed to:  https://delay-model-api-qzo5moezqa-uw.a.run.app
\ No newline at end of file
diff --git a/poetry.lock b/poetry.lock
new file mode 100644
index 0000000..6deb3aa
--- /dev/null
+++ b/poetry.lock
@@ -0,0 +1,3242 @@
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
+
+[[package]]
+name = "anyio"
+version = "4.4.0"
+description = "High level compatibility layer for multiple asynchronous event loop implementations"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"},
+    {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"},
+]
+
+[package.dependencies]
+exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""}
+idna = ">=2.8"
+sniffio = ">=1.1"
+typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""}
+
+[package.extras]
+doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"]
+test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"]
+trio = ["trio (>=0.23)"]
+
+[[package]]
+name = "appnope"
+version = "0.1.4"
+description = "Disable App Nap on macOS >= 10.9"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"},
+    {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"},
+]
+
+[[package]]
+name = "asgiref"
+version = "3.8.1"
+description = "ASGI specs, helper code, and adapters"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "asgiref-3.8.1-py3-none-any.whl", hash = "sha256:3e1e3ecc849832fe52ccf2cb6686b7a55f82bb1d6aee72a58826471390335e47"},
+    {file = "asgiref-3.8.1.tar.gz", hash = "sha256:c343bd80a0bec947a9860adb4c432ffa7db769836c64238fc34bdc3fec84d590"},
+]
+
+[package.dependencies]
+typing-extensions = {version = ">=4", markers = "python_version < \"3.11\""}
+
+[package.extras]
+tests = ["mypy (>=0.800)", "pytest", "pytest-asyncio"]
+
+[[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 = "atomicwrites"
+version = "1.4.1"
+description = "Atomic file writes."
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "atomicwrites-1.4.1.tar.gz", hash = "sha256:81b2c9071a49367a7f770170e5eec8cb66567cfbbc8c73d20ce5ca4a8d71cf11"},
+]
+
+[[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 = "black"
+version = "23.3.0"
+description = "The uncompromising code formatter."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "black-23.3.0-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:0945e13506be58bf7db93ee5853243eb368ace1c08a24c65ce108986eac65915"},
+    {file = "black-23.3.0-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:67de8d0c209eb5b330cce2469503de11bca4085880d62f1628bd9972cc3366b9"},
+    {file = "black-23.3.0-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:7c3eb7cea23904399866c55826b31c1f55bbcd3890ce22ff70466b907b6775c2"},
+    {file = "black-23.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32daa9783106c28815d05b724238e30718f34155653d4d6e125dc7daec8e260c"},
+    {file = "black-23.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:35d1381d7a22cc5b2be2f72c7dfdae4072a3336060635718cc7e1ede24221d6c"},
+    {file = "black-23.3.0-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:a8a968125d0a6a404842fa1bf0b349a568634f856aa08ffaff40ae0dfa52e7c6"},
+    {file = "black-23.3.0-cp311-cp311-macosx_10_16_universal2.whl", hash = "sha256:c7ab5790333c448903c4b721b59c0d80b11fe5e9803d8703e84dcb8da56fec1b"},
+    {file = "black-23.3.0-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:a6f6886c9869d4daae2d1715ce34a19bbc4b95006d20ed785ca00fa03cba312d"},
+    {file = "black-23.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f3c333ea1dd6771b2d3777482429864f8e258899f6ff05826c3a4fcc5ce3f70"},
+    {file = "black-23.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:11c410f71b876f961d1de77b9699ad19f939094c3a677323f43d7a29855fe326"},
+    {file = "black-23.3.0-cp37-cp37m-macosx_10_16_x86_64.whl", hash = "sha256:1d06691f1eb8de91cd1b322f21e3bfc9efe0c7ca1f0e1eb1db44ea367dff656b"},
+    {file = "black-23.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50cb33cac881766a5cd9913e10ff75b1e8eb71babf4c7104f2e9c52da1fb7de2"},
+    {file = "black-23.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:e114420bf26b90d4b9daa597351337762b63039752bdf72bf361364c1aa05925"},
+    {file = "black-23.3.0-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:48f9d345675bb7fbc3dd85821b12487e1b9a75242028adad0333ce36ed2a6d27"},
+    {file = "black-23.3.0-cp38-cp38-macosx_10_16_universal2.whl", hash = "sha256:714290490c18fb0126baa0fca0a54ee795f7502b44177e1ce7624ba1c00f2331"},
+    {file = "black-23.3.0-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:064101748afa12ad2291c2b91c960be28b817c0c7eaa35bec09cc63aa56493c5"},
+    {file = "black-23.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:562bd3a70495facf56814293149e51aa1be9931567474993c7942ff7d3533961"},
+    {file = "black-23.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:e198cf27888ad6f4ff331ca1c48ffc038848ea9f031a3b40ba36aced7e22f2c8"},
+    {file = "black-23.3.0-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:3238f2aacf827d18d26db07524e44741233ae09a584273aa059066d644ca7b30"},
+    {file = "black-23.3.0-cp39-cp39-macosx_10_16_universal2.whl", hash = "sha256:f0bd2f4a58d6666500542b26354978218a9babcdc972722f4bf90779524515f3"},
+    {file = "black-23.3.0-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:92c543f6854c28a3c7f39f4d9b7694f9a6eb9d3c5e2ece488c327b6e7ea9b266"},
+    {file = "black-23.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a150542a204124ed00683f0db1f5cf1c2aaaa9cc3495b7a3b5976fb136090ab"},
+    {file = "black-23.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:6b39abdfb402002b8a7d030ccc85cf5afff64ee90fa4c5aebc531e3ad0175ddb"},
+    {file = "black-23.3.0-py3-none-any.whl", hash = "sha256:ec751418022185b0c1bb7d7736e6933d40bbb14c14a0abcf9123d1b159f98dd4"},
+    {file = "black-23.3.0.tar.gz", hash = "sha256:1c7b8d606e728a41ea1ccbd7264677e494e87cf630e399262ced92d4a8dac940"},
+]
+
+[package.dependencies]
+click = ">=8.0.0"
+mypy-extensions = ">=0.4.3"
+packaging = ">=22.0"
+pathspec = ">=0.9.0"
+platformdirs = ">=2"
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+
+[package.extras]
+colorama = ["colorama (>=0.4.3)"]
+d = ["aiohttp (>=3.7.4)"]
+jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
+uvloop = ["uvloop (>=0.15.2)"]
+
+[[package]]
+name = "blinker"
+version = "1.8.2"
+description = "Fast, simple object-to-object and broadcast signaling"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "blinker-1.8.2-py3-none-any.whl", hash = "sha256:1779309f71bf239144b9399d06ae925637cf6634cf6bd131104184531bf67c01"},
+    {file = "blinker-1.8.2.tar.gz", hash = "sha256:8f77b09d3bf7c795e969e9486f39c2c5e9c39d4ee07424be2bc594ece9642d83"},
+]
+
+[[package]]
+name = "brotli"
+version = "1.1.0"
+description = "Python bindings for the Brotli compression library"
+optional = false
+python-versions = "*"
+files = [
+    {file = "Brotli-1.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e1140c64812cb9b06c922e77f1c26a75ec5e3f0fb2bf92cc8c58720dec276752"},
+    {file = "Brotli-1.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c8fd5270e906eef71d4a8d19b7c6a43760c6abcfcc10c9101d14eb2357418de9"},
+    {file = "Brotli-1.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ae56aca0402a0f9a3431cddda62ad71666ca9d4dc3a10a142b9dce2e3c0cda3"},
+    {file = "Brotli-1.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:43ce1b9935bfa1ede40028054d7f48b5469cd02733a365eec8a329ffd342915d"},
+    {file = "Brotli-1.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:7c4855522edb2e6ae7fdb58e07c3ba9111e7621a8956f481c68d5d979c93032e"},
+    {file = "Brotli-1.1.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:38025d9f30cf4634f8309c6874ef871b841eb3c347e90b0851f63d1ded5212da"},
+    {file = "Brotli-1.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e6a904cb26bfefc2f0a6f240bdf5233be78cd2488900a2f846f3c3ac8489ab80"},
+    {file = "Brotli-1.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:a37b8f0391212d29b3a91a799c8e4a2855e0576911cdfb2515487e30e322253d"},
+    {file = "Brotli-1.1.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e84799f09591700a4154154cab9787452925578841a94321d5ee8fb9a9a328f0"},
+    {file = "Brotli-1.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f66b5337fa213f1da0d9000bc8dc0cb5b896b726eefd9c6046f699b169c41b9e"},
+    {file = "Brotli-1.1.0-cp310-cp310-win32.whl", hash = "sha256:be36e3d172dc816333f33520154d708a2657ea63762ec16b62ece02ab5e4daf2"},
+    {file = "Brotli-1.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:0c6244521dda65ea562d5a69b9a26120769b7a9fb3db2fe9545935ed6735b128"},
+    {file = "Brotli-1.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a3daabb76a78f829cafc365531c972016e4aa8d5b4bf60660ad8ecee19df7ccc"},
+    {file = "Brotli-1.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c8146669223164fc87a7e3de9f81e9423c67a79d6b3447994dfb9c95da16e2d6"},
+    {file = "Brotli-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30924eb4c57903d5a7526b08ef4a584acc22ab1ffa085faceb521521d2de32dd"},
+    {file = "Brotli-1.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ceb64bbc6eac5a140ca649003756940f8d6a7c444a68af170b3187623b43bebf"},
+    {file = "Brotli-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a469274ad18dc0e4d316eefa616d1d0c2ff9da369af19fa6f3daa4f09671fd61"},
+    {file = "Brotli-1.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:524f35912131cc2cabb00edfd8d573b07f2d9f21fa824bd3fb19725a9cf06327"},
+    {file = "Brotli-1.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5b3cc074004d968722f51e550b41a27be656ec48f8afaeeb45ebf65b561481dd"},
+    {file = "Brotli-1.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:19c116e796420b0cee3da1ccec3b764ed2952ccfcc298b55a10e5610ad7885f9"},
+    {file = "Brotli-1.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:510b5b1bfbe20e1a7b3baf5fed9e9451873559a976c1a78eebaa3b86c57b4265"},
+    {file = "Brotli-1.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a1fd8a29719ccce974d523580987b7f8229aeace506952fa9ce1d53a033873c8"},
+    {file = "Brotli-1.1.0-cp311-cp311-win32.whl", hash = "sha256:39da8adedf6942d76dc3e46653e52df937a3c4d6d18fdc94a7c29d263b1f5b50"},
+    {file = "Brotli-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:aac0411d20e345dc0920bdec5548e438e999ff68d77564d5e9463a7ca9d3e7b1"},
+    {file = "Brotli-1.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:316cc9b17edf613ac76b1f1f305d2a748f1b976b033b049a6ecdfd5612c70409"},
+    {file = "Brotli-1.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:caf9ee9a5775f3111642d33b86237b05808dafcd6268faa492250e9b78046eb2"},
+    {file = "Brotli-1.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70051525001750221daa10907c77830bc889cb6d865cc0b813d9db7fefc21451"},
+    {file = "Brotli-1.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f4bf76817c14aa98cc6697ac02f3972cb8c3da93e9ef16b9c66573a68014f91"},
+    {file = "Brotli-1.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0c5516f0aed654134a2fc936325cc2e642f8a0e096d075209672eb321cff408"},
+    {file = "Brotli-1.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c3020404e0b5eefd7c9485ccf8393cfb75ec38ce75586e046573c9dc29967a0"},
+    {file = "Brotli-1.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4ed11165dd45ce798d99a136808a794a748d5dc38511303239d4e2363c0695dc"},
+    {file = "Brotli-1.1.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:4093c631e96fdd49e0377a9c167bfd75b6d0bad2ace734c6eb20b348bc3ea180"},
+    {file = "Brotli-1.1.0-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e4c4629ddad63006efa0ef968c8e4751c5868ff0b1c5c40f76524e894c50248"},
+    {file = "Brotli-1.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:861bf317735688269936f755fa136a99d1ed526883859f86e41a5d43c61d8966"},
+    {file = "Brotli-1.1.0-cp312-cp312-win32.whl", hash = "sha256:5f4d5ea15c9382135076d2fb28dde923352fe02951e66935a9efaac8f10e81b0"},
+    {file = "Brotli-1.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:906bc3a79de8c4ae5b86d3d75a8b77e44404b0f4261714306e3ad248d8ab0951"},
+    {file = "Brotli-1.1.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:a090ca607cbb6a34b0391776f0cb48062081f5f60ddcce5d11838e67a01928d1"},
+    {file = "Brotli-1.1.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2de9d02f5bda03d27ede52e8cfe7b865b066fa49258cbab568720aa5be80a47d"},
+    {file = "Brotli-1.1.0-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2333e30a5e00fe0fe55903c8832e08ee9c3b1382aacf4db26664a16528d51b4b"},
+    {file = "Brotli-1.1.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4d4a848d1837973bf0f4b5e54e3bec977d99be36a7895c61abb659301b02c112"},
+    {file = "Brotli-1.1.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:fdc3ff3bfccdc6b9cc7c342c03aa2400683f0cb891d46e94b64a197910dc4064"},
+    {file = "Brotli-1.1.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:5eeb539606f18a0b232d4ba45adccde4125592f3f636a6182b4a8a436548b914"},
+    {file = "Brotli-1.1.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:fd5f17ff8f14003595ab414e45fce13d073e0762394f957182e69035c9f3d7c2"},
+    {file = "Brotli-1.1.0-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:069a121ac97412d1fe506da790b3e69f52254b9df4eb665cd42460c837193354"},
+    {file = "Brotli-1.1.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:e93dfc1a1165e385cc8239fab7c036fb2cd8093728cbd85097b284d7b99249a2"},
+    {file = "Brotli-1.1.0-cp36-cp36m-win32.whl", hash = "sha256:a599669fd7c47233438a56936988a2478685e74854088ef5293802123b5b2460"},
+    {file = "Brotli-1.1.0-cp36-cp36m-win_amd64.whl", hash = "sha256:d143fd47fad1db3d7c27a1b1d66162e855b5d50a89666af46e1679c496e8e579"},
+    {file = "Brotli-1.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:11d00ed0a83fa22d29bc6b64ef636c4552ebafcef57154b4ddd132f5638fbd1c"},
+    {file = "Brotli-1.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f733d788519c7e3e71f0855c96618720f5d3d60c3cb829d8bbb722dddce37985"},
+    {file = "Brotli-1.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:929811df5462e182b13920da56c6e0284af407d1de637d8e536c5cd00a7daf60"},
+    {file = "Brotli-1.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0b63b949ff929fbc2d6d3ce0e924c9b93c9785d877a21a1b678877ffbbc4423a"},
+    {file = "Brotli-1.1.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d192f0f30804e55db0d0e0a35d83a9fead0e9a359a9ed0285dbacea60cc10a84"},
+    {file = "Brotli-1.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:f296c40e23065d0d6650c4aefe7470d2a25fffda489bcc3eb66083f3ac9f6643"},
+    {file = "Brotli-1.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:919e32f147ae93a09fe064d77d5ebf4e35502a8df75c29fb05788528e330fe74"},
+    {file = "Brotli-1.1.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:23032ae55523cc7bccb4f6a0bf368cd25ad9bcdcc1990b64a647e7bbcce9cb5b"},
+    {file = "Brotli-1.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:224e57f6eac61cc449f498cc5f0e1725ba2071a3d4f48d5d9dffba42db196438"},
+    {file = "Brotli-1.1.0-cp37-cp37m-win32.whl", hash = "sha256:587ca6d3cef6e4e868102672d3bd9dc9698c309ba56d41c2b9c85bbb903cdb95"},
+    {file = "Brotli-1.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:2954c1c23f81c2eaf0b0717d9380bd348578a94161a65b3a2afc62c86467dd68"},
+    {file = "Brotli-1.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:efa8b278894b14d6da122a72fefcebc28445f2d3f880ac59d46c90f4c13be9a3"},
+    {file = "Brotli-1.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:03d20af184290887bdea3f0f78c4f737d126c74dc2f3ccadf07e54ceca3bf208"},
+    {file = "Brotli-1.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6172447e1b368dcbc458925e5ddaf9113477b0ed542df258d84fa28fc45ceea7"},
+    {file = "Brotli-1.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a743e5a28af5f70f9c080380a5f908d4d21d40e8f0e0c8901604d15cfa9ba751"},
+    {file = "Brotli-1.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0541e747cce78e24ea12d69176f6a7ddb690e62c425e01d31cc065e69ce55b48"},
+    {file = "Brotli-1.1.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:cdbc1fc1bc0bff1cef838eafe581b55bfbffaed4ed0318b724d0b71d4d377619"},
+    {file = "Brotli-1.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:890b5a14ce214389b2cc36ce82f3093f96f4cc730c1cffdbefff77a7c71f2a97"},
+    {file = "Brotli-1.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1ab4fbee0b2d9098c74f3057b2bc055a8bd92ccf02f65944a241b4349229185a"},
+    {file = "Brotli-1.1.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:141bd4d93984070e097521ed07e2575b46f817d08f9fa42b16b9b5f27b5ac088"},
+    {file = "Brotli-1.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:fce1473f3ccc4187f75b4690cfc922628aed4d3dd013d047f95a9b3919a86596"},
+    {file = "Brotli-1.1.0-cp38-cp38-win32.whl", hash = "sha256:db85ecf4e609a48f4b29055f1e144231b90edc90af7481aa731ba2d059226b1b"},
+    {file = "Brotli-1.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:3d7954194c36e304e1523f55d7042c59dc53ec20dd4e9ea9d151f1b62b4415c0"},
+    {file = "Brotli-1.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5fb2ce4b8045c78ebbc7b8f3c15062e435d47e7393cc57c25115cfd49883747a"},
+    {file = "Brotli-1.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7905193081db9bfa73b1219140b3d315831cbff0d8941f22da695832f0dd188f"},
+    {file = "Brotli-1.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a77def80806c421b4b0af06f45d65a136e7ac0bdca3c09d9e2ea4e515367c7e9"},
+    {file = "Brotli-1.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8dadd1314583ec0bf2d1379f7008ad627cd6336625d6679cf2f8e67081b83acf"},
+    {file = "Brotli-1.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:901032ff242d479a0efa956d853d16875d42157f98951c0230f69e69f9c09bac"},
+    {file = "Brotli-1.1.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:22fc2a8549ffe699bfba2256ab2ed0421a7b8fadff114a3d201794e45a9ff578"},
+    {file = "Brotli-1.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ae15b066e5ad21366600ebec29a7ccbc86812ed267e4b28e860b8ca16a2bc474"},
+    {file = "Brotli-1.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:949f3b7c29912693cee0afcf09acd6ebc04c57af949d9bf77d6101ebb61e388c"},
+    {file = "Brotli-1.1.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:89f4988c7203739d48c6f806f1e87a1d96e0806d44f0fba61dba81392c9e474d"},
+    {file = "Brotli-1.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:de6551e370ef19f8de1807d0a9aa2cdfdce2e85ce88b122fe9f6b2b076837e59"},
+    {file = "Brotli-1.1.0-cp39-cp39-win32.whl", hash = "sha256:f0d8a7a6b5983c2496e364b969f0e526647a06b075d034f3297dc66f3b360c64"},
+    {file = "Brotli-1.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:cdad5b9014d83ca68c25d2e9444e28e967ef16e80f6b436918c700c117a85467"},
+    {file = "Brotli-1.1.0.tar.gz", hash = "sha256:81de08ac11bcb85841e440c13611c00b67d3bf82698314928d0b676362546724"},
+]
+
+[[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 = "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 = "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 = "comm"
+version = "0.2.2"
+description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"},
+    {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"},
+]
+
+[package.dependencies]
+traitlets = ">=4"
+
+[package.extras]
+test = ["pytest"]
+
+[[package]]
+name = "configargparse"
+version = "1.7"
+description = "A drop-in replacement for argparse that allows options to also be set via config files and/or environment variables."
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "ConfigArgParse-1.7-py3-none-any.whl", hash = "sha256:d249da6591465c6c26df64a9f73d2536e743be2f244eb3ebe61114af2f94f86b"},
+    {file = "ConfigArgParse-1.7.tar.gz", hash = "sha256:e7067471884de5478c58a511e529f0f9bd1c66bfef1dea90935438d6c23306d1"},
+]
+
+[package.extras]
+test = ["PyYAML", "mock", "pytest"]
+yaml = ["PyYAML"]
+
+[[package]]
+name = "contourpy"
+version = "1.2.1"
+description = "Python library for calculating contours of 2D quadrilateral grids"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "contourpy-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040"},
+    {file = "contourpy-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da"},
+    {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b"},
+    {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd"},
+    {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619"},
+    {file = "contourpy-1.2.1-cp310-cp310-win32.whl", hash = "sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8"},
+    {file = "contourpy-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9"},
+    {file = "contourpy-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5"},
+    {file = "contourpy-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2"},
+    {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df"},
+    {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205"},
+    {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8"},
+    {file = "contourpy-1.2.1-cp311-cp311-win32.whl", hash = "sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec"},
+    {file = "contourpy-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922"},
+    {file = "contourpy-1.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc"},
+    {file = "contourpy-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0"},
+    {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b"},
+    {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce"},
+    {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4"},
+    {file = "contourpy-1.2.1-cp312-cp312-win32.whl", hash = "sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f"},
+    {file = "contourpy-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce"},
+    {file = "contourpy-1.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b"},
+    {file = "contourpy-1.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985"},
+    {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445"},
+    {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02"},
+    {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083"},
+    {file = "contourpy-1.2.1-cp39-cp39-win32.whl", hash = "sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba"},
+    {file = "contourpy-1.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9"},
+    {file = "contourpy-1.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609"},
+    {file = "contourpy-1.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3"},
+    {file = "contourpy-1.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f"},
+    {file = "contourpy-1.2.1.tar.gz", hash = "sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c"},
+]
+
+[package.dependencies]
+numpy = ">=1.20"
+
+[package.extras]
+bokeh = ["bokeh", "selenium"]
+docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"]
+mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.8.0)", "types-Pillow"]
+test = ["Pillow", "contourpy[test-no-images]", "matplotlib"]
+test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"]
+
+[[package]]
+name = "coverage"
+version = "5.5"
+description = "Code coverage measurement for Python"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"
+files = [
+    {file = "coverage-5.5-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:b6d534e4b2ab35c9f93f46229363e17f63c53ad01330df9f2d6bd1187e5eaacf"},
+    {file = "coverage-5.5-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:b7895207b4c843c76a25ab8c1e866261bcfe27bfaa20c192de5190121770672b"},
+    {file = "coverage-5.5-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:c2723d347ab06e7ddad1a58b2a821218239249a9e4365eaff6649d31180c1669"},
+    {file = "coverage-5.5-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:900fbf7759501bc7807fd6638c947d7a831fc9fdf742dc10f02956ff7220fa90"},
+    {file = "coverage-5.5-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:004d1880bed2d97151facef49f08e255a20ceb6f9432df75f4eef018fdd5a78c"},
+    {file = "coverage-5.5-cp27-cp27m-win32.whl", hash = "sha256:06191eb60f8d8a5bc046f3799f8a07a2d7aefb9504b0209aff0b47298333302a"},
+    {file = "coverage-5.5-cp27-cp27m-win_amd64.whl", hash = "sha256:7501140f755b725495941b43347ba8a2777407fc7f250d4f5a7d2a1050ba8e82"},
+    {file = "coverage-5.5-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:372da284cfd642d8e08ef606917846fa2ee350f64994bebfbd3afb0040436905"},
+    {file = "coverage-5.5-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:8963a499849a1fc54b35b1c9f162f4108017b2e6db2c46c1bed93a72262ed083"},
+    {file = "coverage-5.5-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:869a64f53488f40fa5b5b9dcb9e9b2962a66a87dab37790f3fcfb5144b996ef5"},
+    {file = "coverage-5.5-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:4a7697d8cb0f27399b0e393c0b90f0f1e40c82023ea4d45d22bce7032a5d7b81"},
+    {file = "coverage-5.5-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:8d0a0725ad7c1a0bcd8d1b437e191107d457e2ec1084b9f190630a4fb1af78e6"},
+    {file = "coverage-5.5-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:51cb9476a3987c8967ebab3f0fe144819781fca264f57f89760037a2ea191cb0"},
+    {file = "coverage-5.5-cp310-cp310-win_amd64.whl", hash = "sha256:c0891a6a97b09c1f3e073a890514d5012eb256845c451bd48f7968ef939bf4ae"},
+    {file = "coverage-5.5-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:3487286bc29a5aa4b93a072e9592f22254291ce96a9fbc5251f566b6b7343cdb"},
+    {file = "coverage-5.5-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:deee1077aae10d8fa88cb02c845cfba9b62c55e1183f52f6ae6a2df6a2187160"},
+    {file = "coverage-5.5-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:f11642dddbb0253cc8853254301b51390ba0081750a8ac03f20ea8103f0c56b6"},
+    {file = "coverage-5.5-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:6c90e11318f0d3c436a42409f2749ee1a115cd8b067d7f14c148f1ce5574d701"},
+    {file = "coverage-5.5-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:30c77c1dc9f253283e34c27935fded5015f7d1abe83bc7821680ac444eaf7793"},
+    {file = "coverage-5.5-cp35-cp35m-win32.whl", hash = "sha256:9a1ef3b66e38ef8618ce5fdc7bea3d9f45f3624e2a66295eea5e57966c85909e"},
+    {file = "coverage-5.5-cp35-cp35m-win_amd64.whl", hash = "sha256:972c85d205b51e30e59525694670de6a8a89691186012535f9d7dbaa230e42c3"},
+    {file = "coverage-5.5-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:af0e781009aaf59e25c5a678122391cb0f345ac0ec272c7961dc5455e1c40066"},
+    {file = "coverage-5.5-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:74d881fc777ebb11c63736622b60cb9e4aee5cace591ce274fb69e582a12a61a"},
+    {file = "coverage-5.5-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:92b017ce34b68a7d67bd6d117e6d443a9bf63a2ecf8567bb3d8c6c7bc5014465"},
+    {file = "coverage-5.5-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:d636598c8305e1f90b439dbf4f66437de4a5e3c31fdf47ad29542478c8508bbb"},
+    {file = "coverage-5.5-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:41179b8a845742d1eb60449bdb2992196e211341818565abded11cfa90efb821"},
+    {file = "coverage-5.5-cp36-cp36m-win32.whl", hash = "sha256:040af6c32813fa3eae5305d53f18875bedd079960822ef8ec067a66dd8afcd45"},
+    {file = "coverage-5.5-cp36-cp36m-win_amd64.whl", hash = "sha256:5fec2d43a2cc6965edc0bb9e83e1e4b557f76f843a77a2496cbe719583ce8184"},
+    {file = "coverage-5.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:18ba8bbede96a2c3dde7b868de9dcbd55670690af0988713f0603f037848418a"},
+    {file = "coverage-5.5-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:2910f4d36a6a9b4214bb7038d537f015346f413a975d57ca6b43bf23d6563b53"},
+    {file = "coverage-5.5-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:f0b278ce10936db1a37e6954e15a3730bea96a0997c26d7fee88e6c396c2086d"},
+    {file = "coverage-5.5-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:796c9c3c79747146ebd278dbe1e5c5c05dd6b10cc3bcb8389dfdf844f3ead638"},
+    {file = "coverage-5.5-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:53194af30d5bad77fcba80e23a1441c71abfb3e01192034f8246e0d8f99528f3"},
+    {file = "coverage-5.5-cp37-cp37m-win32.whl", hash = "sha256:184a47bbe0aa6400ed2d41d8e9ed868b8205046518c52464fde713ea06e3a74a"},
+    {file = "coverage-5.5-cp37-cp37m-win_amd64.whl", hash = "sha256:2949cad1c5208b8298d5686d5a85b66aae46d73eec2c3e08c817dd3513e5848a"},
+    {file = "coverage-5.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:217658ec7187497e3f3ebd901afdca1af062b42cfe3e0dafea4cced3983739f6"},
+    {file = "coverage-5.5-cp38-cp38-manylinux1_i686.whl", hash = "sha256:1aa846f56c3d49205c952d8318e76ccc2ae23303351d9270ab220004c580cfe2"},
+    {file = "coverage-5.5-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:24d4a7de75446be83244eabbff746d66b9240ae020ced65d060815fac3423759"},
+    {file = "coverage-5.5-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:d1f8bf7b90ba55699b3a5e44930e93ff0189aa27186e96071fac7dd0d06a1873"},
+    {file = "coverage-5.5-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:970284a88b99673ccb2e4e334cfb38a10aab7cd44f7457564d11898a74b62d0a"},
+    {file = "coverage-5.5-cp38-cp38-win32.whl", hash = "sha256:01d84219b5cdbfc8122223b39a954820929497a1cb1422824bb86b07b74594b6"},
+    {file = "coverage-5.5-cp38-cp38-win_amd64.whl", hash = "sha256:2e0d881ad471768bf6e6c2bf905d183543f10098e3b3640fc029509530091502"},
+    {file = "coverage-5.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d1f9ce122f83b2305592c11d64f181b87153fc2c2bbd3bb4a3dde8303cfb1a6b"},
+    {file = "coverage-5.5-cp39-cp39-manylinux1_i686.whl", hash = "sha256:13c4ee887eca0f4c5a247b75398d4114c37882658300e153113dafb1d76de529"},
+    {file = "coverage-5.5-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:52596d3d0e8bdf3af43db3e9ba8dcdaac724ba7b5ca3f6358529d56f7a166f8b"},
+    {file = "coverage-5.5-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:2cafbbb3af0733db200c9b5f798d18953b1a304d3f86a938367de1567f4b5bff"},
+    {file = "coverage-5.5-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:44d654437b8ddd9eee7d1eaee28b7219bec228520ff809af170488fd2fed3e2b"},
+    {file = "coverage-5.5-cp39-cp39-win32.whl", hash = "sha256:d314ed732c25d29775e84a960c3c60808b682c08d86602ec2c3008e1202e3bb6"},
+    {file = "coverage-5.5-cp39-cp39-win_amd64.whl", hash = "sha256:13034c4409db851670bc9acd836243aeee299949bd5673e11844befcb0149f03"},
+    {file = "coverage-5.5-pp36-none-any.whl", hash = "sha256:f030f8873312a16414c0d8e1a1ddff2d3235655a2174e3648b4fa66b3f2f1079"},
+    {file = "coverage-5.5-pp37-none-any.whl", hash = "sha256:2a3859cb82dcbda1cfd3e6f71c27081d18aa251d20a17d87d26d4cd216fb0af4"},
+    {file = "coverage-5.5.tar.gz", hash = "sha256:ebe78fe9a0e874362175b02371bdfbee64d8edc42a044253ddf4ee7d3c15212c"},
+]
+
+[package.extras]
+toml = ["toml"]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+description = "Composable style cycles"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"},
+    {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"},
+]
+
+[package.extras]
+docs = ["ipython", "matplotlib", "numpydoc", "sphinx"]
+tests = ["pytest", "pytest-cov", "pytest-xdist"]
+
+[[package]]
+name = "debugpy"
+version = "1.8.2"
+description = "An implementation of the Debug Adapter Protocol for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "debugpy-1.8.2-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:7ee2e1afbf44b138c005e4380097d92532e1001580853a7cb40ed84e0ef1c3d2"},
+    {file = "debugpy-1.8.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f8c3f7c53130a070f0fc845a0f2cee8ed88d220d6b04595897b66605df1edd6"},
+    {file = "debugpy-1.8.2-cp310-cp310-win32.whl", hash = "sha256:f179af1e1bd4c88b0b9f0fa153569b24f6b6f3de33f94703336363ae62f4bf47"},
+    {file = "debugpy-1.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:0600faef1d0b8d0e85c816b8bb0cb90ed94fc611f308d5fde28cb8b3d2ff0fe3"},
+    {file = "debugpy-1.8.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:8a13417ccd5978a642e91fb79b871baded925d4fadd4dfafec1928196292aa0a"},
+    {file = "debugpy-1.8.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acdf39855f65c48ac9667b2801234fc64d46778021efac2de7e50907ab90c634"},
+    {file = "debugpy-1.8.2-cp311-cp311-win32.whl", hash = "sha256:2cbd4d9a2fc5e7f583ff9bf11f3b7d78dfda8401e8bb6856ad1ed190be4281ad"},
+    {file = "debugpy-1.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:d3408fddd76414034c02880e891ea434e9a9cf3a69842098ef92f6e809d09afa"},
+    {file = "debugpy-1.8.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:5d3ccd39e4021f2eb86b8d748a96c766058b39443c1f18b2dc52c10ac2757835"},
+    {file = "debugpy-1.8.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:62658aefe289598680193ff655ff3940e2a601765259b123dc7f89c0239b8cd3"},
+    {file = "debugpy-1.8.2-cp312-cp312-win32.whl", hash = "sha256:bd11fe35d6fd3431f1546d94121322c0ac572e1bfb1f6be0e9b8655fb4ea941e"},
+    {file = "debugpy-1.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:15bc2f4b0f5e99bf86c162c91a74c0631dbd9cef3c6a1d1329c946586255e859"},
+    {file = "debugpy-1.8.2-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:5a019d4574afedc6ead1daa22736c530712465c0c4cd44f820d803d937531b2d"},
+    {file = "debugpy-1.8.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40f062d6877d2e45b112c0bbade9a17aac507445fd638922b1a5434df34aed02"},
+    {file = "debugpy-1.8.2-cp38-cp38-win32.whl", hash = "sha256:c78ba1680f1015c0ca7115671fe347b28b446081dada3fedf54138f44e4ba031"},
+    {file = "debugpy-1.8.2-cp38-cp38-win_amd64.whl", hash = "sha256:cf327316ae0c0e7dd81eb92d24ba8b5e88bb4d1b585b5c0d32929274a66a5210"},
+    {file = "debugpy-1.8.2-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:1523bc551e28e15147815d1397afc150ac99dbd3a8e64641d53425dba57b0ff9"},
+    {file = "debugpy-1.8.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e24ccb0cd6f8bfaec68d577cb49e9c680621c336f347479b3fce060ba7c09ec1"},
+    {file = "debugpy-1.8.2-cp39-cp39-win32.whl", hash = "sha256:7f8d57a98c5a486c5c7824bc0b9f2f11189d08d73635c326abef268f83950326"},
+    {file = "debugpy-1.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:16c8dcab02617b75697a0a925a62943e26a0330da076e2a10437edd9f0bf3755"},
+    {file = "debugpy-1.8.2-py2.py3-none-any.whl", hash = "sha256:16e16df3a98a35c63c3ab1e4d19be4cbc7fdda92d9ddc059294f18910928e0ca"},
+    {file = "debugpy-1.8.2.zip", hash = "sha256:95378ed08ed2089221896b9b3a8d021e642c24edc8fef20e5d4342ca8be65c00"},
+]
+
+[[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 = "dnspython"
+version = "2.6.1"
+description = "DNS toolkit"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "dnspython-2.6.1-py3-none-any.whl", hash = "sha256:5ef3b9680161f6fa89daf8ad451b5f1a33b18ae8a1c6778cdf4b43f08c0a6e50"},
+    {file = "dnspython-2.6.1.tar.gz", hash = "sha256:e8f0f9c23a7b7cb99ded64e6c3a6f3e701d78f50c55e002b839dea7225cff7cc"},
+]
+
+[package.extras]
+dev = ["black (>=23.1.0)", "coverage (>=7.0)", "flake8 (>=7)", "mypy (>=1.8)", "pylint (>=3)", "pytest (>=7.4)", "pytest-cov (>=4.1.0)", "sphinx (>=7.2.0)", "twine (>=4.0.0)", "wheel (>=0.42.0)"]
+dnssec = ["cryptography (>=41)"]
+doh = ["h2 (>=4.1.0)", "httpcore (>=1.0.0)", "httpx (>=0.26.0)"]
+doq = ["aioquic (>=0.9.25)"]
+idna = ["idna (>=3.6)"]
+trio = ["trio (>=0.23)"]
+wmi = ["wmi (>=1.5.1)"]
+
+[[package]]
+name = "email-validator"
+version = "2.2.0"
+description = "A robust email address syntax and deliverability validation library."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "email_validator-2.2.0-py3-none-any.whl", hash = "sha256:561977c2d73ce3611850a06fa56b414621e0c8faa9d66f2611407d87465da631"},
+    {file = "email_validator-2.2.0.tar.gz", hash = "sha256:cb690f344c617a714f22e66ae771445a1ceb46821152df8e165c5f9a364582b7"},
+]
+
+[package.dependencies]
+dnspython = ">=2.0.0"
+idna = ">=2.0.0"
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.2"
+description = "Backport of PEP 654 (exception groups)"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},
+    {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"},
+]
+
+[package.extras]
+test = ["pytest (>=6)"]
+
+[[package]]
+name = "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 = "fastapi"
+version = "0.111.1"
+description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fastapi-0.111.1-py3-none-any.whl", hash = "sha256:4f51cfa25d72f9fbc3280832e84b32494cf186f50158d364a8765aabf22587bf"},
+    {file = "fastapi-0.111.1.tar.gz", hash = "sha256:ddd1ac34cb1f76c2e2d7f8545a4bcb5463bce4834e81abf0b189e0c359ab2413"},
+]
+
+[package.dependencies]
+email_validator = ">=2.0.0"
+fastapi-cli = ">=0.0.2"
+httpx = ">=0.23.0"
+jinja2 = ">=2.11.2"
+pydantic = ">=1.7.4,<1.8 || >1.8,<1.8.1 || >1.8.1,<2.0.0 || >2.0.0,<2.0.1 || >2.0.1,<2.1.0 || >2.1.0,<3.0.0"
+python-multipart = ">=0.0.7"
+starlette = ">=0.37.2,<0.38.0"
+typing-extensions = ">=4.8.0"
+uvicorn = {version = ">=0.12.0", extras = ["standard"]}
+
+[package.extras]
+all = ["email_validator (>=2.0.0)", "httpx (>=0.23.0)", "itsdangerous (>=1.1.0)", "jinja2 (>=2.11.2)", "orjson (>=3.2.1)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.7)", "pyyaml (>=5.3.1)", "ujson (>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0)", "uvicorn[standard] (>=0.12.0)"]
+
+[[package]]
+name = "fastapi-cli"
+version = "0.0.4"
+description = "Run and manage FastAPI apps from the command line with FastAPI CLI. 🚀"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fastapi_cli-0.0.4-py3-none-any.whl", hash = "sha256:a2552f3a7ae64058cdbb530be6fa6dbfc975dc165e4fa66d224c3d396e25e809"},
+    {file = "fastapi_cli-0.0.4.tar.gz", hash = "sha256:e2e9ffaffc1f7767f488d6da34b6f5a377751c996f397902eb6abb99a67bde32"},
+]
+
+[package.dependencies]
+typer = ">=0.12.3"
+
+[package.extras]
+standard = ["fastapi", "uvicorn[standard] (>=0.15.0)"]
+
+[[package]]
+name = "flake8"
+version = "6.0.0"
+description = "the modular source code checker: pep8 pyflakes and co"
+optional = false
+python-versions = ">=3.8.1"
+files = [
+    {file = "flake8-6.0.0-py2.py3-none-any.whl", hash = "sha256:3833794e27ff64ea4e9cf5d410082a8b97ff1a06c16aa3d2027339cd0f1195c7"},
+    {file = "flake8-6.0.0.tar.gz", hash = "sha256:c61007e76655af75e6785a931f452915b371dc48f56efd765247c8fe68f2b181"},
+]
+
+[package.dependencies]
+mccabe = ">=0.7.0,<0.8.0"
+pycodestyle = ">=2.10.0,<2.11.0"
+pyflakes = ">=3.0.0,<3.1.0"
+
+[[package]]
+name = "flask"
+version = "2.3.3"
+description = "A simple framework for building complex web applications."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "flask-2.3.3-py3-none-any.whl", hash = "sha256:f69fcd559dc907ed196ab9df0e48471709175e696d6e698dd4dbe940f96ce66b"},
+    {file = "flask-2.3.3.tar.gz", hash = "sha256:09c347a92aa7ff4a8e7f3206795f30d826654baf38b873d0744cd571ca609efc"},
+]
+
+[package.dependencies]
+blinker = ">=1.6.2"
+click = ">=8.1.3"
+itsdangerous = ">=2.1.2"
+Jinja2 = ">=3.1.2"
+Werkzeug = ">=2.3.7"
+
+[package.extras]
+async = ["asgiref (>=3.2)"]
+dotenv = ["python-dotenv"]
+
+[[package]]
+name = "flask-cors"
+version = "4.0.1"
+description = "A Flask extension adding a decorator for CORS support"
+optional = false
+python-versions = "*"
+files = [
+    {file = "Flask_Cors-4.0.1-py2.py3-none-any.whl", hash = "sha256:f2a704e4458665580c074b714c4627dd5a306b333deb9074d0b1794dfa2fb677"},
+    {file = "flask_cors-4.0.1.tar.gz", hash = "sha256:eeb69b342142fdbf4766ad99357a7f3876a2ceb77689dc10ff912aac06c389e4"},
+]
+
+[package.dependencies]
+Flask = ">=0.9"
+
+[[package]]
+name = "flask-login"
+version = "0.6.3"
+description = "User authentication and session management for Flask."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "Flask-Login-0.6.3.tar.gz", hash = "sha256:5e23d14a607ef12806c699590b89d0f0e0d67baeec599d75947bf9c147330333"},
+    {file = "Flask_Login-0.6.3-py3-none-any.whl", hash = "sha256:849b25b82a436bf830a054e74214074af59097171562ab10bfa999e6b78aae5d"},
+]
+
+[package.dependencies]
+Flask = ">=1.0.4"
+Werkzeug = ">=1.0.1"
+
+[[package]]
+name = "fonttools"
+version = "4.53.1"
+description = "Tools to manipulate font files"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fonttools-4.53.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0679a30b59d74b6242909945429dbddb08496935b82f91ea9bf6ad240ec23397"},
+    {file = "fonttools-4.53.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8bf06b94694251861ba7fdeea15c8ec0967f84c3d4143ae9daf42bbc7717fe3"},
+    {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b96cd370a61f4d083c9c0053bf634279b094308d52fdc2dd9a22d8372fdd590d"},
+    {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1c7c5aa18dd3b17995898b4a9b5929d69ef6ae2af5b96d585ff4005033d82f0"},
+    {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e013aae589c1c12505da64a7d8d023e584987e51e62006e1bb30d72f26522c41"},
+    {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9efd176f874cb6402e607e4cc9b4a9cd584d82fc34a4b0c811970b32ba62501f"},
+    {file = "fonttools-4.53.1-cp310-cp310-win32.whl", hash = "sha256:c8696544c964500aa9439efb6761947393b70b17ef4e82d73277413f291260a4"},
+    {file = "fonttools-4.53.1-cp310-cp310-win_amd64.whl", hash = "sha256:8959a59de5af6d2bec27489e98ef25a397cfa1774b375d5787509c06659b3671"},
+    {file = "fonttools-4.53.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:da33440b1413bad53a8674393c5d29ce64d8c1a15ef8a77c642ffd900d07bfe1"},
+    {file = "fonttools-4.53.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ff7e5e9bad94e3a70c5cd2fa27f20b9bb9385e10cddab567b85ce5d306ea923"},
+    {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c6e7170d675d12eac12ad1a981d90f118c06cf680b42a2d74c6c931e54b50719"},
+    {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee32ea8765e859670c4447b0817514ca79054463b6b79784b08a8df3a4d78e3"},
+    {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6e08f572625a1ee682115223eabebc4c6a2035a6917eac6f60350aba297ccadb"},
+    {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b21952c092ffd827504de7e66b62aba26fdb5f9d1e435c52477e6486e9d128b2"},
+    {file = "fonttools-4.53.1-cp311-cp311-win32.whl", hash = "sha256:9dfdae43b7996af46ff9da520998a32b105c7f098aeea06b2226b30e74fbba88"},
+    {file = "fonttools-4.53.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4d0096cb1ac7a77b3b41cd78c9b6bc4a400550e21dc7a92f2b5ab53ed74eb02"},
+    {file = "fonttools-4.53.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d92d3c2a1b39631a6131c2fa25b5406855f97969b068e7e08413325bc0afba58"},
+    {file = "fonttools-4.53.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3b3c8ebafbee8d9002bd8f1195d09ed2bd9ff134ddec37ee8f6a6375e6a4f0e8"},
+    {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32f029c095ad66c425b0ee85553d0dc326d45d7059dbc227330fc29b43e8ba60"},
+    {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f5e6c3510b79ea27bb1ebfcc67048cde9ec67afa87c7dd7efa5c700491ac7f"},
+    {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f677ce218976496a587ab17140da141557beb91d2a5c1a14212c994093f2eae2"},
+    {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9e6ceba2a01b448e36754983d376064730690401da1dd104ddb543519470a15f"},
+    {file = "fonttools-4.53.1-cp312-cp312-win32.whl", hash = "sha256:791b31ebbc05197d7aa096bbc7bd76d591f05905d2fd908bf103af4488e60670"},
+    {file = "fonttools-4.53.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ed170b5e17da0264b9f6fae86073be3db15fa1bd74061c8331022bca6d09bab"},
+    {file = "fonttools-4.53.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c818c058404eb2bba05e728d38049438afd649e3c409796723dfc17cd3f08749"},
+    {file = "fonttools-4.53.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:651390c3b26b0c7d1f4407cad281ee7a5a85a31a110cbac5269de72a51551ba2"},
+    {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e54f1bba2f655924c1138bbc7fa91abd61f45c68bd65ab5ed985942712864bbb"},
+    {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9cd19cf4fe0595ebdd1d4915882b9440c3a6d30b008f3cc7587c1da7b95be5f"},
+    {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:2af40ae9cdcb204fc1d8f26b190aa16534fcd4f0df756268df674a270eab575d"},
+    {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:35250099b0cfb32d799fb5d6c651220a642fe2e3c7d2560490e6f1d3f9ae9169"},
+    {file = "fonttools-4.53.1-cp38-cp38-win32.whl", hash = "sha256:f08df60fbd8d289152079a65da4e66a447efc1d5d5a4d3f299cdd39e3b2e4a7d"},
+    {file = "fonttools-4.53.1-cp38-cp38-win_amd64.whl", hash = "sha256:7b6b35e52ddc8fb0db562133894e6ef5b4e54e1283dff606fda3eed938c36fc8"},
+    {file = "fonttools-4.53.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:75a157d8d26c06e64ace9df037ee93a4938a4606a38cb7ffaf6635e60e253b7a"},
+    {file = "fonttools-4.53.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4824c198f714ab5559c5be10fd1adf876712aa7989882a4ec887bf1ef3e00e31"},
+    {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:becc5d7cb89c7b7afa8321b6bb3dbee0eec2b57855c90b3e9bf5fb816671fa7c"},
+    {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84ec3fb43befb54be490147b4a922b5314e16372a643004f182babee9f9c3407"},
+    {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:73379d3ffdeecb376640cd8ed03e9d2d0e568c9d1a4e9b16504a834ebadc2dfb"},
+    {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:02569e9a810f9d11f4ae82c391ebc6fb5730d95a0657d24d754ed7763fb2d122"},
+    {file = "fonttools-4.53.1-cp39-cp39-win32.whl", hash = "sha256:aae7bd54187e8bf7fd69f8ab87b2885253d3575163ad4d669a262fe97f0136cb"},
+    {file = "fonttools-4.53.1-cp39-cp39-win_amd64.whl", hash = "sha256:e5b708073ea3d684235648786f5f6153a48dc8762cdfe5563c57e80787c29fbb"},
+    {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"},
+    {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"},
+]
+
+[package.extras]
+all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"]
+graphite = ["lz4 (>=1.7.4.2)"]
+interpolatable = ["munkres", "pycairo", "scipy"]
+lxml = ["lxml (>=4.0)"]
+pathops = ["skia-pathops (>=0.5.0)"]
+plot = ["matplotlib"]
+repacker = ["uharfbuzz (>=0.23.0)"]
+symfont = ["sympy"]
+type1 = ["xattr"]
+ufo = ["fs (>=2.2.0,<3)"]
+unicode = ["unicodedata2 (>=15.1.0)"]
+woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"]
+
+[[package]]
+name = "gevent"
+version = "24.2.1"
+description = "Coroutine-based network library"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "gevent-24.2.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:6f947a9abc1a129858391b3d9334c45041c08a0f23d14333d5b844b6e5c17a07"},
+    {file = "gevent-24.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bde283313daf0b34a8d1bab30325f5cb0f4e11b5869dbe5bc61f8fe09a8f66f3"},
+    {file = "gevent-24.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a1df555431f5cd5cc189a6ee3544d24f8c52f2529134685f1e878c4972ab026"},
+    {file = "gevent-24.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14532a67f7cb29fb055a0e9b39f16b88ed22c66b96641df8c04bdc38c26b9ea5"},
+    {file = "gevent-24.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd23df885318391856415e20acfd51a985cba6919f0be78ed89f5db9ff3a31cb"},
+    {file = "gevent-24.2.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ca80b121bbec76d7794fcb45e65a7eca660a76cc1a104ed439cdbd7df5f0b060"},
+    {file = "gevent-24.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b9913c45d1be52d7a5db0c63977eebb51f68a2d5e6fd922d1d9b5e5fd758cc98"},
+    {file = "gevent-24.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:918cdf8751b24986f915d743225ad6b702f83e1106e08a63b736e3a4c6ead789"},
+    {file = "gevent-24.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:3d5325ccfadfd3dcf72ff88a92fb8fc0b56cacc7225f0f4b6dcf186c1a6eeabc"},
+    {file = "gevent-24.2.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:03aa5879acd6b7076f6a2a307410fb1e0d288b84b03cdfd8c74db8b4bc882fc5"},
+    {file = "gevent-24.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8bb35ce57a63c9a6896c71a285818a3922d8ca05d150fd1fe49a7f57287b836"},
+    {file = "gevent-24.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d7f87c2c02e03d99b95cfa6f7a776409083a9e4d468912e18c7680437b29222c"},
+    {file = "gevent-24.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:968581d1717bbcf170758580f5f97a2925854943c45a19be4d47299507db2eb7"},
+    {file = "gevent-24.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7899a38d0ae7e817e99adb217f586d0a4620e315e4de577444ebeeed2c5729be"},
+    {file = "gevent-24.2.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:f5e8e8d60e18d5f7fd49983f0c4696deeddaf6e608fbab33397671e2fcc6cc91"},
+    {file = "gevent-24.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fbfdce91239fe306772faab57597186710d5699213f4df099d1612da7320d682"},
+    {file = "gevent-24.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cdf66977a976d6a3cfb006afdf825d1482f84f7b81179db33941f2fc9673bb1d"},
+    {file = "gevent-24.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:1dffb395e500613e0452b9503153f8f7ba587c67dd4a85fc7cd7aa7430cb02cc"},
+    {file = "gevent-24.2.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:6c47ae7d1174617b3509f5d884935e788f325eb8f1a7efc95d295c68d83cce40"},
+    {file = "gevent-24.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7cac622e11b4253ac4536a654fe221249065d9a69feb6cdcd4d9af3503602e0"},
+    {file = "gevent-24.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bf5b9c72b884c6f0c4ed26ef204ee1f768b9437330422492c319470954bc4cc7"},
+    {file = "gevent-24.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f5de3c676e57177b38857f6e3cdfbe8f38d1cd754b63200c0615eaa31f514b4f"},
+    {file = "gevent-24.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4faf846ed132fd7ebfbbf4fde588a62d21faa0faa06e6f468b7faa6f436b661"},
+    {file = "gevent-24.2.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:368a277bd9278ddb0fde308e6a43f544222d76ed0c4166e0d9f6b036586819d9"},
+    {file = "gevent-24.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f8a04cf0c5b7139bc6368b461257d4a757ea2fe89b3773e494d235b7dd51119f"},
+    {file = "gevent-24.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9d8d0642c63d453179058abc4143e30718b19a85cbf58c2744c9a63f06a1d388"},
+    {file = "gevent-24.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:94138682e68ec197db42ad7442d3cf9b328069c3ad8e4e5022e6b5cd3e7ffae5"},
+    {file = "gevent-24.2.1-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:8f4b8e777d39013595a7740b4463e61b1cfe5f462f1b609b28fbc1e4c4ff01e5"},
+    {file = "gevent-24.2.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:141a2b24ad14f7b9576965c0c84927fc85f824a9bb19f6ec1e61e845d87c9cd8"},
+    {file = "gevent-24.2.1-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:9202f22ef811053077d01f43cc02b4aaf4472792f9fd0f5081b0b05c926cca19"},
+    {file = "gevent-24.2.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2955eea9c44c842c626feebf4459c42ce168685aa99594e049d03bedf53c2800"},
+    {file = "gevent-24.2.1-cp38-cp38-win32.whl", hash = "sha256:44098038d5e2749b0784aabb27f1fcbb3f43edebedf64d0af0d26955611be8d6"},
+    {file = "gevent-24.2.1-cp38-cp38-win_amd64.whl", hash = "sha256:117e5837bc74a1673605fb53f8bfe22feb6e5afa411f524c835b2ddf768db0de"},
+    {file = "gevent-24.2.1-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:2ae3a25ecce0a5b0cd0808ab716bfca180230112bb4bc89b46ae0061d62d4afe"},
+    {file = "gevent-24.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7ceb59986456ce851160867ce4929edaffbd2f069ae25717150199f8e1548b8"},
+    {file = "gevent-24.2.1-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:2e9ac06f225b696cdedbb22f9e805e2dd87bf82e8fa5e17756f94e88a9d37cf7"},
+    {file = "gevent-24.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:90cbac1ec05b305a1b90ede61ef73126afdeb5a804ae04480d6da12c56378df1"},
+    {file = "gevent-24.2.1-cp39-cp39-win32.whl", hash = "sha256:782a771424fe74bc7e75c228a1da671578c2ba4ddb2ca09b8f959abdf787331e"},
+    {file = "gevent-24.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:3adfb96637f44010be8abd1b5e73b5070f851b817a0b182e601202f20fa06533"},
+    {file = "gevent-24.2.1-pp310-pypy310_pp73-macosx_11_0_universal2.whl", hash = "sha256:7b00f8c9065de3ad226f7979154a7b27f3b9151c8055c162332369262fc025d8"},
+    {file = "gevent-24.2.1.tar.gz", hash = "sha256:432fc76f680acf7cf188c2ee0f5d3ab73b63c1f03114c7cd8a34cebbe5aa2056"},
+]
+
+[package.dependencies]
+cffi = {version = ">=1.12.2", markers = "platform_python_implementation == \"CPython\" and sys_platform == \"win32\""}
+greenlet = {version = ">=2.0.0", markers = "platform_python_implementation == \"CPython\" and python_version < \"3.11\""}
+"zope.event" = "*"
+"zope.interface" = "*"
+
+[package.extras]
+dnspython = ["dnspython (>=1.16.0,<2.0)", "idna"]
+docs = ["furo", "repoze.sphinx.autointerface", "sphinx", "sphinxcontrib-programoutput", "zope.schema"]
+monitor = ["psutil (>=5.7.0)"]
+recommended = ["cffi (>=1.12.2)", "dnspython (>=1.16.0,<2.0)", "idna", "psutil (>=5.7.0)"]
+test = ["cffi (>=1.12.2)", "coverage (>=5.0)", "dnspython (>=1.16.0,<2.0)", "idna", "objgraph", "psutil (>=5.7.0)", "requests"]
+
+[[package]]
+name = "geventhttpclient"
+version = "2.3.1"
+description = "HTTP client library for gevent"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "geventhttpclient-2.3.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:da22ab7bf5af4ba3d07cffee6de448b42696e53e7ac1fe97ed289037733bf1c2"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2399e3d4e2fae8bbd91756189da6e9d84adf8f3eaace5eef0667874a705a29f8"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3e33e87d0d5b9f5782c4e6d3cb7e3592fea41af52713137d04776df7646d71b"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c071db313866c3d0510feb6c0f40ec086ccf7e4a845701b6316c82c06e8b9b29"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f36f0c6ef88a27e60af8369d9c2189fe372c6f2943182a7568e0f2ad33bb69f1"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c4624843c03a5337282a42247d987c2531193e57255ee307b36eeb4f243a0c21"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d614573621ba827c417786057e1e20e9f96c4f6b3878c55b1b7b54e1026693bc"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:5d51330a40ac9762879d0e296c279c1beae8cfa6484bb196ac829242c416b709"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:bc9f2162d4e8cb86bb5322d99bfd552088a3eacd540a841298f06bb8bc1f1f03"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:06e59d3397e63c65ecc7a7561a5289f0cf2e2c2252e29632741e792f57f5d124"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4436eef515b3e0c1d4a453ae32e047290e780a623c1eddb11026ae9d5fb03d42"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-win32.whl", hash = "sha256:5d1cf7d8a4f8e15cc8fd7d88ac4cdb058d6274203a42587e594cc9f0850ac862"},
+    {file = "geventhttpclient-2.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:4deaebc121036f7ea95430c2d0f80ab085b15280e6ab677a6360b70e57020e7f"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f0ae055b9ce1704f2ce72c0847df28f4e14dbb3eea79256cda6c909d82688ea3"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f087af2ac439495b5388841d6f3c4de8d2573ca9870593d78f7b554aa5cfa7f5"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:76c367d175810facfe56281e516c9a5a4a191eff76641faaa30aa33882ed4b2f"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a58376d0d461fe0322ff2ad362553b437daee1eeb92b4c0e3b1ffef9e77defbe"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f440cc704f8a9869848a109b2c401805c17c070539b2014e7b884ecfc8591e33"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f10c62994f9052f23948c19de930b2d1f063240462c8bd7077c2b3290e61f4fa"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:52c45d9f3dd9627844c12e9ca347258c7be585bed54046336220e25ea6eac155"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:77c1a2c6e3854bf87cd5588b95174640c8a881716bd07fa0d131d082270a6795"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:ce649d4e25c2d56023471df0bf1e8e2ab67dfe4ff12ce3e8fe7e6fae30cd672a"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:265d9f31b4ac8f688eebef0bd4c814ffb37a16f769ad0c8c8b8c24a84db8eab5"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:2de436a9d61dae877e4e811fb3e2594e2a1df1b18f4280878f318aef48a562b9"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-win32.whl", hash = "sha256:83e22178b9480b0a95edf0053d4f30b717d0b696b3c262beabe6964d9c5224b1"},
+    {file = "geventhttpclient-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:97b072a282233384c1302a7dee88ad8bfedc916f06b1bc1da54f84980f1406a9"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:e1c90abcc2735cd8dd2d2572a13da32f6625392dc04862decb5c6476a3ddee22"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5deb41c2f51247b4e568c14964f59d7b8e537eff51900564c88af3200004e678"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c6f1a56a66a90c4beae2f009b5e9d42db9a58ced165aa35441ace04d69cb7b37"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ee6e741849c29e3129b1ec3828ac3a5e5dcb043402f852ea92c52334fb8cabf"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0d0972096a63b1ddaa73fa3dab2c7a136e3ab8bf7999a2f85a5dee851fa77cdd"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00675ba682fb7d19d659c14686fa8a52a65e3f301b56c2a4ee6333b380dd9467"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea77b67c186df90473416f4403839728f70ef6cf1689cec97b4f6bbde392a8a8"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ddcc3f0fdffd9a3801e1005b73026202cffed8199863fdef9315bea9a860a032"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:c9f1ef4ec048563cc621a47ff01a4f10048ff8b676d7a4d75e5433ed8e703e56"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:a364b30bec7a0a00dbe256e2b6807e4dc866bead7ac84aaa51ca5e2c3d15c258"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:25d255383d3d6a6fbd643bb51ae1a7e4f6f7b0dbd5f3225b537d0bd0432eaf39"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-win32.whl", hash = "sha256:ad0b507e354d2f398186dcb12fe526d0594e7c9387b514fb843f7a14fdf1729a"},
+    {file = "geventhttpclient-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:7924e0883bc2b177cfe27aa65af6bb9dd57f3e26905c7675a2d1f3ef69df7cca"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:fe912c6456faab196b952adcd63e9353a0d5c8deb31c8d733d38f4f0ab22e359"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8b599359779c2278018786c35d70664d441a7cd0d6baef2b2cd0d1685cf478ed"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:34107b506e2c40ec7784efa282469bf86888cacddced463dceeb58c201834897"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc34031905b2b31a80d88cd33d7e42b81812950e5304860ab6a65ee2803e2046"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50b54f67ba2087f4d9d2172065c5c5de0f0c7f865ac350116e5452de4be31444"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9ddeb431836c2ef7fd33c505a06180dc907b474e0e8537a43ff12e12c9bf0307"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4890713433ca19b081f70b5f7ad258a0979ec3354f9538b50b3ad7d0a86f88de"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b8ca7dcbe94cb563341087b00b6fbd0fdd70b2acc1b5d963f9ebbfbc1e5e2893"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:05a1bbdd43ae36bcc10b3dbfa0806aefc5033a91efecfddfe56159446a46ea71"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f82c454595a88a5e510ae0985711ef398386998b6f37d90fc30e9ff1a2001280"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6b032a5cdb1721921f4cd36aad620af318263b462962cfb23d648cdb93aab232"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-win32.whl", hash = "sha256:ce2c7d18bac7ffdacc4a86cd490bea6136a7d1e1170f8624f2e3bbe3b189d5b8"},
+    {file = "geventhttpclient-2.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:6ca50dd9761971d3557b897108933b34fb4a11533d52f0f2753840c740a2861a"},
+    {file = "geventhttpclient-2.3.1-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:c31431e38df45b3c79bf3c9427c796adb8263d622bc6fa25e2f6ba916c2aad93"},
+    {file = "geventhttpclient-2.3.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:855ab1e145575769b180b57accb0573a77cd6a7392f40a6ef7bc9a4926ebd77b"},
+    {file = "geventhttpclient-2.3.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a374aad77c01539e786d0c7829bec2eba034ccd45733c1bf9811ad18d2a8ecd"},
+    {file = "geventhttpclient-2.3.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66c1e97460608304f400485ac099736fff3566d3d8db2038533d466f8cf5de5a"},
+    {file = "geventhttpclient-2.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:4f843f81ee44ba4c553a1b3f73115e0ad8f00044023c24db29f5b1df3da08465"},
+    {file = "geventhttpclient-2.3.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:321b73c73d73b85cfeff36b9b5ee04174ec8406fb3dadc129558a26ccb879360"},
+    {file = "geventhttpclient-2.3.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:829d03c2a140edbe74ad1fb4f850384f585f3e06fc47cfe647d065412b93926f"},
+    {file = "geventhttpclient-2.3.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:994c543f156db7bce3bae15491a0e041eeb3f1cf467e0d1db0c161a900a90bec"},
+    {file = "geventhttpclient-2.3.1-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4beff505306aa9da5cdfe2f206b403ec7c8d06a22d6b7248365772858c4ee8c"},
+    {file = "geventhttpclient-2.3.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:fb0a9673074541ccda09a2423fa16f4528819ceb1ba19d252213f6aca7d4b44a"},
+    {file = "geventhttpclient-2.3.1.tar.gz", hash = "sha256:b40ddac8517c456818942c7812f555f84702105c82783238c9fcb8dc12675185"},
+]
+
+[package.dependencies]
+brotli = "*"
+certifi = "*"
+gevent = "*"
+urllib3 = "*"
+
+[package.extras]
+benchmarks = ["httplib2", "httpx", "requests", "urllib3"]
+dev = ["dpkt", "pytest", "requests"]
+examples = ["oauth2"]
+
+[[package]]
+name = "greenlet"
+version = "3.0.3"
+description = "Lightweight in-process concurrent programming"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "greenlet-3.0.3-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9da2bd29ed9e4f15955dd1595ad7bc9320308a3b766ef7f837e23ad4b4aac31a"},
+    {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d353cadd6083fdb056bb46ed07e4340b0869c305c8ca54ef9da3421acbdf6881"},
+    {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dca1e2f3ca00b84a396bc1bce13dd21f680f035314d2379c4160c98153b2059b"},
+    {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ed7fb269f15dc662787f4119ec300ad0702fa1b19d2135a37c2c4de6fadfd4a"},
+    {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd4f49ae60e10adbc94b45c0b5e6a179acc1736cf7a90160b404076ee283cf83"},
+    {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:73a411ef564e0e097dbe7e866bb2dda0f027e072b04da387282b02c308807405"},
+    {file = "greenlet-3.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7f362975f2d179f9e26928c5b517524e89dd48530a0202570d55ad6ca5d8a56f"},
+    {file = "greenlet-3.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:649dde7de1a5eceb258f9cb00bdf50e978c9db1b996964cd80703614c86495eb"},
+    {file = "greenlet-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:68834da854554926fbedd38c76e60c4a2e3198c6fbed520b106a8986445caaf9"},
+    {file = "greenlet-3.0.3-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:b1b5667cced97081bf57b8fa1d6bfca67814b0afd38208d52538316e9422fc61"},
+    {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:52f59dd9c96ad2fc0d5724107444f76eb20aaccb675bf825df6435acb7703559"},
+    {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:afaff6cf5200befd5cec055b07d1c0a5a06c040fe5ad148abcd11ba6ab9b114e"},
+    {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe754d231288e1e64323cfad462fcee8f0288654c10bdf4f603a39ed923bef33"},
+    {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2797aa5aedac23af156bbb5a6aa2cd3427ada2972c828244eb7d1b9255846379"},
+    {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7f009caad047246ed379e1c4dbcb8b020f0a390667ea74d2387be2998f58a22"},
+    {file = "greenlet-3.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c5e1536de2aad7bf62e27baf79225d0d64360d4168cf2e6becb91baf1ed074f3"},
+    {file = "greenlet-3.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:894393ce10ceac937e56ec00bb71c4c2f8209ad516e96033e4b3b1de270e200d"},
+    {file = "greenlet-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:1ea188d4f49089fc6fb283845ab18a2518d279c7cd9da1065d7a84e991748728"},
+    {file = "greenlet-3.0.3-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:70fb482fdf2c707765ab5f0b6655e9cfcf3780d8d87355a063547b41177599be"},
+    {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4d1ac74f5c0c0524e4a24335350edad7e5f03b9532da7ea4d3c54d527784f2e"},
+    {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:149e94a2dd82d19838fe4b2259f1b6b9957d5ba1b25640d2380bea9c5df37676"},
+    {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15d79dd26056573940fcb8c7413d84118086f2ec1a8acdfa854631084393efcc"},
+    {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b7db1ebff4ba09aaaeae6aa491daeb226c8150fc20e836ad00041bcb11230"},
+    {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcd2469d6a2cf298f198f0487e0a5b1a47a42ca0fa4dfd1b6862c999f018ebbf"},
+    {file = "greenlet-3.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1f672519db1796ca0d8753f9e78ec02355e862d0998193038c7073045899f305"},
+    {file = "greenlet-3.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2516a9957eed41dd8f1ec0c604f1cdc86758b587d964668b5b196a9db5bfcde6"},
+    {file = "greenlet-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:bba5387a6975598857d86de9eac14210a49d554a77eb8261cc68b7d082f78ce2"},
+    {file = "greenlet-3.0.3-cp37-cp37m-macosx_11_0_universal2.whl", hash = "sha256:5b51e85cb5ceda94e79d019ed36b35386e8c37d22f07d6a751cb659b180d5274"},
+    {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:daf3cb43b7cf2ba96d614252ce1684c1bccee6b2183a01328c98d36fcd7d5cb0"},
+    {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:99bf650dc5d69546e076f413a87481ee1d2d09aaaaaca058c9251b6d8c14783f"},
+    {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2dd6e660effd852586b6a8478a1d244b8dc90ab5b1321751d2ea15deb49ed414"},
+    {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3391d1e16e2a5a1507d83e4a8b100f4ee626e8eca43cf2cadb543de69827c4c"},
+    {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e1f145462f1fa6e4a4ae3c0f782e580ce44d57c8f2c7aae1b6fa88c0b2efdb41"},
+    {file = "greenlet-3.0.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:1a7191e42732df52cb5f39d3527217e7ab73cae2cb3694d241e18f53d84ea9a7"},
+    {file = "greenlet-3.0.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:0448abc479fab28b00cb472d278828b3ccca164531daab4e970a0458786055d6"},
+    {file = "greenlet-3.0.3-cp37-cp37m-win32.whl", hash = "sha256:b542be2440edc2d48547b5923c408cbe0fc94afb9f18741faa6ae970dbcb9b6d"},
+    {file = "greenlet-3.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:01bc7ea167cf943b4c802068e178bbf70ae2e8c080467070d01bfa02f337ee67"},
+    {file = "greenlet-3.0.3-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:1996cb9306c8595335bb157d133daf5cf9f693ef413e7673cb07e3e5871379ca"},
+    {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc0f794e6ad661e321caa8d2f0a55ce01213c74722587256fb6566049a8b04"},
+    {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9db1c18f0eaad2f804728c67d6c610778456e3e1cc4ab4bbd5eeb8e6053c6fc"},
+    {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7170375bcc99f1a2fbd9c306f5be8764eaf3ac6b5cb968862cad4c7057756506"},
+    {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b66c9c1e7ccabad3a7d037b2bcb740122a7b17a53734b7d72a344ce39882a1b"},
+    {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:098d86f528c855ead3479afe84b49242e174ed262456c342d70fc7f972bc13c4"},
+    {file = "greenlet-3.0.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:81bb9c6d52e8321f09c3d165b2a78c680506d9af285bfccbad9fb7ad5a5da3e5"},
+    {file = "greenlet-3.0.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:fd096eb7ffef17c456cfa587523c5f92321ae02427ff955bebe9e3c63bc9f0da"},
+    {file = "greenlet-3.0.3-cp38-cp38-win32.whl", hash = "sha256:d46677c85c5ba00a9cb6f7a00b2bfa6f812192d2c9f7d9c4f6a55b60216712f3"},
+    {file = "greenlet-3.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:419b386f84949bf0e7c73e6032e3457b82a787c1ab4a0e43732898a761cc9dbf"},
+    {file = "greenlet-3.0.3-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:da70d4d51c8b306bb7a031d5cff6cc25ad253affe89b70352af5f1cb68e74b53"},
+    {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:086152f8fbc5955df88382e8a75984e2bb1c892ad2e3c80a2508954e52295257"},
+    {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d73a9fe764d77f87f8ec26a0c85144d6a951a6c438dfe50487df5595c6373eac"},
+    {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7dcbe92cc99f08c8dd11f930de4d99ef756c3591a5377d1d9cd7dd5e896da71"},
+    {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1551a8195c0d4a68fac7a4325efac0d541b48def35feb49d803674ac32582f61"},
+    {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:64d7675ad83578e3fc149b617a444fab8efdafc9385471f868eb5ff83e446b8b"},
+    {file = "greenlet-3.0.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b37eef18ea55f2ffd8f00ff8fe7c8d3818abd3e25fb73fae2ca3b672e333a7a6"},
+    {file = "greenlet-3.0.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:77457465d89b8263bca14759d7c1684df840b6811b2499838cc5b040a8b5b113"},
+    {file = "greenlet-3.0.3-cp39-cp39-win32.whl", hash = "sha256:57e8974f23e47dac22b83436bdcf23080ade568ce77df33159e019d161ce1d1e"},
+    {file = "greenlet-3.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:c5ee858cfe08f34712f548c3c363e807e7186f03ad7a5039ebadb29e8c6be067"},
+    {file = "greenlet-3.0.3.tar.gz", hash = "sha256:43374442353259554ce33599da8b692d5aa96f8976d567d4badf263371fbe491"},
+]
+
+[package.extras]
+docs = ["Sphinx", "furo"]
+test = ["objgraph", "psutil"]
+
+[[package]]
+name = "h11"
+version = "0.14.0"
+description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"},
+    {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"},
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.5"
+description = "A minimal low-level HTTP client."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"},
+    {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"},
+]
+
+[package.dependencies]
+certifi = "*"
+h11 = ">=0.13,<0.15"
+
+[package.extras]
+asyncio = ["anyio (>=4.0,<5.0)"]
+http2 = ["h2 (>=3,<5)"]
+socks = ["socksio (==1.*)"]
+trio = ["trio (>=0.22.0,<0.26.0)"]
+
+[[package]]
+name = "httptools"
+version = "0.2.0"
+description = "A collection of framework independent HTTP protocol utils."
+optional = false
+python-versions = "*"
+files = [
+    {file = "httptools-0.2.0-cp35-cp35m-macosx_10_14_x86_64.whl", hash = "sha256:79dbc21f3612a78b28384e989b21872e2e3cf3968532601544696e4ed0007ce5"},
+    {file = "httptools-0.2.0-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:78d03dd39b09c99ec917d50189e6743adbfd18c15d5944392d2eabda688bf149"},
+    {file = "httptools-0.2.0-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:a23166e5ae2775709cf4f7ad4c2048755ebfb272767d244e1a96d55ac775cca7"},
+    {file = "httptools-0.2.0-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:3ab1f390d8867f74b3b5ee2a7ecc9b8d7f53750bd45714bf1cb72a953d7dfa77"},
+    {file = "httptools-0.2.0-cp36-cp36m-win_amd64.whl", hash = "sha256:a7594f9a010cdf1e16a58b3bf26c9da39bbf663e3b8d46d39176999d71816658"},
+    {file = "httptools-0.2.0-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:01b392a166adcc8bc2f526a939a8aabf89fe079243e1543fd0e7dc1b58d737cb"},
+    {file = "httptools-0.2.0-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:80ffa04fe8c8dfacf6e4cef8277347d35b0442c581f5814f3b0cf41b65c43c6e"},
+    {file = "httptools-0.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d5682eeb10cca0606c4a8286a3391d4c3c5a36f0c448e71b8bd05be4e1694bfb"},
+    {file = "httptools-0.2.0-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:a289c27ccae399a70eacf32df9a44059ca2ba4ac444604b00a19a6c1f0809943"},
+    {file = "httptools-0.2.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:813871f961edea6cb2fe312f2d9b27d12a51ba92545380126f80d0de1917ea15"},
+    {file = "httptools-0.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:cc9be041e428c10f8b6ab358c6b393648f9457094e1dcc11b4906026d43cd380"},
+    {file = "httptools-0.2.0-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:b08d00d889a118f68f37f3c43e359aab24ee29eb2e3fe96d64c6a2ba8b9d6557"},
+    {file = "httptools-0.2.0-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:fd3b8905e21431ad306eeaf56644a68fdd621bf8f3097eff54d0f6bdf7262065"},
+    {file = "httptools-0.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:200fc1cdf733a9ff554c0bb97a4047785cfaad9875307d6087001db3eb2b417f"},
+    {file = "httptools-0.2.0.tar.gz", hash = "sha256:94505026be56652d7a530ab03d89474dc6021019d6b8682281977163b3471ea0"},
+]
+
+[package.extras]
+test = ["Cython (==0.29.22)"]
+
+[[package]]
+name = "httpx"
+version = "0.27.0"
+description = "The next generation HTTP client."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "httpx-0.27.0-py3-none-any.whl", hash = "sha256:71d5465162c13681bff01ad59b2cc68dd838ea1f10e51574bac27103f00c91a5"},
+    {file = "httpx-0.27.0.tar.gz", hash = "sha256:a0cb88a46f32dc874e04ee956e4c2764aba2aa228f650b06788ba6bda2962ab5"},
+]
+
+[package.dependencies]
+anyio = "*"
+certifi = "*"
+httpcore = "==1.*"
+idna = "*"
+sniffio = "*"
+
+[package.extras]
+brotli = ["brotli", "brotlicffi"]
+cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
+http2 = ["h2 (>=3,<5)"]
+socks = ["socksio (==1.*)"]
+
+[[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 = "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 = "ipdb"
+version = "0.13.13"
+description = "IPython-enabled pdb"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"},
+    {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"},
+]
+
+[package.dependencies]
+decorator = {version = "*", markers = "python_version > \"3.6\" and python_version < \"3.11\""}
+ipython = {version = ">=7.31.1", markers = "python_version > \"3.6\" and python_version < \"3.11\""}
+tomli = {version = "*", markers = "python_version > \"3.6\" and python_version < \"3.11\""}
+
+[[package]]
+name = "ipykernel"
+version = "6.29.5"
+description = "IPython Kernel for Jupyter"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"},
+    {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"},
+]
+
+[package.dependencies]
+appnope = {version = "*", markers = "platform_system == \"Darwin\""}
+comm = ">=0.1.1"
+debugpy = ">=1.6.5"
+ipython = ">=7.23.1"
+jupyter-client = ">=6.1.12"
+jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0"
+matplotlib-inline = ">=0.1"
+nest-asyncio = "*"
+packaging = "*"
+psutil = "*"
+pyzmq = ">=24"
+tornado = ">=6.1"
+traitlets = ">=5.4.0"
+
+[package.extras]
+cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"]
+docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"]
+pyqt5 = ["pyqt5"]
+pyside6 = ["pyside6"]
+test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.23.5)", "pytest-cov", "pytest-timeout"]
+
+[[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 = "*"
+exceptiongroup = {version = "*", markers = "python_version < \"3.11\""}
+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.12.0"
+description = "A Python utility / library to sort Python imports."
+optional = false
+python-versions = ">=3.8.0"
+files = [
+    {file = "isort-5.12.0-py3-none-any.whl", hash = "sha256:f84c2818376e66cf843d497486ea8fed8700b340f308f076c6fb1229dff318b6"},
+    {file = "isort-5.12.0.tar.gz", hash = "sha256:8bef7dde241278824a6d83f44a544709b065191b95b6e50894bdc722fcba0504"},
+]
+
+[package.extras]
+colors = ["colorama (>=0.4.3)"]
+pipfile-deprecated-finder = ["pip-shims (>=0.5.2)", "pipreqs", "requirementslib"]
+plugins = ["setuptools"]
+requirements-deprecated-finder = ["pip-api", "pipreqs"]
+
+[[package]]
+name = "itsdangerous"
+version = "2.2.0"
+description = "Safely pass data to untrusted environments and back."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef"},
+    {file = "itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173"},
+]
+
+[[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 = "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 = "joblib"
+version = "1.4.2"
+description = "Lightweight pipelining with Python functions"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"},
+    {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"},
+]
+
+[[package]]
+name = "jupyter-client"
+version = "8.6.2"
+description = "Jupyter protocol implementation and client libraries"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "jupyter_client-8.6.2-py3-none-any.whl", hash = "sha256:50cbc5c66fd1b8f65ecb66bc490ab73217993632809b6e505687de18e9dea39f"},
+    {file = "jupyter_client-8.6.2.tar.gz", hash = "sha256:2bda14d55ee5ba58552a8c53ae43d215ad9868853489213f37da060ced54d8df"},
+]
+
+[package.dependencies]
+jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0"
+python-dateutil = ">=2.8.2"
+pyzmq = ">=23.0"
+tornado = ">=6.2"
+traitlets = ">=5.3"
+
+[package.extras]
+docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"]
+test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest (<8.2.0)", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"]
+
+[[package]]
+name = "jupyter-core"
+version = "5.7.2"
+description = "Jupyter core package. A base package on which Jupyter projects rely."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"},
+    {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"},
+]
+
+[package.dependencies]
+platformdirs = ">=2.5"
+pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""}
+traitlets = ">=5.3"
+
+[package.extras]
+docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"]
+test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"]
+
+[[package]]
+name = "kiwisolver"
+version = "1.4.5"
+description = "A fast implementation of the Cassowary constraint solver"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"},
+    {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"},
+    {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"},
+    {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"},
+    {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"},
+    {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"},
+    {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"},
+    {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"},
+    {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"},
+    {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"},
+    {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"},
+]
+
+[[package]]
+name = "locust"
+version = "2.29.1"
+description = "Developer-friendly load testing framework"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "locust-2.29.1-py3-none-any.whl", hash = "sha256:8b15daab44cdf50eef1860a32bb30969423e3795247115e5a37446da3240c6d6"},
+    {file = "locust-2.29.1.tar.gz", hash = "sha256:2e0628a59e2689a50cb4735a9a43709e30f2da7ed276c15d877c5325507f44b1"},
+]
+
+[package.dependencies]
+ConfigArgParse = ">=1.5.5"
+flask = ">=2.0.0"
+Flask-Cors = ">=3.0.10"
+Flask-Login = ">=0.6.3"
+gevent = ">=22.10.2"
+geventhttpclient = ">=2.3.1"
+msgpack = ">=1.0.0"
+psutil = ">=5.9.1"
+pywin32 = {version = "*", markers = "platform_system == \"Windows\""}
+pyzmq = ">=25.0.0"
+requests = ">=2.26.0"
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+typing-extensions = {version = ">=4.6.0", markers = "python_version < \"3.11\""}
+Werkzeug = ">=2.0.0"
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+description = "Python port of markdown-it. Markdown parsing, done right!"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"},
+    {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"},
+]
+
+[package.dependencies]
+mdurl = ">=0.1,<1.0"
+
+[package.extras]
+benchmarking = ["psutil", "pytest", "pytest-benchmark"]
+code-style = ["pre-commit (>=3.0,<4.0)"]
+compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"]
+linkify = ["linkify-it-py (>=1,<3)"]
+plugins = ["mdit-py-plugins"]
+profiling = ["gprof2dot"]
+rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"]
+testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"]
+
+[[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"
+version = "3.7.5"
+description = "Python plotting package"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "matplotlib-3.7.5-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:4a87b69cb1cb20943010f63feb0b2901c17a3b435f75349fd9865713bfa63925"},
+    {file = "matplotlib-3.7.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d3ce45010fefb028359accebb852ca0c21bd77ec0f281952831d235228f15810"},
+    {file = "matplotlib-3.7.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fbea1e762b28400393d71be1a02144aa16692a3c4c676ba0178ce83fc2928fdd"},
+    {file = "matplotlib-3.7.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec0e1adc0ad70ba8227e957551e25a9d2995e319c29f94a97575bb90fa1d4469"},
+    {file = "matplotlib-3.7.5-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6738c89a635ced486c8a20e20111d33f6398a9cbebce1ced59c211e12cd61455"},
+    {file = "matplotlib-3.7.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1210b7919b4ed94b5573870f316bca26de3e3b07ffdb563e79327dc0e6bba515"},
+    {file = "matplotlib-3.7.5-cp310-cp310-win32.whl", hash = "sha256:068ebcc59c072781d9dcdb82f0d3f1458271c2de7ca9c78f5bd672141091e9e1"},
+    {file = "matplotlib-3.7.5-cp310-cp310-win_amd64.whl", hash = "sha256:f098ffbaab9df1e3ef04e5a5586a1e6b1791380698e84938d8640961c79b1fc0"},
+    {file = "matplotlib-3.7.5-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:f65342c147572673f02a4abec2d5a23ad9c3898167df9b47c149f32ce61ca078"},
+    {file = "matplotlib-3.7.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4ddf7fc0e0dc553891a117aa083039088d8a07686d4c93fb8a810adca68810af"},
+    {file = "matplotlib-3.7.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0ccb830fc29442360d91be48527809f23a5dcaee8da5f4d9b2d5b867c1b087b8"},
+    {file = "matplotlib-3.7.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efc6bb28178e844d1f408dd4d6341ee8a2e906fc9e0fa3dae497da4e0cab775d"},
+    {file = "matplotlib-3.7.5-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b15c4c2d374f249f324f46e883340d494c01768dd5287f8bc00b65b625ab56c"},
+    {file = "matplotlib-3.7.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d028555421912307845e59e3de328260b26d055c5dac9b182cc9783854e98fb"},
+    {file = "matplotlib-3.7.5-cp311-cp311-win32.whl", hash = "sha256:fe184b4625b4052fa88ef350b815559dd90cc6cc8e97b62f966e1ca84074aafa"},
+    {file = "matplotlib-3.7.5-cp311-cp311-win_amd64.whl", hash = "sha256:084f1f0f2f1010868c6f1f50b4e1c6f2fb201c58475494f1e5b66fed66093647"},
+    {file = "matplotlib-3.7.5-cp312-cp312-macosx_10_12_universal2.whl", hash = "sha256:34bceb9d8ddb142055ff27cd7135f539f2f01be2ce0bafbace4117abe58f8fe4"},
+    {file = "matplotlib-3.7.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c5a2134162273eb8cdfd320ae907bf84d171de948e62180fa372a3ca7cf0f433"},
+    {file = "matplotlib-3.7.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:039ad54683a814002ff37bf7981aa1faa40b91f4ff84149beb53d1eb64617980"},
+    {file = "matplotlib-3.7.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d742ccd1b09e863b4ca58291728db645b51dab343eebb08d5d4b31b308296ce"},
+    {file = "matplotlib-3.7.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:743b1c488ca6a2bc7f56079d282e44d236bf375968bfd1b7ba701fd4d0fa32d6"},
+    {file = "matplotlib-3.7.5-cp312-cp312-win_amd64.whl", hash = "sha256:fbf730fca3e1f23713bc1fae0a57db386e39dc81ea57dc305c67f628c1d7a342"},
+    {file = "matplotlib-3.7.5-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:cfff9b838531698ee40e40ea1a8a9dc2c01edb400b27d38de6ba44c1f9a8e3d2"},
+    {file = "matplotlib-3.7.5-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:1dbcca4508bca7847fe2d64a05b237a3dcaec1f959aedb756d5b1c67b770c5ee"},
+    {file = "matplotlib-3.7.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4cdf4ef46c2a1609a50411b66940b31778db1e4b73d4ecc2eaa40bd588979b13"},
+    {file = "matplotlib-3.7.5-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:167200ccfefd1674b60e957186dfd9baf58b324562ad1a28e5d0a6b3bea77905"},
+    {file = "matplotlib-3.7.5-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:53e64522934df6e1818b25fd48cf3b645b11740d78e6ef765fbb5fa5ce080d02"},
+    {file = "matplotlib-3.7.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3e3bc79b2d7d615067bd010caff9243ead1fc95cf735c16e4b2583173f717eb"},
+    {file = "matplotlib-3.7.5-cp38-cp38-win32.whl", hash = "sha256:6b641b48c6819726ed47c55835cdd330e53747d4efff574109fd79b2d8a13748"},
+    {file = "matplotlib-3.7.5-cp38-cp38-win_amd64.whl", hash = "sha256:f0b60993ed3488b4532ec6b697059897891927cbfc2b8d458a891b60ec03d9d7"},
+    {file = "matplotlib-3.7.5-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:090964d0afaff9c90e4d8de7836757e72ecfb252fb02884016d809239f715651"},
+    {file = "matplotlib-3.7.5-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:9fc6fcfbc55cd719bc0bfa60bde248eb68cf43876d4c22864603bdd23962ba25"},
+    {file = "matplotlib-3.7.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5e7cc3078b019bb863752b8b60e8b269423000f1603cb2299608231996bd9d54"},
+    {file = "matplotlib-3.7.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e4e9a868e8163abaaa8259842d85f949a919e1ead17644fb77a60427c90473c"},
+    {file = "matplotlib-3.7.5-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fa7ebc995a7d747dacf0a717d0eb3aa0f0c6a0e9ea88b0194d3a3cd241a1500f"},
+    {file = "matplotlib-3.7.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3785bfd83b05fc0e0c2ae4c4a90034fe693ef96c679634756c50fe6efcc09856"},
+    {file = "matplotlib-3.7.5-cp39-cp39-win32.whl", hash = "sha256:29b058738c104d0ca8806395f1c9089dfe4d4f0f78ea765c6c704469f3fffc81"},
+    {file = "matplotlib-3.7.5-cp39-cp39-win_amd64.whl", hash = "sha256:fd4028d570fa4b31b7b165d4a685942ae9cdc669f33741e388c01857d9723eab"},
+    {file = "matplotlib-3.7.5-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2a9a3f4d6a7f88a62a6a18c7e6a84aedcaf4faf0708b4ca46d87b19f1b526f88"},
+    {file = "matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9b3fd853d4a7f008a938df909b96db0b454225f935d3917520305b90680579c"},
+    {file = "matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0ad550da9f160737d7890217c5eeed4337d07e83ca1b2ca6535078f354e7675"},
+    {file = "matplotlib-3.7.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:20da7924a08306a861b3f2d1da0d1aa9a6678e480cf8eacffe18b565af2813e7"},
+    {file = "matplotlib-3.7.5-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b45c9798ea6bb920cb77eb7306409756a7fab9db9b463e462618e0559aecb30e"},
+    {file = "matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a99866267da1e561c7776fe12bf4442174b79aac1a47bd7e627c7e4d077ebd83"},
+    {file = "matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b6aa62adb6c268fc87d80f963aca39c64615c31830b02697743c95590ce3fbb"},
+    {file = "matplotlib-3.7.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e530ab6a0afd082d2e9c17eb1eb064a63c5b09bb607b2b74fa41adbe3e162286"},
+    {file = "matplotlib-3.7.5.tar.gz", hash = "sha256:1e5c971558ebc811aa07f54c7b7c677d78aa518ef4c390e14673a09e0860184a"},
+]
+
+[package.dependencies]
+contourpy = ">=1.0.1"
+cycler = ">=0.10"
+fonttools = ">=4.22.0"
+kiwisolver = ">=1.0.1"
+numpy = ">=1.20,<2"
+packaging = ">=20.0"
+pillow = ">=6.2.0"
+pyparsing = ">=2.3.1"
+python-dateutil = ">=2.7"
+
+[[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 = "mdurl"
+version = "0.1.2"
+description = "Markdown URL utilities"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"},
+    {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"},
+]
+
+[[package]]
+name = "mockito"
+version = "1.2.2"
+description = "Spying framework"
+optional = false
+python-versions = "*"
+files = [
+    {file = "mockito-1.2.2.tar.gz", hash = "sha256:d6b3aca6cdb92bbd47e19ebdb1a0b84ef23ab874eae5c6d505323c8657257c06"},
+]
+
+[[package]]
+name = "msgpack"
+version = "1.0.8"
+description = "MessagePack serializer"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "msgpack-1.0.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:505fe3d03856ac7d215dbe005414bc28505d26f0c128906037e66d98c4e95868"},
+    {file = "msgpack-1.0.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b7842518a63a9f17107eb176320960ec095a8ee3b4420b5f688e24bf50c53c"},
+    {file = "msgpack-1.0.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:376081f471a2ef24828b83a641a02c575d6103a3ad7fd7dade5486cad10ea659"},
+    {file = "msgpack-1.0.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e390971d082dba073c05dbd56322427d3280b7cc8b53484c9377adfbae67dc2"},
+    {file = "msgpack-1.0.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e073efcba9ea99db5acef3959efa45b52bc67b61b00823d2a1a6944bf45982"},
+    {file = "msgpack-1.0.8-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82d92c773fbc6942a7a8b520d22c11cfc8fd83bba86116bfcf962c2f5c2ecdaa"},
+    {file = "msgpack-1.0.8-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9ee32dcb8e531adae1f1ca568822e9b3a738369b3b686d1477cbc643c4a9c128"},
+    {file = "msgpack-1.0.8-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e3aa7e51d738e0ec0afbed661261513b38b3014754c9459508399baf14ae0c9d"},
+    {file = "msgpack-1.0.8-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:69284049d07fce531c17404fcba2bb1df472bc2dcdac642ae71a2d079d950653"},
+    {file = "msgpack-1.0.8-cp310-cp310-win32.whl", hash = "sha256:13577ec9e247f8741c84d06b9ece5f654920d8365a4b636ce0e44f15e07ec693"},
+    {file = "msgpack-1.0.8-cp310-cp310-win_amd64.whl", hash = "sha256:e532dbd6ddfe13946de050d7474e3f5fb6ec774fbb1a188aaf469b08cf04189a"},
+    {file = "msgpack-1.0.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9517004e21664f2b5a5fd6333b0731b9cf0817403a941b393d89a2f1dc2bd836"},
+    {file = "msgpack-1.0.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d16a786905034e7e34098634b184a7d81f91d4c3d246edc6bd7aefb2fd8ea6ad"},
+    {file = "msgpack-1.0.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2872993e209f7ed04d963e4b4fbae72d034844ec66bc4ca403329db2074377b"},
+    {file = "msgpack-1.0.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c330eace3dd100bdb54b5653b966de7f51c26ec4a7d4e87132d9b4f738220ba"},
+    {file = "msgpack-1.0.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83b5c044f3eff2a6534768ccfd50425939e7a8b5cf9a7261c385de1e20dcfc85"},
+    {file = "msgpack-1.0.8-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1876b0b653a808fcd50123b953af170c535027bf1d053b59790eebb0aeb38950"},
+    {file = "msgpack-1.0.8-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:dfe1f0f0ed5785c187144c46a292b8c34c1295c01da12e10ccddfc16def4448a"},
+    {file = "msgpack-1.0.8-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3528807cbbb7f315bb81959d5961855e7ba52aa60a3097151cb21956fbc7502b"},
+    {file = "msgpack-1.0.8-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e2f879ab92ce502a1e65fce390eab619774dda6a6ff719718069ac94084098ce"},
+    {file = "msgpack-1.0.8-cp311-cp311-win32.whl", hash = "sha256:26ee97a8261e6e35885c2ecd2fd4a6d38252246f94a2aec23665a4e66d066305"},
+    {file = "msgpack-1.0.8-cp311-cp311-win_amd64.whl", hash = "sha256:eadb9f826c138e6cf3c49d6f8de88225a3c0ab181a9b4ba792e006e5292d150e"},
+    {file = "msgpack-1.0.8-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:114be227f5213ef8b215c22dde19532f5da9652e56e8ce969bf0a26d7c419fee"},
+    {file = "msgpack-1.0.8-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d661dc4785affa9d0edfdd1e59ec056a58b3dbb9f196fa43587f3ddac654ac7b"},
+    {file = "msgpack-1.0.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d56fd9f1f1cdc8227d7b7918f55091349741904d9520c65f0139a9755952c9e8"},
+    {file = "msgpack-1.0.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0726c282d188e204281ebd8de31724b7d749adebc086873a59efb8cf7ae27df3"},
+    {file = "msgpack-1.0.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8db8e423192303ed77cff4dce3a4b88dbfaf43979d280181558af5e2c3c71afc"},
+    {file = "msgpack-1.0.8-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99881222f4a8c2f641f25703963a5cefb076adffd959e0558dc9f803a52d6a58"},
+    {file = "msgpack-1.0.8-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b5505774ea2a73a86ea176e8a9a4a7c8bf5d521050f0f6f8426afe798689243f"},
+    {file = "msgpack-1.0.8-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:ef254a06bcea461e65ff0373d8a0dd1ed3aa004af48839f002a0c994a6f72d04"},
+    {file = "msgpack-1.0.8-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e1dd7839443592d00e96db831eddb4111a2a81a46b028f0facd60a09ebbdd543"},
+    {file = "msgpack-1.0.8-cp312-cp312-win32.whl", hash = "sha256:64d0fcd436c5683fdd7c907eeae5e2cbb5eb872fafbc03a43609d7941840995c"},
+    {file = "msgpack-1.0.8-cp312-cp312-win_amd64.whl", hash = "sha256:74398a4cf19de42e1498368c36eed45d9528f5fd0155241e82c4082b7e16cffd"},
+    {file = "msgpack-1.0.8-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:0ceea77719d45c839fd73abcb190b8390412a890df2f83fb8cf49b2a4b5c2f40"},
+    {file = "msgpack-1.0.8-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1ab0bbcd4d1f7b6991ee7c753655b481c50084294218de69365f8f1970d4c151"},
+    {file = "msgpack-1.0.8-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1cce488457370ffd1f953846f82323cb6b2ad2190987cd4d70b2713e17268d24"},
+    {file = "msgpack-1.0.8-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3923a1778f7e5ef31865893fdca12a8d7dc03a44b33e2a5f3295416314c09f5d"},
+    {file = "msgpack-1.0.8-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a22e47578b30a3e199ab067a4d43d790249b3c0587d9a771921f86250c8435db"},
+    {file = "msgpack-1.0.8-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd739c9251d01e0279ce729e37b39d49a08c0420d3fee7f2a4968c0576678f77"},
+    {file = "msgpack-1.0.8-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:d3420522057ebab1728b21ad473aa950026d07cb09da41103f8e597dfbfaeb13"},
+    {file = "msgpack-1.0.8-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:5845fdf5e5d5b78a49b826fcdc0eb2e2aa7191980e3d2cfd2a30303a74f212e2"},
+    {file = "msgpack-1.0.8-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6a0e76621f6e1f908ae52860bdcb58e1ca85231a9b0545e64509c931dd34275a"},
+    {file = "msgpack-1.0.8-cp38-cp38-win32.whl", hash = "sha256:374a8e88ddab84b9ada695d255679fb99c53513c0a51778796fcf0944d6c789c"},
+    {file = "msgpack-1.0.8-cp38-cp38-win_amd64.whl", hash = "sha256:f3709997b228685fe53e8c433e2df9f0cdb5f4542bd5114ed17ac3c0129b0480"},
+    {file = "msgpack-1.0.8-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f51bab98d52739c50c56658cc303f190785f9a2cd97b823357e7aeae54c8f68a"},
+    {file = "msgpack-1.0.8-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:73ee792784d48aa338bba28063e19a27e8d989344f34aad14ea6e1b9bd83f596"},
+    {file = "msgpack-1.0.8-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f9904e24646570539a8950400602d66d2b2c492b9010ea7e965025cb71d0c86d"},
+    {file = "msgpack-1.0.8-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e75753aeda0ddc4c28dce4c32ba2f6ec30b1b02f6c0b14e547841ba5b24f753f"},
+    {file = "msgpack-1.0.8-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5dbf059fb4b7c240c873c1245ee112505be27497e90f7c6591261c7d3c3a8228"},
+    {file = "msgpack-1.0.8-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4916727e31c28be8beaf11cf117d6f6f188dcc36daae4e851fee88646f5b6b18"},
+    {file = "msgpack-1.0.8-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7938111ed1358f536daf311be244f34df7bf3cdedb3ed883787aca97778b28d8"},
+    {file = "msgpack-1.0.8-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:493c5c5e44b06d6c9268ce21b302c9ca055c1fd3484c25ba41d34476c76ee746"},
+    {file = "msgpack-1.0.8-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fbb160554e319f7b22ecf530a80a3ff496d38e8e07ae763b9e82fadfe96f273"},
+    {file = "msgpack-1.0.8-cp39-cp39-win32.whl", hash = "sha256:f9af38a89b6a5c04b7d18c492c8ccf2aee7048aff1ce8437c4683bb5a1df893d"},
+    {file = "msgpack-1.0.8-cp39-cp39-win_amd64.whl", hash = "sha256:ed59dd52075f8fc91da6053b12e8c89e37aa043f8986efd89e61fae69dc1b011"},
+    {file = "msgpack-1.0.8.tar.gz", hash = "sha256:95c02b0e27e706e48d0e5426d1710ca78e0f0628d6e89d5b5a5b91a5f12274f3"},
+]
+
+[[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 = "nest-asyncio"
+version = "1.6.0"
+description = "Patch asyncio to allow nested event loops"
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"},
+    {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"},
+]
+
+[[package]]
+name = "numpy"
+version = "1.22.4"
+description = "NumPy is the fundamental package for array computing with Python."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "numpy-1.22.4-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:ba9ead61dfb5d971d77b6c131a9dbee62294a932bf6a356e48c75ae684e635b3"},
+    {file = "numpy-1.22.4-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:1ce7ab2053e36c0a71e7a13a7475bd3b1f54750b4b433adc96313e127b870887"},
+    {file = "numpy-1.22.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7228ad13744f63575b3a972d7ee4fd61815b2879998e70930d4ccf9ec721dce0"},
+    {file = "numpy-1.22.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:43a8ca7391b626b4c4fe20aefe79fec683279e31e7c79716863b4b25021e0e74"},
+    {file = "numpy-1.22.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a911e317e8c826ea632205e63ed8507e0dc877dcdc49744584dfc363df9ca08c"},
+    {file = "numpy-1.22.4-cp310-cp310-win32.whl", hash = "sha256:9ce7df0abeabe7fbd8ccbf343dc0db72f68549856b863ae3dd580255d009648e"},
+    {file = "numpy-1.22.4-cp310-cp310-win_amd64.whl", hash = "sha256:3e1ffa4748168e1cc8d3cde93f006fe92b5421396221a02f2274aab6ac83b077"},
+    {file = "numpy-1.22.4-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:59d55e634968b8f77d3fd674a3cf0b96e85147cd6556ec64ade018f27e9479e1"},
+    {file = "numpy-1.22.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c1d937820db6e43bec43e8d016b9b3165dcb42892ea9f106c70fb13d430ffe72"},
+    {file = "numpy-1.22.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4c5d5eb2ec8da0b4f50c9a843393971f31f1d60be87e0fb0917a49133d257d6"},
+    {file = "numpy-1.22.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64f56fc53a2d18b1924abd15745e30d82a5782b2cab3429aceecc6875bd5add0"},
+    {file = "numpy-1.22.4-cp38-cp38-win32.whl", hash = "sha256:fb7a980c81dd932381f8228a426df8aeb70d59bbcda2af075b627bbc50207cba"},
+    {file = "numpy-1.22.4-cp38-cp38-win_amd64.whl", hash = "sha256:e96d7f3096a36c8754207ab89d4b3282ba7b49ea140e4973591852c77d09eb76"},
+    {file = "numpy-1.22.4-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:4c6036521f11a731ce0648f10c18ae66d7143865f19f7299943c985cdc95afb5"},
+    {file = "numpy-1.22.4-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:b89bf9b94b3d624e7bb480344e91f68c1c6c75f026ed6755955117de00917a7c"},
+    {file = "numpy-1.22.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2d487e06ecbf1dc2f18e7efce82ded4f705f4bd0cd02677ffccfb39e5c284c7e"},
+    {file = "numpy-1.22.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3eb268dbd5cfaffd9448113539e44e2dd1c5ca9ce25576f7c04a5453edc26fa"},
+    {file = "numpy-1.22.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37431a77ceb9307c28382c9773da9f306435135fae6b80b62a11c53cfedd8802"},
+    {file = "numpy-1.22.4-cp39-cp39-win32.whl", hash = "sha256:cc7f00008eb7d3f2489fca6f334ec19ca63e31371be28fd5dad955b16ec285bd"},
+    {file = "numpy-1.22.4-cp39-cp39-win_amd64.whl", hash = "sha256:f0725df166cf4785c0bc4cbfb320203182b1ecd30fee6e541c8752a92df6aa32"},
+    {file = "numpy-1.22.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0791fbd1e43bf74b3502133207e378901272f3c156c4df4954cad833b1380207"},
+    {file = "numpy-1.22.4.zip", hash = "sha256:425b390e4619f58d8526b3dcf656dde069133ae5c240229821f01b5f44ea07af"},
+]
+
+[[package]]
+name = "nvidia-nccl-cu12"
+version = "2.22.3"
+description = "NVIDIA Collective Communication Library (NCCL) Runtime"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_nccl_cu12-2.22.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f9f5e03c00269dee2cd1aa57019f9a024478a74ae6e9b32d5341c849fe6f6302"},
+]
+
+[[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 = "1.3.5"
+description = "Powerful data structures for data analysis, time series, and statistics"
+optional = false
+python-versions = ">=3.7.1"
+files = [
+    {file = "pandas-1.3.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:62d5b5ce965bae78f12c1c0df0d387899dd4211ec0bdc52822373f13a3a022b9"},
+    {file = "pandas-1.3.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:adfeb11be2d54f275142c8ba9bf67acee771b7186a5745249c7d5a06c670136b"},
+    {file = "pandas-1.3.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:60a8c055d58873ad81cae290d974d13dd479b82cbb975c3e1fa2cf1920715296"},
+    {file = "pandas-1.3.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd541ab09e1f80a2a1760032d665f6e032d8e44055d602d65eeea6e6e85498cb"},
+    {file = "pandas-1.3.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2651d75b9a167cc8cc572cf787ab512d16e316ae00ba81874b560586fa1325e0"},
+    {file = "pandas-1.3.5-cp310-cp310-win_amd64.whl", hash = "sha256:aaf183a615ad790801fa3cf2fa450e5b6d23a54684fe386f7e3208f8b9bfbef6"},
+    {file = "pandas-1.3.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:344295811e67f8200de2390093aeb3c8309f5648951b684d8db7eee7d1c81fb7"},
+    {file = "pandas-1.3.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:552020bf83b7f9033b57cbae65589c01e7ef1544416122da0c79140c93288f56"},
+    {file = "pandas-1.3.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5cce0c6bbeb266b0e39e35176ee615ce3585233092f685b6a82362523e59e5b4"},
+    {file = "pandas-1.3.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d28a3c65463fd0d0ba8bbb7696b23073efee0510783340a44b08f5e96ffce0c"},
+    {file = "pandas-1.3.5-cp37-cp37m-win32.whl", hash = "sha256:a62949c626dd0ef7de11de34b44c6475db76995c2064e2d99c6498c3dba7fe58"},
+    {file = "pandas-1.3.5-cp37-cp37m-win_amd64.whl", hash = "sha256:8025750767e138320b15ca16d70d5cdc1886e8f9cc56652d89735c016cd8aea6"},
+    {file = "pandas-1.3.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:fe95bae4e2d579812865db2212bb733144e34d0c6785c0685329e5b60fcb85dd"},
+    {file = "pandas-1.3.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f261553a1e9c65b7a310302b9dbac31cf0049a51695c14ebe04e4bfd4a96f02"},
+    {file = "pandas-1.3.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b6dbec5f3e6d5dc80dcfee250e0a2a652b3f28663492f7dab9a24416a48ac39"},
+    {file = "pandas-1.3.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d3bc49af96cd6285030a64779de5b3688633a07eb75c124b0747134a63f4c05f"},
+    {file = "pandas-1.3.5-cp38-cp38-win32.whl", hash = "sha256:b6b87b2fb39e6383ca28e2829cddef1d9fc9e27e55ad91ca9c435572cdba51bf"},
+    {file = "pandas-1.3.5-cp38-cp38-win_amd64.whl", hash = "sha256:a395692046fd8ce1edb4c6295c35184ae0c2bbe787ecbe384251da609e27edcb"},
+    {file = "pandas-1.3.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bd971a3f08b745a75a86c00b97f3007c2ea175951286cdda6abe543e687e5f2f"},
+    {file = "pandas-1.3.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37f06b59e5bc05711a518aa10beaec10942188dccb48918bb5ae602ccbc9f1a0"},
+    {file = "pandas-1.3.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c21778a688d3712d35710501f8001cdbf96eb70a7c587a3d5613573299fdca6"},
+    {file = "pandas-1.3.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3345343206546545bc26a05b4602b6a24385b5ec7c75cb6059599e3d56831da2"},
+    {file = "pandas-1.3.5-cp39-cp39-win32.whl", hash = "sha256:c69406a2808ba6cf580c2255bcf260b3f214d2664a3a4197d0e640f573b46fd3"},
+    {file = "pandas-1.3.5-cp39-cp39-win_amd64.whl", hash = "sha256:32e1a26d5ade11b547721a72f9bfc4bd113396947606e00d5b4a5b79b3dcb006"},
+    {file = "pandas-1.3.5.tar.gz", hash = "sha256:1e4285f5de1012de20ca46b188ccf33521bff61ba5c5ebd78b4fb28e5416a9f1"},
+]
+
+[package.dependencies]
+numpy = {version = ">=1.21.0", markers = "python_version >= \"3.10\""}
+python-dateutil = ">=2.7.3"
+pytz = ">=2017.3"
+
+[package.extras]
+test = ["hypothesis (>=3.58)", "pytest (>=6.0)", "pytest-xdist"]
+
+[[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 = "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 = "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 = "psutil"
+version = "6.0.0"
+description = "Cross-platform lib for process and system monitoring in Python."
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
+files = [
+    {file = "psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a021da3e881cd935e64a3d0a20983bda0bb4cf80e4f74fa9bfcb1bc5785360c6"},
+    {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:1287c2b95f1c0a364d23bc6f2ea2365a8d4d9b726a3be7294296ff7ba97c17f0"},
+    {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:a9a3dbfb4de4f18174528d87cc352d1f788b7496991cca33c6996f40c9e3c92c"},
+    {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:6ec7588fb3ddaec7344a825afe298db83fe01bfaaab39155fa84cf1c0d6b13c3"},
+    {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:1e7c870afcb7d91fdea2b37c24aeb08f98b6d67257a5cb0a8bc3ac68d0f1a68c"},
+    {file = "psutil-6.0.0-cp27-none-win32.whl", hash = "sha256:02b69001f44cc73c1c5279d02b30a817e339ceb258ad75997325e0e6169d8b35"},
+    {file = "psutil-6.0.0-cp27-none-win_amd64.whl", hash = "sha256:21f1fb635deccd510f69f485b87433460a603919b45e2a324ad65b0cc74f8fb1"},
+    {file = "psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c588a7e9b1173b6e866756dde596fd4cad94f9399daf99ad8c3258b3cb2b47a0"},
+    {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ed2440ada7ef7d0d608f20ad89a04ec47d2d3ab7190896cd62ca5fc4fe08bf0"},
+    {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"},
+    {file = "psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e8d0054fc88153ca0544f5c4d554d42e33df2e009c4ff42284ac9ebdef4132"},
+    {file = "psutil-6.0.0-cp36-cp36m-win32.whl", hash = "sha256:fc8c9510cde0146432bbdb433322861ee8c3efbf8589865c8bf8d21cb30c4d14"},
+    {file = "psutil-6.0.0-cp36-cp36m-win_amd64.whl", hash = "sha256:34859b8d8f423b86e4385ff3665d3f4d94be3cdf48221fbe476e883514fdb71c"},
+    {file = "psutil-6.0.0-cp37-abi3-win32.whl", hash = "sha256:a495580d6bae27291324fe60cea0b5a7c23fa36a7cd35035a16d93bdcf076b9d"},
+    {file = "psutil-6.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"},
+    {file = "psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"},
+    {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"},
+]
+
+[package.extras]
+test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"]
+
+[[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 = "py"
+version = "1.11.0"
+description = "library with cross-python path, ini-parsing, io, code, log facilities"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+files = [
+    {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"},
+    {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"},
+]
+
+[[package]]
+name = "pycodestyle"
+version = "2.10.0"
+description = "Python style guide checker"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "pycodestyle-2.10.0-py2.py3-none-any.whl", hash = "sha256:8a4eaf0d0495c7395bdab3589ac2db602797d76207242c17d470186815706610"},
+    {file = "pycodestyle-2.10.0.tar.gz", hash = "sha256:347187bdb476329d98f695c213d7295a846d1152ff4fe9bacb8a9590b8ee7053"},
+]
+
+[[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 = "pydantic"
+version = "1.10.17"
+description = "Data validation and settings management using python type hints"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "pydantic-1.10.17-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0fa51175313cc30097660b10eec8ca55ed08bfa07acbfe02f7a42f6c242e9a4b"},
+    {file = "pydantic-1.10.17-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7e8988bb16988890c985bd2093df9dd731bfb9d5e0860db054c23034fab8f7a"},
+    {file = "pydantic-1.10.17-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:371dcf1831f87c9e217e2b6a0c66842879a14873114ebb9d0861ab22e3b5bb1e"},
+    {file = "pydantic-1.10.17-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4866a1579c0c3ca2c40575398a24d805d4db6cb353ee74df75ddeee3c657f9a7"},
+    {file = "pydantic-1.10.17-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:543da3c6914795b37785703ffc74ba4d660418620cc273490d42c53949eeeca6"},
+    {file = "pydantic-1.10.17-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7623b59876f49e61c2e283551cc3647616d2fbdc0b4d36d3d638aae8547ea681"},
+    {file = "pydantic-1.10.17-cp310-cp310-win_amd64.whl", hash = "sha256:409b2b36d7d7d19cd8310b97a4ce6b1755ef8bd45b9a2ec5ec2b124db0a0d8f3"},
+    {file = "pydantic-1.10.17-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fa43f362b46741df8f201bf3e7dff3569fa92069bcc7b4a740dea3602e27ab7a"},
+    {file = "pydantic-1.10.17-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2a72d2a5ff86a3075ed81ca031eac86923d44bc5d42e719d585a8eb547bf0c9b"},
+    {file = "pydantic-1.10.17-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4ad32aed3bf5eea5ca5decc3d1bbc3d0ec5d4fbcd72a03cdad849458decbc63"},
+    {file = "pydantic-1.10.17-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aeb4e741782e236ee7dc1fb11ad94dc56aabaf02d21df0e79e0c21fe07c95741"},
+    {file = "pydantic-1.10.17-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:d2f89a719411cb234105735a520b7c077158a81e0fe1cb05a79c01fc5eb59d3c"},
+    {file = "pydantic-1.10.17-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:db3b48d9283d80a314f7a682f7acae8422386de659fffaba454b77a083c3937d"},
+    {file = "pydantic-1.10.17-cp311-cp311-win_amd64.whl", hash = "sha256:9c803a5113cfab7bbb912f75faa4fc1e4acff43e452c82560349fff64f852e1b"},
+    {file = "pydantic-1.10.17-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:820ae12a390c9cbb26bb44913c87fa2ff431a029a785642c1ff11fed0a095fcb"},
+    {file = "pydantic-1.10.17-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c1e51d1af306641b7d1574d6d3307eaa10a4991542ca324f0feb134fee259815"},
+    {file = "pydantic-1.10.17-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e53fb834aae96e7b0dadd6e92c66e7dd9cdf08965340ed04c16813102a47fab"},
+    {file = "pydantic-1.10.17-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e2495309b1266e81d259a570dd199916ff34f7f51f1b549a0d37a6d9b17b4dc"},
+    {file = "pydantic-1.10.17-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:098ad8de840c92ea586bf8efd9e2e90c6339d33ab5c1cfbb85be66e4ecf8213f"},
+    {file = "pydantic-1.10.17-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:525bbef620dac93c430d5d6bdbc91bdb5521698d434adf4434a7ef6ffd5c4b7f"},
+    {file = "pydantic-1.10.17-cp312-cp312-win_amd64.whl", hash = "sha256:6654028d1144df451e1da69a670083c27117d493f16cf83da81e1e50edce72ad"},
+    {file = "pydantic-1.10.17-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c87cedb4680d1614f1d59d13fea353faf3afd41ba5c906a266f3f2e8c245d655"},
+    {file = "pydantic-1.10.17-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11289fa895bcbc8f18704efa1d8020bb9a86314da435348f59745473eb042e6b"},
+    {file = "pydantic-1.10.17-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:94833612d6fd18b57c359a127cbfd932d9150c1b72fea7c86ab58c2a77edd7c7"},
+    {file = "pydantic-1.10.17-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:d4ecb515fa7cb0e46e163ecd9d52f9147ba57bc3633dca0e586cdb7a232db9e3"},
+    {file = "pydantic-1.10.17-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:7017971ffa7fd7808146880aa41b266e06c1e6e12261768a28b8b41ba55c8076"},
+    {file = "pydantic-1.10.17-cp37-cp37m-win_amd64.whl", hash = "sha256:e840e6b2026920fc3f250ea8ebfdedf6ea7a25b77bf04c6576178e681942ae0f"},
+    {file = "pydantic-1.10.17-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bfbb18b616abc4df70591b8c1ff1b3eabd234ddcddb86b7cac82657ab9017e33"},
+    {file = "pydantic-1.10.17-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ebb249096d873593e014535ab07145498957091aa6ae92759a32d40cb9998e2e"},
+    {file = "pydantic-1.10.17-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8c209af63ccd7b22fba94b9024e8b7fd07feffee0001efae50dd99316b27768"},
+    {file = "pydantic-1.10.17-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4b40c9e13a0b61583e5599e7950490c700297b4a375b55b2b592774332798b7"},
+    {file = "pydantic-1.10.17-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:c31d281c7485223caf6474fc2b7cf21456289dbaa31401844069b77160cab9c7"},
+    {file = "pydantic-1.10.17-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:ae5184e99a060a5c80010a2d53c99aee76a3b0ad683d493e5f0620b5d86eeb75"},
+    {file = "pydantic-1.10.17-cp38-cp38-win_amd64.whl", hash = "sha256:ad1e33dc6b9787a6f0f3fd132859aa75626528b49cc1f9e429cdacb2608ad5f0"},
+    {file = "pydantic-1.10.17-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7e17c0ee7192e54a10943f245dc79e36d9fe282418ea05b886e1c666063a7b54"},
+    {file = "pydantic-1.10.17-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cafb9c938f61d1b182dfc7d44a7021326547b7b9cf695db5b68ec7b590214773"},
+    {file = "pydantic-1.10.17-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95ef534e3c22e5abbdbdd6f66b6ea9dac3ca3e34c5c632894f8625d13d084cbe"},
+    {file = "pydantic-1.10.17-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:62d96b8799ae3d782df7ec9615cb59fc32c32e1ed6afa1b231b0595f6516e8ab"},
+    {file = "pydantic-1.10.17-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:ab2f976336808fd5d539fdc26eb51f9aafc1f4b638e212ef6b6f05e753c8011d"},
+    {file = "pydantic-1.10.17-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b8ad363330557beac73159acfbeed220d5f1bfcd6b930302a987a375e02f74fd"},
+    {file = "pydantic-1.10.17-cp39-cp39-win_amd64.whl", hash = "sha256:48db882e48575ce4b39659558b2f9f37c25b8d348e37a2b4e32971dd5a7d6227"},
+    {file = "pydantic-1.10.17-py3-none-any.whl", hash = "sha256:e41b5b973e5c64f674b3b4720286ded184dcc26a691dd55f34391c62c6934688"},
+    {file = "pydantic-1.10.17.tar.gz", hash = "sha256:f434160fb14b353caf634149baaf847206406471ba70e64657c1e8330277a991"},
+]
+
+[package.dependencies]
+typing-extensions = ">=4.2.0"
+
+[package.extras]
+dotenv = ["python-dotenv (>=0.10.4)"]
+email = ["email-validator (>=1.0.3)"]
+
+[[package]]
+name = "pyflakes"
+version = "3.0.1"
+description = "passive checker of Python programs"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "pyflakes-3.0.1-py2.py3-none-any.whl", hash = "sha256:ec55bf7fe21fff7f1ad2f7da62363d749e2a470500eab1b555334b67aa1ef8cf"},
+    {file = "pyflakes-3.0.1.tar.gz", hash = "sha256:ec8b276a6b60bd80defed25add7e439881c19e64850afd9b346283d4165fd0fd"},
+]
+
+[[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 = "pyparsing"
+version = "3.1.2"
+description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+optional = false
+python-versions = ">=3.6.8"
+files = [
+    {file = "pyparsing-3.1.2-py3-none-any.whl", hash = "sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742"},
+    {file = "pyparsing-3.1.2.tar.gz", hash = "sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad"},
+]
+
+[package.extras]
+diagrams = ["jinja2", "railroad-diagrams"]
+
+[[package]]
+name = "pytest"
+version = "6.2.5"
+description = "pytest: simple powerful testing with Python"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "pytest-6.2.5-py3-none-any.whl", hash = "sha256:7310f8d27bc79ced999e760ca304d69f6ba6c6649c0b60fb0e04a4a77cacc134"},
+    {file = "pytest-6.2.5.tar.gz", hash = "sha256:131b36680866a76e6781d13f101efb86cf674ebb9762eb70d3082b6f29889e89"},
+]
+
+[package.dependencies]
+atomicwrites = {version = ">=1.0", markers = "sys_platform == \"win32\""}
+attrs = ">=19.2.0"
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+iniconfig = "*"
+packaging = "*"
+pluggy = ">=0.12,<2.0"
+py = ">=1.8.2"
+toml = "*"
+
+[package.extras]
+testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "requests", "xmlschema"]
+
+[[package]]
+name = "pytest-cov"
+version = "2.12.1"
+description = "Pytest plugin for measuring coverage."
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+files = [
+    {file = "pytest-cov-2.12.1.tar.gz", hash = "sha256:261ceeb8c227b726249b376b8526b600f38667ee314f910353fa318caa01f4d7"},
+    {file = "pytest_cov-2.12.1-py2.py3-none-any.whl", hash = "sha256:261bb9e47e65bd099c89c3edf92972865210c36813f80ede5277dceb77a4a62a"},
+]
+
+[package.dependencies]
+coverage = ">=5.2.1"
+pytest = ">=4.6"
+toml = "*"
+
+[package.extras]
+testing = ["fields", "hunter", "process-tests", "pytest-xdist", "six", "virtualenv"]
+
+[[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-dotenv"
+version = "1.0.1"
+description = "Read key-value pairs from a .env file and set them as environment variables"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"},
+    {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"},
+]
+
+[package.extras]
+cli = ["click (>=5.0)"]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.9"
+description = "A streaming multipart parser for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "python_multipart-0.0.9-py3-none-any.whl", hash = "sha256:97ca7b8ea7b05f977dc3849c3ba99d51689822fab725c3703af7c866a0c2b215"},
+    {file = "python_multipart-0.0.9.tar.gz", hash = "sha256:03f54688c663f1b7977105f021043b0793151e4cb1c1a9d4a11fc13d622c4026"},
+]
+
+[package.extras]
+dev = ["atomicwrites (==1.4.1)", "attrs (==23.2.0)", "coverage (==7.4.1)", "hatch", "invoke (==2.2.0)", "more-itertools (==10.2.0)", "pbr (==6.0.0)", "pluggy (==1.4.0)", "py (==1.11.0)", "pytest (==8.0.0)", "pytest-cov (==4.1.0)", "pytest-timeout (==2.2.0)", "pyyaml (==6.0.1)", "ruff (==0.2.1)"]
+
+[[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"
+version = "306"
+description = "Python for Window Extensions"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"},
+    {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"},
+    {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"},
+    {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"},
+    {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"},
+    {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"},
+    {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"},
+    {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"},
+    {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"},
+    {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"},
+    {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"},
+    {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"},
+    {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"},
+    {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"},
+]
+
+[[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 = "pyzmq"
+version = "26.0.3"
+description = "Python bindings for 0MQ"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:44dd6fc3034f1eaa72ece33588867df9e006a7303725a12d64c3dff92330f625"},
+    {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:acb704195a71ac5ea5ecf2811c9ee19ecdc62b91878528302dd0be1b9451cc90"},
+    {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dbb9c997932473a27afa93954bb77a9f9b786b4ccf718d903f35da3232317de"},
+    {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6bcb34f869d431799c3ee7d516554797f7760cb2198ecaa89c3f176f72d062be"},
+    {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38ece17ec5f20d7d9b442e5174ae9f020365d01ba7c112205a4d59cf19dc38ee"},
+    {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ba6e5e6588e49139a0979d03a7deb9c734bde647b9a8808f26acf9c547cab1bf"},
+    {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3bf8b000a4e2967e6dfdd8656cd0757d18c7e5ce3d16339e550bd462f4857e59"},
+    {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:2136f64fbb86451dbbf70223635a468272dd20075f988a102bf8a3f194a411dc"},
+    {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e8918973fbd34e7814f59143c5f600ecd38b8038161239fd1a3d33d5817a38b8"},
+    {file = "pyzmq-26.0.3-cp310-cp310-win32.whl", hash = "sha256:0aaf982e68a7ac284377d051c742610220fd06d330dcd4c4dbb4cdd77c22a537"},
+    {file = "pyzmq-26.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:f1a9b7d00fdf60b4039f4455afd031fe85ee8305b019334b72dcf73c567edc47"},
+    {file = "pyzmq-26.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:80b12f25d805a919d53efc0a5ad7c0c0326f13b4eae981a5d7b7cc343318ebb7"},
+    {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:a72a84570f84c374b4c287183debc776dc319d3e8ce6b6a0041ce2e400de3f32"},
+    {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7ca684ee649b55fd8f378127ac8462fb6c85f251c2fb027eb3c887e8ee347bcd"},
+    {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e222562dc0f38571c8b1ffdae9d7adb866363134299264a1958d077800b193b7"},
+    {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f17cde1db0754c35a91ac00b22b25c11da6eec5746431d6e5092f0cd31a3fea9"},
+    {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b7c0c0b3244bb2275abe255d4a30c050d541c6cb18b870975553f1fb6f37527"},
+    {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:ac97a21de3712afe6a6c071abfad40a6224fd14fa6ff0ff8d0c6e6cd4e2f807a"},
+    {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:88b88282e55fa39dd556d7fc04160bcf39dea015f78e0cecec8ff4f06c1fc2b5"},
+    {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:72b67f966b57dbd18dcc7efbc1c7fc9f5f983e572db1877081f075004614fcdd"},
+    {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f4b6cecbbf3b7380f3b61de3a7b93cb721125dc125c854c14ddc91225ba52f83"},
+    {file = "pyzmq-26.0.3-cp311-cp311-win32.whl", hash = "sha256:eed56b6a39216d31ff8cd2f1d048b5bf1700e4b32a01b14379c3b6dde9ce3aa3"},
+    {file = "pyzmq-26.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:3191d312c73e3cfd0f0afdf51df8405aafeb0bad71e7ed8f68b24b63c4f36500"},
+    {file = "pyzmq-26.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:b6907da3017ef55139cf0e417c5123a84c7332520e73a6902ff1f79046cd3b94"},
+    {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:068ca17214038ae986d68f4a7021f97e187ed278ab6dccb79f837d765a54d753"},
+    {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7821d44fe07335bea256b9f1f41474a642ca55fa671dfd9f00af8d68a920c2d4"},
+    {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eeb438a26d87c123bb318e5f2b3d86a36060b01f22fbdffd8cf247d52f7c9a2b"},
+    {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:69ea9d6d9baa25a4dc9cef5e2b77b8537827b122214f210dd925132e34ae9b12"},
+    {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7daa3e1369355766dea11f1d8ef829905c3b9da886ea3152788dc25ee6079e02"},
+    {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6ca7a9a06b52d0e38ccf6bca1aeff7be178917893f3883f37b75589d42c4ac20"},
+    {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1b7d0e124948daa4d9686d421ef5087c0516bc6179fdcf8828b8444f8e461a77"},
+    {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e746524418b70f38550f2190eeee834db8850088c834d4c8406fbb9bc1ae10b2"},
+    {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:6b3146f9ae6af82c47a5282ac8803523d381b3b21caeae0327ed2f7ecb718798"},
+    {file = "pyzmq-26.0.3-cp312-cp312-win32.whl", hash = "sha256:2b291d1230845871c00c8462c50565a9cd6026fe1228e77ca934470bb7d70ea0"},
+    {file = "pyzmq-26.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:926838a535c2c1ea21c903f909a9a54e675c2126728c21381a94ddf37c3cbddf"},
+    {file = "pyzmq-26.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:5bf6c237f8c681dfb91b17f8435b2735951f0d1fad10cc5dfd96db110243370b"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c0991f5a96a8e620f7691e61178cd8f457b49e17b7d9cfa2067e2a0a89fc1d5"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:dbf012d8fcb9f2cf0643b65df3b355fdd74fc0035d70bb5c845e9e30a3a4654b"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:01fbfbeb8249a68d257f601deb50c70c929dc2dfe683b754659569e502fbd3aa"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c8eb19abe87029c18f226d42b8a2c9efdd139d08f8bf6e085dd9075446db450"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5344b896e79800af86ad643408ca9aa303a017f6ebff8cee5a3163c1e9aec987"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:204e0f176fd1d067671157d049466869b3ae1fc51e354708b0dc41cf94e23a3a"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:a42db008d58530efa3b881eeee4991146de0b790e095f7ae43ba5cc612decbc5"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-win32.whl", hash = "sha256:8d7a498671ca87e32b54cb47c82a92b40130a26c5197d392720a1bce1b3c77cf"},
+    {file = "pyzmq-26.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:3b4032a96410bdc760061b14ed6a33613ffb7f702181ba999df5d16fb96ba16a"},
+    {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:2cc4e280098c1b192c42a849de8de2c8e0f3a84086a76ec5b07bfee29bda7d18"},
+    {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5bde86a2ed3ce587fa2b207424ce15b9a83a9fa14422dcc1c5356a13aed3df9d"},
+    {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:34106f68e20e6ff253c9f596ea50397dbd8699828d55e8fa18bd4323d8d966e6"},
+    {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ebbbd0e728af5db9b04e56389e2299a57ea8b9dd15c9759153ee2455b32be6ad"},
+    {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6b1d1c631e5940cac5a0b22c5379c86e8df6a4ec277c7a856b714021ab6cfad"},
+    {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e891ce81edd463b3b4c3b885c5603c00141151dd9c6936d98a680c8c72fe5c67"},
+    {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:9b273ecfbc590a1b98f014ae41e5cf723932f3b53ba9367cfb676f838038b32c"},
+    {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b32bff85fb02a75ea0b68f21e2412255b5731f3f389ed9aecc13a6752f58ac97"},
+    {file = "pyzmq-26.0.3-cp38-cp38-win32.whl", hash = "sha256:f6c21c00478a7bea93caaaef9e7629145d4153b15a8653e8bb4609d4bc70dbfc"},
+    {file = "pyzmq-26.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:3401613148d93ef0fd9aabdbddb212de3db7a4475367f49f590c837355343972"},
+    {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:2ed8357f4c6e0daa4f3baf31832df8a33334e0fe5b020a61bc8b345a3db7a606"},
+    {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c1c8f2a2ca45292084c75bb6d3a25545cff0ed931ed228d3a1810ae3758f975f"},
+    {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b63731993cdddcc8e087c64e9cf003f909262b359110070183d7f3025d1c56b5"},
+    {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b3cd31f859b662ac5d7f4226ec7d8bd60384fa037fc02aee6ff0b53ba29a3ba8"},
+    {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:115f8359402fa527cf47708d6f8a0f8234f0e9ca0cab7c18c9c189c194dbf620"},
+    {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:715bdf952b9533ba13dfcf1f431a8f49e63cecc31d91d007bc1deb914f47d0e4"},
+    {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:e1258c639e00bf5e8a522fec6c3eaa3e30cf1c23a2f21a586be7e04d50c9acab"},
+    {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:15c59e780be8f30a60816a9adab900c12a58d79c1ac742b4a8df044ab2a6d920"},
+    {file = "pyzmq-26.0.3-cp39-cp39-win32.whl", hash = "sha256:d0cdde3c78d8ab5b46595054e5def32a755fc028685add5ddc7403e9f6de9879"},
+    {file = "pyzmq-26.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:ce828058d482ef860746bf532822842e0ff484e27f540ef5c813d516dd8896d2"},
+    {file = "pyzmq-26.0.3-cp39-cp39-win_arm64.whl", hash = "sha256:788f15721c64109cf720791714dc14afd0f449d63f3a5487724f024345067381"},
+    {file = "pyzmq-26.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2c18645ef6294d99b256806e34653e86236eb266278c8ec8112622b61db255de"},
+    {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e6bc96ebe49604df3ec2c6389cc3876cabe475e6bfc84ced1bf4e630662cb35"},
+    {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:971e8990c5cc4ddcff26e149398fc7b0f6a042306e82500f5e8db3b10ce69f84"},
+    {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8416c23161abd94cc7da80c734ad7c9f5dbebdadfdaa77dad78244457448223"},
+    {file = "pyzmq-26.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:082a2988364b60bb5de809373098361cf1dbb239623e39e46cb18bc035ed9c0c"},
+    {file = "pyzmq-26.0.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d57dfbf9737763b3a60d26e6800e02e04284926329aee8fb01049635e957fe81"},
+    {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:77a85dca4c2430ac04dc2a2185c2deb3858a34fe7f403d0a946fa56970cf60a1"},
+    {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4c82a6d952a1d555bf4be42b6532927d2a5686dd3c3e280e5f63225ab47ac1f5"},
+    {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4496b1282c70c442809fc1b151977c3d967bfb33e4e17cedbf226d97de18f709"},
+    {file = "pyzmq-26.0.3-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:e4946d6bdb7ba972dfda282f9127e5756d4f299028b1566d1245fa0d438847e6"},
+    {file = "pyzmq-26.0.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:03c0ae165e700364b266876d712acb1ac02693acd920afa67da2ebb91a0b3c09"},
+    {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3e3070e680f79887d60feeda051a58d0ac36622e1759f305a41059eff62c6da7"},
+    {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6ca08b840fe95d1c2bd9ab92dac5685f949fc6f9ae820ec16193e5ddf603c3b2"},
+    {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e76654e9dbfb835b3518f9938e565c7806976c07b37c33526b574cc1a1050480"},
+    {file = "pyzmq-26.0.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:871587bdadd1075b112e697173e946a07d722459d20716ceb3d1bd6c64bd08ce"},
+    {file = "pyzmq-26.0.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d0a2d1bd63a4ad79483049b26514e70fa618ce6115220da9efdff63688808b17"},
+    {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0270b49b6847f0d106d64b5086e9ad5dc8a902413b5dbbb15d12b60f9c1747a4"},
+    {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:703c60b9910488d3d0954ca585c34f541e506a091a41930e663a098d3b794c67"},
+    {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:74423631b6be371edfbf7eabb02ab995c2563fee60a80a30829176842e71722a"},
+    {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4adfbb5451196842a88fda3612e2c0414134874bffb1c2ce83ab4242ec9e027d"},
+    {file = "pyzmq-26.0.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3516119f4f9b8671083a70b6afaa0a070f5683e431ab3dc26e9215620d7ca1ad"},
+    {file = "pyzmq-26.0.3.tar.gz", hash = "sha256:dba7d9f2e047dfa2bca3b01f4f84aa5246725203d6284e3790f2ca15fba6b40a"},
+]
+
+[package.dependencies]
+cffi = {version = "*", markers = "implementation_name == \"pypy\""}
+
+[[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 = "rich"
+version = "13.7.1"
+description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal"
+optional = false
+python-versions = ">=3.7.0"
+files = [
+    {file = "rich-13.7.1-py3-none-any.whl", hash = "sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222"},
+    {file = "rich-13.7.1.tar.gz", hash = "sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432"},
+]
+
+[package.dependencies]
+markdown-it-py = ">=2.2.0"
+pygments = ">=2.13.0,<3.0.0"
+
+[package.extras]
+jupyter = ["ipywidgets (>=7.5.1,<9)"]
+
+[[package]]
+name = "scikit-learn"
+version = "1.3.2"
+description = "A set of python modules for machine learning and data mining"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "scikit-learn-1.3.2.tar.gz", hash = "sha256:a2f54c76accc15a34bfb9066e6c7a56c1e7235dda5762b990792330b52ccfb05"},
+    {file = "scikit_learn-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e326c0eb5cf4d6ba40f93776a20e9a7a69524c4db0757e7ce24ba222471ee8a1"},
+    {file = "scikit_learn-1.3.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:535805c2a01ccb40ca4ab7d081d771aea67e535153e35a1fd99418fcedd1648a"},
+    {file = "scikit_learn-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1215e5e58e9880b554b01187b8c9390bf4dc4692eedeaf542d3273f4785e342c"},
+    {file = "scikit_learn-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ee107923a623b9f517754ea2f69ea3b62fc898a3641766cb7deb2f2ce450161"},
+    {file = "scikit_learn-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:35a22e8015048c628ad099da9df5ab3004cdbf81edc75b396fd0cff8699ac58c"},
+    {file = "scikit_learn-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6fb6bc98f234fda43163ddbe36df8bcde1d13ee176c6dc9b92bb7d3fc842eb66"},
+    {file = "scikit_learn-1.3.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:18424efee518a1cde7b0b53a422cde2f6625197de6af36da0b57ec502f126157"},
+    {file = "scikit_learn-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3271552a5eb16f208a6f7f617b8cc6d1f137b52c8a1ef8edf547db0259b2c9fb"},
+    {file = "scikit_learn-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4144a5004a676d5022b798d9e573b05139e77f271253a4703eed295bde0433"},
+    {file = "scikit_learn-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:67f37d708f042a9b8d59551cf94d30431e01374e00dc2645fa186059c6c5d78b"},
+    {file = "scikit_learn-1.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:8db94cd8a2e038b37a80a04df8783e09caac77cbe052146432e67800e430c028"},
+    {file = "scikit_learn-1.3.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:61a6efd384258789aa89415a410dcdb39a50e19d3d8410bd29be365bcdd512d5"},
+    {file = "scikit_learn-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb06f8dce3f5ddc5dee1715a9b9f19f20d295bed8e3cd4fa51e1d050347de525"},
+    {file = "scikit_learn-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5b2de18d86f630d68fe1f87af690d451388bb186480afc719e5f770590c2ef6c"},
+    {file = "scikit_learn-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:0402638c9a7c219ee52c94cbebc8fcb5eb9fe9c773717965c1f4185588ad3107"},
+    {file = "scikit_learn-1.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a19f90f95ba93c1a7f7924906d0576a84da7f3b2282ac3bfb7a08a32801add93"},
+    {file = "scikit_learn-1.3.2-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:b8692e395a03a60cd927125eef3a8e3424d86dde9b2370d544f0ea35f78a8073"},
+    {file = "scikit_learn-1.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15e1e94cc23d04d39da797ee34236ce2375ddea158b10bee3c343647d615581d"},
+    {file = "scikit_learn-1.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:785a2213086b7b1abf037aeadbbd6d67159feb3e30263434139c98425e3dcfcf"},
+    {file = "scikit_learn-1.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:64381066f8aa63c2710e6b56edc9f0894cc7bf59bd71b8ce5613a4559b6145e0"},
+    {file = "scikit_learn-1.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6c43290337f7a4b969d207e620658372ba3c1ffb611f8bc2b6f031dc5c6d1d03"},
+    {file = "scikit_learn-1.3.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:dc9002fc200bed597d5d34e90c752b74df516d592db162f756cc52836b38fe0e"},
+    {file = "scikit_learn-1.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d08ada33e955c54355d909b9c06a4789a729977f165b8bae6f225ff0a60ec4a"},
+    {file = "scikit_learn-1.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:763f0ae4b79b0ff9cca0bf3716bcc9915bdacff3cebea15ec79652d1cc4fa5c9"},
+    {file = "scikit_learn-1.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:ed932ea780517b00dae7431e031faae6b49b20eb6950918eb83bd043237950e0"},
+]
+
+[package.dependencies]
+joblib = ">=1.1.1"
+numpy = ">=1.17.3,<2.0"
+scipy = ">=1.5.0"
+threadpoolctl = ">=2.0.0"
+
+[package.extras]
+benchmark = ["matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "pandas (>=1.0.5)"]
+docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.10.1)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"]
+examples = ["matplotlib (>=3.1.3)", "pandas (>=1.0.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)"]
+tests = ["black (>=23.3.0)", "matplotlib (>=3.1.3)", "mypy (>=1.3)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.0.272)", "scikit-image (>=0.16.2)"]
+
+[[package]]
+name = "scipy"
+version = "1.13.1"
+description = "Fundamental algorithms for scientific computing in Python"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "scipy-1.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca"},
+    {file = "scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f"},
+    {file = "scipy-1.13.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfa31f1def5c819b19ecc3a8b52d28ffdcc7ed52bb20c9a7589669dd3c250989"},
+    {file = "scipy-1.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26264b282b9da0952a024ae34710c2aff7d27480ee91a2e82b7b7073c24722f"},
+    {file = "scipy-1.13.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:eccfa1906eacc02de42d70ef4aecea45415f5be17e72b61bafcfd329bdc52e94"},
+    {file = "scipy-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:2831f0dc9c5ea9edd6e51e6e769b655f08ec6db6e2e10f86ef39bd32eb11da54"},
+    {file = "scipy-1.13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:27e52b09c0d3a1d5b63e1105f24177e544a222b43611aaf5bc44d4a0979e32f9"},
+    {file = "scipy-1.13.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:54f430b00f0133e2224c3ba42b805bfd0086fe488835effa33fa291561932326"},
+    {file = "scipy-1.13.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e89369d27f9e7b0884ae559a3a956e77c02114cc60a6058b4e5011572eea9299"},
+    {file = "scipy-1.13.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78b4b3345f1b6f68a763c6e25c0c9a23a9fd0f39f5f3d200efe8feda560a5fa"},
+    {file = "scipy-1.13.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:45484bee6d65633752c490404513b9ef02475b4284c4cfab0ef946def50b3f59"},
+    {file = "scipy-1.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:5713f62f781eebd8d597eb3f88b8bf9274e79eeabf63afb4a737abc6c84ad37b"},
+    {file = "scipy-1.13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5d72782f39716b2b3509cd7c33cdc08c96f2f4d2b06d51e52fb45a19ca0c86a1"},
+    {file = "scipy-1.13.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:017367484ce5498445aade74b1d5ab377acdc65e27095155e448c88497755a5d"},
+    {file = "scipy-1.13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:949ae67db5fa78a86e8fa644b9a6b07252f449dcf74247108c50e1d20d2b4627"},
+    {file = "scipy-1.13.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de3ade0e53bc1f21358aa74ff4830235d716211d7d077e340c7349bc3542e884"},
+    {file = "scipy-1.13.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2ac65fb503dad64218c228e2dc2d0a0193f7904747db43014645ae139c8fad16"},
+    {file = "scipy-1.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:cdd7dacfb95fea358916410ec61bbc20440f7860333aee6d882bb8046264e949"},
+    {file = "scipy-1.13.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:436bbb42a94a8aeef855d755ce5a465479c721e9d684de76bf61a62e7c2b81d5"},
+    {file = "scipy-1.13.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:8335549ebbca860c52bf3d02f80784e91a004b71b059e3eea9678ba994796a24"},
+    {file = "scipy-1.13.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d533654b7d221a6a97304ab63c41c96473ff04459e404b83275b60aa8f4b7004"},
+    {file = "scipy-1.13.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637e98dcf185ba7f8e663e122ebf908c4702420477ae52a04f9908707456ba4d"},
+    {file = "scipy-1.13.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a014c2b3697bde71724244f63de2476925596c24285c7a637364761f8710891c"},
+    {file = "scipy-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:392e4ec766654852c25ebad4f64e4e584cf19820b980bc04960bca0b0cd6eaa2"},
+    {file = "scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c"},
+]
+
+[package.dependencies]
+numpy = ">=1.22.4,<2.3"
+
+[package.extras]
+dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"]
+doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"]
+test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"]
+
+[[package]]
+name = "seaborn"
+version = "0.12.2"
+description = "Statistical data visualization"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "seaborn-0.12.2-py3-none-any.whl", hash = "sha256:ebf15355a4dba46037dfd65b7350f014ceb1f13c05e814eda2c9f5fd731afc08"},
+    {file = "seaborn-0.12.2.tar.gz", hash = "sha256:374645f36509d0dcab895cba5b47daf0586f77bfe3b36c97c607db7da5be0139"},
+]
+
+[package.dependencies]
+matplotlib = ">=3.1,<3.6.1 || >3.6.1"
+numpy = ">=1.17,<1.24.0 || >1.24.0"
+pandas = ">=0.25"
+
+[package.extras]
+dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"]
+docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx-copybutton", "sphinx-design", "sphinx-issues"]
+stats = ["scipy (>=1.3)", "statsmodels (>=0.10)"]
+
+[[package]]
+name = "setuptools"
+version = "70.3.0"
+description = "Easily download, build, install, upgrade, and uninstall Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "setuptools-70.3.0-py3-none-any.whl", hash = "sha256:fe384da74336c398e0d956d1cae0669bc02eed936cdb1d49b57de1990dc11ffc"},
+    {file = "setuptools-70.3.0.tar.gz", hash = "sha256:f171bab1dfbc86b132997f26a119f6056a57950d058587841a0082e8830f9dc5"},
+]
+
+[package.extras]
+doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"]
+test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test", "mypy (==1.10.0)", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (>=0.3.2)", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+description = "Tool to Detect Surrounding Shell"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"},
+    {file = "shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de"},
+]
+
+[[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 = "sniffio"
+version = "1.3.1"
+description = "Sniff out which async library your code is running under"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"},
+    {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"},
+]
+
+[[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 = "starlette"
+version = "0.37.2"
+description = "The little ASGI library that shines."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "starlette-0.37.2-py3-none-any.whl", hash = "sha256:6fe59f29268538e5d0d182f2791a479a0c64638e6935d1c6989e63fb2699c6ee"},
+    {file = "starlette-0.37.2.tar.gz", hash = "sha256:9af890290133b79fc3db55474ade20f6220a364a0402e0b556e7cd5e1e093823"},
+]
+
+[package.dependencies]
+anyio = ">=3.4.0,<5"
+
+[package.extras]
+full = ["httpx (>=0.22.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.7)", "pyyaml"]
+
+[[package]]
+name = "threadpoolctl"
+version = "3.5.0"
+description = "threadpoolctl"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "threadpoolctl-3.5.0-py3-none-any.whl", hash = "sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467"},
+    {file = "threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107"},
+]
+
+[[package]]
+name = "toml"
+version = "0.10.2"
+description = "Python Library for Tom's Obvious, Minimal Language"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+files = [
+    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
+    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
+]
+
+[[package]]
+name = "tomli"
+version = "2.0.1"
+description = "A lil' TOML parser"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
+    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
+]
+
+[[package]]
+name = "tornado"
+version = "6.4.1"
+description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:163b0aafc8e23d8cdc3c9dfb24c5368af84a81e3364745ccb4427669bf84aec8"},
+    {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6d5ce3437e18a2b66fbadb183c1d3364fb03f2be71299e7d10dbeeb69f4b2a14"},
+    {file = "tornado-6.4.1-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e20b9113cd7293f164dc46fffb13535266e713cdb87bd2d15ddb336e96cfc4"},
+    {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ae50a504a740365267b2a8d1a90c9fbc86b780a39170feca9bcc1787ff80842"},
+    {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613bf4ddf5c7a95509218b149b555621497a6cc0d46ac341b30bd9ec19eac7f3"},
+    {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25486eb223babe3eed4b8aecbac33b37e3dd6d776bc730ca14e1bf93888b979f"},
+    {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:454db8a7ecfcf2ff6042dde58404164d969b6f5d58b926da15e6b23817950fc4"},
+    {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a02a08cc7a9314b006f653ce40483b9b3c12cda222d6a46d4ac63bb6c9057698"},
+    {file = "tornado-6.4.1-cp38-abi3-win32.whl", hash = "sha256:d9a566c40b89757c9aa8e6f032bcdb8ca8795d7c1a9762910c722b1635c9de4d"},
+    {file = "tornado-6.4.1-cp38-abi3-win_amd64.whl", hash = "sha256:b24b8982ed444378d7f21d563f4180a2de31ced9d8d84443907a0a64da2072e7"},
+    {file = "tornado-6.4.1.tar.gz", hash = "sha256:92d3ab53183d8c50f8204a51e6f91d18a15d5ef261e84d452800d4ff6fc504e9"},
+]
+
+[[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 = "typer"
+version = "0.12.3"
+description = "Typer, build great CLIs. Easy to code. Based on Python type hints."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "typer-0.12.3-py3-none-any.whl", hash = "sha256:070d7ca53f785acbccba8e7d28b08dcd88f79f1fbda035ade0aecec71ca5c914"},
+    {file = "typer-0.12.3.tar.gz", hash = "sha256:49e73131481d804288ef62598d97a1ceef3058905aa536a1134f90891ba35482"},
+]
+
+[package.dependencies]
+click = ">=8.0.0"
+rich = ">=10.11.0"
+shellingham = ">=1.3.0"
+typing-extensions = ">=3.7.4.3"
+
+[[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 = "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 = "uvicorn"
+version = "0.15.0"
+description = "The lightning-fast ASGI server."
+optional = false
+python-versions = "*"
+files = [
+    {file = "uvicorn-0.15.0-py3-none-any.whl", hash = "sha256:17f898c64c71a2640514d4089da2689e5db1ce5d4086c2d53699bf99513421c1"},
+    {file = "uvicorn-0.15.0.tar.gz", hash = "sha256:d9a3c0dd1ca86728d3e235182683b4cf94cd53a867c288eaeca80ee781b2caff"},
+]
+
+[package.dependencies]
+asgiref = ">=3.4.0"
+click = ">=7.0"
+colorama = {version = ">=0.4", optional = true, markers = "sys_platform == \"win32\" and extra == \"standard\""}
+h11 = ">=0.8"
+httptools = {version = "==0.2.*", optional = true, markers = "extra == \"standard\""}
+python-dotenv = {version = ">=0.13", optional = true, markers = "extra == \"standard\""}
+PyYAML = {version = ">=5.1", optional = true, markers = "extra == \"standard\""}
+uvloop = {version = ">=0.14.0,<0.15.0 || >0.15.0,<0.15.1 || >0.15.1", optional = true, markers = "(sys_platform != \"win32\" and sys_platform != \"cygwin\") and platform_python_implementation != \"PyPy\" and extra == \"standard\""}
+watchgod = {version = ">=0.6", optional = true, markers = "extra == \"standard\""}
+websockets = {version = ">=9.1", optional = true, markers = "extra == \"standard\""}
+
+[package.extras]
+standard = ["PyYAML (>=5.1)", "colorama (>=0.4)", "httptools (==0.2.*)", "python-dotenv (>=0.13)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1)", "watchgod (>=0.6)", "websockets (>=9.1)"]
+
+[[package]]
+name = "uvloop"
+version = "0.19.0"
+description = "Fast implementation of asyncio event loop on top of libuv"
+optional = false
+python-versions = ">=3.8.0"
+files = [
+    {file = "uvloop-0.19.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:de4313d7f575474c8f5a12e163f6d89c0a878bc49219641d49e6f1444369a90e"},
+    {file = "uvloop-0.19.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5588bd21cf1fcf06bded085f37e43ce0e00424197e7c10e77afd4bbefffef428"},
+    {file = "uvloop-0.19.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b1fd71c3843327f3bbc3237bedcdb6504fd50368ab3e04d0410e52ec293f5b8"},
+    {file = "uvloop-0.19.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a05128d315e2912791de6088c34136bfcdd0c7cbc1cf85fd6fd1bb321b7c849"},
+    {file = "uvloop-0.19.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:cd81bdc2b8219cb4b2556eea39d2e36bfa375a2dd021404f90a62e44efaaf957"},
+    {file = "uvloop-0.19.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:5f17766fb6da94135526273080f3455a112f82570b2ee5daa64d682387fe0dcd"},
+    {file = "uvloop-0.19.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4ce6b0af8f2729a02a5d1575feacb2a94fc7b2e983868b009d51c9a9d2149bef"},
+    {file = "uvloop-0.19.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:31e672bb38b45abc4f26e273be83b72a0d28d074d5b370fc4dcf4c4eb15417d2"},
+    {file = "uvloop-0.19.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:570fc0ed613883d8d30ee40397b79207eedd2624891692471808a95069a007c1"},
+    {file = "uvloop-0.19.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5138821e40b0c3e6c9478643b4660bd44372ae1e16a322b8fc07478f92684e24"},
+    {file = "uvloop-0.19.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:91ab01c6cd00e39cde50173ba4ec68a1e578fee9279ba64f5221810a9e786533"},
+    {file = "uvloop-0.19.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:47bf3e9312f63684efe283f7342afb414eea4d3011542155c7e625cd799c3b12"},
+    {file = "uvloop-0.19.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:da8435a3bd498419ee8c13c34b89b5005130a476bda1d6ca8cfdde3de35cd650"},
+    {file = "uvloop-0.19.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:02506dc23a5d90e04d4f65c7791e65cf44bd91b37f24cfc3ef6cf2aff05dc7ec"},
+    {file = "uvloop-0.19.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2693049be9d36fef81741fddb3f441673ba12a34a704e7b4361efb75cf30befc"},
+    {file = "uvloop-0.19.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7010271303961c6f0fe37731004335401eb9075a12680738731e9c92ddd96ad6"},
+    {file = "uvloop-0.19.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:5daa304d2161d2918fa9a17d5635099a2f78ae5b5960e742b2fcfbb7aefaa593"},
+    {file = "uvloop-0.19.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:7207272c9520203fea9b93843bb775d03e1cf88a80a936ce760f60bb5add92f3"},
+    {file = "uvloop-0.19.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:78ab247f0b5671cc887c31d33f9b3abfb88d2614b84e4303f1a63b46c046c8bd"},
+    {file = "uvloop-0.19.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:472d61143059c84947aa8bb74eabbace30d577a03a1805b77933d6bd13ddebbd"},
+    {file = "uvloop-0.19.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45bf4c24c19fb8a50902ae37c5de50da81de4922af65baf760f7c0c42e1088be"},
+    {file = "uvloop-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271718e26b3e17906b28b67314c45d19106112067205119dddbd834c2b7ce797"},
+    {file = "uvloop-0.19.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:34175c9fd2a4bc3adc1380e1261f60306344e3407c20a4d684fd5f3be010fa3d"},
+    {file = "uvloop-0.19.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e27f100e1ff17f6feeb1f33968bc185bf8ce41ca557deee9d9bbbffeb72030b7"},
+    {file = "uvloop-0.19.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:13dfdf492af0aa0a0edf66807d2b465607d11c4fa48f4a1fd41cbea5b18e8e8b"},
+    {file = "uvloop-0.19.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6e3d4e85ac060e2342ff85e90d0c04157acb210b9ce508e784a944f852a40e67"},
+    {file = "uvloop-0.19.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ca4956c9ab567d87d59d49fa3704cf29e37109ad348f2d5223c9bf761a332e7"},
+    {file = "uvloop-0.19.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f467a5fd23b4fc43ed86342641f3936a68ded707f4627622fa3f82a120e18256"},
+    {file = "uvloop-0.19.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:492e2c32c2af3f971473bc22f086513cedfc66a130756145a931a90c3958cb17"},
+    {file = "uvloop-0.19.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:2df95fca285a9f5bfe730e51945ffe2fa71ccbfdde3b0da5772b4ee4f2e770d5"},
+    {file = "uvloop-0.19.0.tar.gz", hash = "sha256:0246f4fd1bf2bf702e06b0d45ee91677ee5c31242f39aab4ea6fe0c51aedd0fd"},
+]
+
+[package.extras]
+docs = ["Sphinx (>=4.1.2,<4.2.0)", "sphinx-rtd-theme (>=0.5.2,<0.6.0)", "sphinxcontrib-asyncio (>=0.3.0,<0.4.0)"]
+test = ["Cython (>=0.29.36,<0.30.0)", "aiohttp (==3.9.0b0)", "aiohttp (>=3.8.1)", "flake8 (>=5.0,<6.0)", "mypy (>=0.800)", "psutil", "pyOpenSSL (>=23.0.0,<23.1.0)", "pycodestyle (>=2.9.0,<2.10.0)"]
+
+[[package]]
+name = "watchgod"
+version = "0.7"
+description = "Simple, modern file watching and code reload in python."
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "watchgod-0.7-py3-none-any.whl", hash = "sha256:d6c1ea21df37847ac0537ca0d6c2f4cdf513562e95f77bb93abbcf05573407b7"},
+    {file = "watchgod-0.7.tar.gz", hash = "sha256:48140d62b0ebe9dd9cf8381337f06351e1f2e70b2203fa9c6eff4e572ca84f29"},
+]
+
+[[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 = "websockets"
+version = "12.0"
+description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "websockets-12.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d554236b2a2006e0ce16315c16eaa0d628dab009c33b63ea03f41c6107958374"},
+    {file = "websockets-12.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2d225bb6886591b1746b17c0573e29804619c8f755b5598d875bb4235ea639be"},
+    {file = "websockets-12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eb809e816916a3b210bed3c82fb88eaf16e8afcf9c115ebb2bacede1797d2547"},
+    {file = "websockets-12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c588f6abc13f78a67044c6b1273a99e1cf31038ad51815b3b016ce699f0d75c2"},
+    {file = "websockets-12.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5aa9348186d79a5f232115ed3fa9020eab66d6c3437d72f9d2c8ac0c6858c558"},
+    {file = "websockets-12.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6350b14a40c95ddd53e775dbdbbbc59b124a5c8ecd6fbb09c2e52029f7a9f480"},
+    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:70ec754cc2a769bcd218ed8d7209055667b30860ffecb8633a834dde27d6307c"},
+    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6e96f5ed1b83a8ddb07909b45bd94833b0710f738115751cdaa9da1fb0cb66e8"},
+    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4d87be612cbef86f994178d5186add3d94e9f31cc3cb499a0482b866ec477603"},
+    {file = "websockets-12.0-cp310-cp310-win32.whl", hash = "sha256:befe90632d66caaf72e8b2ed4d7f02b348913813c8b0a32fae1cc5fe3730902f"},
+    {file = "websockets-12.0-cp310-cp310-win_amd64.whl", hash = "sha256:363f57ca8bc8576195d0540c648aa58ac18cf85b76ad5202b9f976918f4219cf"},
+    {file = "websockets-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5d873c7de42dea355d73f170be0f23788cf3fa9f7bed718fd2830eefedce01b4"},
+    {file = "websockets-12.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3f61726cae9f65b872502ff3c1496abc93ffbe31b278455c418492016e2afc8f"},
+    {file = "websockets-12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed2fcf7a07334c77fc8a230755c2209223a7cc44fc27597729b8ef5425aa61a3"},
+    {file = "websockets-12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e332c210b14b57904869ca9f9bf4ca32f5427a03eeb625da9b616c85a3a506c"},
+    {file = "websockets-12.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5693ef74233122f8ebab026817b1b37fe25c411ecfca084b29bc7d6efc548f45"},
+    {file = "websockets-12.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e9e7db18b4539a29cc5ad8c8b252738a30e2b13f033c2d6e9d0549b45841c04"},
+    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6e2df67b8014767d0f785baa98393725739287684b9f8d8a1001eb2839031447"},
+    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bea88d71630c5900690fcb03161ab18f8f244805c59e2e0dc4ffadae0a7ee0ca"},
+    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dff6cdf35e31d1315790149fee351f9e52978130cef6c87c4b6c9b3baf78bc53"},
+    {file = "websockets-12.0-cp311-cp311-win32.whl", hash = "sha256:3e3aa8c468af01d70332a382350ee95f6986db479ce7af14d5e81ec52aa2b402"},
+    {file = "websockets-12.0-cp311-cp311-win_amd64.whl", hash = "sha256:25eb766c8ad27da0f79420b2af4b85d29914ba0edf69f547cc4f06ca6f1d403b"},
+    {file = "websockets-12.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0e6e2711d5a8e6e482cacb927a49a3d432345dfe7dea8ace7b5790df5932e4df"},
+    {file = "websockets-12.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:dbcf72a37f0b3316e993e13ecf32f10c0e1259c28ffd0a85cee26e8549595fbc"},
+    {file = "websockets-12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12743ab88ab2af1d17dd4acb4645677cb7063ef4db93abffbf164218a5d54c6b"},
+    {file = "websockets-12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b645f491f3c48d3f8a00d1fce07445fab7347fec54a3e65f0725d730d5b99cb"},
+    {file = "websockets-12.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9893d1aa45a7f8b3bc4510f6ccf8db8c3b62120917af15e3de247f0780294b92"},
+    {file = "websockets-12.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f38a7b376117ef7aff996e737583172bdf535932c9ca021746573bce40165ed"},
+    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f764ba54e33daf20e167915edc443b6f88956f37fb606449b4a5b10ba42235a5"},
+    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:1e4b3f8ea6a9cfa8be8484c9221ec0257508e3a1ec43c36acdefb2a9c3b00aa2"},
+    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9fdf06fd06c32205a07e47328ab49c40fc1407cdec801d698a7c41167ea45113"},
+    {file = "websockets-12.0-cp312-cp312-win32.whl", hash = "sha256:baa386875b70cbd81798fa9f71be689c1bf484f65fd6fb08d051a0ee4e79924d"},
+    {file = "websockets-12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ae0a5da8f35a5be197f328d4727dbcfafa53d1824fac3d96cdd3a642fe09394f"},
+    {file = "websockets-12.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5f6ffe2c6598f7f7207eef9a1228b6f5c818f9f4d53ee920aacd35cec8110438"},
+    {file = "websockets-12.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9edf3fc590cc2ec20dc9d7a45108b5bbaf21c0d89f9fd3fd1685e223771dc0b2"},
+    {file = "websockets-12.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8572132c7be52632201a35f5e08348137f658e5ffd21f51f94572ca6c05ea81d"},
+    {file = "websockets-12.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:604428d1b87edbf02b233e2c207d7d528460fa978f9e391bd8aaf9c8311de137"},
+    {file = "websockets-12.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a9d160fd080c6285e202327aba140fc9a0d910b09e423afff4ae5cbbf1c7205"},
+    {file = "websockets-12.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87b4aafed34653e465eb77b7c93ef058516cb5acf3eb21e42f33928616172def"},
+    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b2ee7288b85959797970114deae81ab41b731f19ebcd3bd499ae9ca0e3f1d2c8"},
+    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:7fa3d25e81bfe6a89718e9791128398a50dec6d57faf23770787ff441d851967"},
+    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a571f035a47212288e3b3519944f6bf4ac7bc7553243e41eac50dd48552b6df7"},
+    {file = "websockets-12.0-cp38-cp38-win32.whl", hash = "sha256:3c6cc1360c10c17463aadd29dd3af332d4a1adaa8796f6b0e9f9df1fdb0bad62"},
+    {file = "websockets-12.0-cp38-cp38-win_amd64.whl", hash = "sha256:1bf386089178ea69d720f8db6199a0504a406209a0fc23e603b27b300fdd6892"},
+    {file = "websockets-12.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ab3d732ad50a4fbd04a4490ef08acd0517b6ae6b77eb967251f4c263011a990d"},
+    {file = "websockets-12.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1d9697f3337a89691e3bd8dc56dea45a6f6d975f92e7d5f773bc715c15dde28"},
+    {file = "websockets-12.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1df2fbd2c8a98d38a66f5238484405b8d1d16f929bb7a33ed73e4801222a6f53"},
+    {file = "websockets-12.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23509452b3bc38e3a057382c2e941d5ac2e01e251acce7adc74011d7d8de434c"},
+    {file = "websockets-12.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e5fc14ec6ea568200ea4ef46545073da81900a2b67b3e666f04adf53ad452ec"},
+    {file = "websockets-12.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46e71dbbd12850224243f5d2aeec90f0aaa0f2dde5aeeb8fc8df21e04d99eff9"},
+    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b81f90dcc6c85a9b7f29873beb56c94c85d6f0dac2ea8b60d995bd18bf3e2aae"},
+    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:a02413bc474feda2849c59ed2dfb2cddb4cd3d2f03a2fedec51d6e959d9b608b"},
+    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bbe6013f9f791944ed31ca08b077e26249309639313fff132bfbf3ba105673b9"},
+    {file = "websockets-12.0-cp39-cp39-win32.whl", hash = "sha256:cbe83a6bbdf207ff0541de01e11904827540aa069293696dd528a6640bd6a5f6"},
+    {file = "websockets-12.0-cp39-cp39-win_amd64.whl", hash = "sha256:fc4e7fa5414512b481a2483775a8e8be7803a35b30ca805afa4998a84f9fd9e8"},
+    {file = "websockets-12.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:248d8e2446e13c1d4326e0a6a4e9629cb13a11195051a73acf414812700badbd"},
+    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f44069528d45a933997a6fef143030d8ca8042f0dfaad753e2906398290e2870"},
+    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c4e37d36f0d19f0a4413d3e18c0d03d0c268ada2061868c1e6f5ab1a6d575077"},
+    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d829f975fc2e527a3ef2f9c8f25e553eb7bc779c6665e8e1d52aa22800bb38b"},
+    {file = "websockets-12.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:2c71bd45a777433dd9113847af751aae36e448bc6b8c361a566cb043eda6ec30"},
+    {file = "websockets-12.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0bee75f400895aef54157b36ed6d3b308fcab62e5260703add87f44cee9c82a6"},
+    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:423fc1ed29f7512fceb727e2d2aecb952c46aa34895e9ed96071821309951123"},
+    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27a5e9964ef509016759f2ef3f2c1e13f403725a5e6a1775555994966a66e931"},
+    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3181df4583c4d3994d31fb235dc681d2aaad744fbdbf94c4802485ececdecf2"},
+    {file = "websockets-12.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:b067cb952ce8bf40115f6c19f478dc71c5e719b7fbaa511359795dfd9d1a6468"},
+    {file = "websockets-12.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:00700340c6c7ab788f176d118775202aadea7602c5cc6be6ae127761c16d6b0b"},
+    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e469d01137942849cff40517c97a30a93ae79917752b34029f0ec72df6b46399"},
+    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffefa1374cd508d633646d51a8e9277763a9b78ae71324183693959cf94635a7"},
+    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba0cab91b3956dfa9f512147860783a1829a8d905ee218a9837c18f683239611"},
+    {file = "websockets-12.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2cb388a5bfb56df4d9a406783b7f9dbefb888c09b71629351cc6b036e9259370"},
+    {file = "websockets-12.0-py3-none-any.whl", hash = "sha256:dc284bbc8d7c78a6c69e0c7325ab46ee5e40bb4d50e494d8131a07ef47500e9e"},
+    {file = "websockets-12.0.tar.gz", hash = "sha256:81df9cbcbb6c260de1e007e58c011bfebe2dafc8435107b0537f393dd38c8b1b"},
+]
+
+[[package]]
+name = "werkzeug"
+version = "3.0.3"
+description = "The comprehensive WSGI web application library."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "werkzeug-3.0.3-py3-none-any.whl", hash = "sha256:fc9645dc43e03e4d630d23143a04a7f947a9a3b5727cd535fdfe155a17cc48c8"},
+    {file = "werkzeug-3.0.3.tar.gz", hash = "sha256:097e5bfda9f0aba8da6b8545146def481d06aa7d3266e7448e2cccf67dd8bd18"},
+]
+
+[package.dependencies]
+MarkupSafe = ">=2.1.1"
+
+[package.extras]
+watchdog = ["watchdog (>=2.3)"]
+
+[[package]]
+name = "xgboost"
+version = "2.1.0"
+description = "XGBoost Python Package"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "xgboost-2.1.0-py3-none-macosx_10_15_x86_64.macosx_11_0_x86_64.macosx_12_0_x86_64.whl", hash = "sha256:19d145eb847b070c32342b1bf2d7331c102783e07a484f8b13b7d759d707c6b0"},
+    {file = "xgboost-2.1.0-py3-none-macosx_12_0_arm64.whl", hash = "sha256:840a0c6e2119d8c8f260a5dace996ea064a267f62b301a25d7d452488a7ac860"},
+    {file = "xgboost-2.1.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:73673c9bb85927db7fe2e3aed6df6d35dba708cfd6767cc63d4ea11dda2dede5"},
+    {file = "xgboost-2.1.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:43b16205689249d7509daf7a6ab00ad0e6c570b3a9c263cb32b26e39d9477bb3"},
+    {file = "xgboost-2.1.0-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:cedc2e386e686795735448fd4597533acacc5ba6fb47dd910c204c468b80bb96"},
+    {file = "xgboost-2.1.0-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:b2a456eb0f3d3e8fd8ab37e44ac288292bf8ea8744c294be9fd88713d27af810"},
+    {file = "xgboost-2.1.0-py3-none-win_amd64.whl", hash = "sha256:74904b91c42524a6c32147fe5718569e78fb65911ff4499b053f81d0964514d4"},
+    {file = "xgboost-2.1.0.tar.gz", hash = "sha256:7144980923e76ce741c7b03a14d3bd7514db6de5c7cabe96ba95b229d274f5ca"},
+]
+
+[package.dependencies]
+numpy = "*"
+nvidia-nccl-cu12 = {version = "*", markers = "platform_system == \"Linux\" and platform_machine != \"aarch64\""}
+scipy = "*"
+
+[package.extras]
+dask = ["dask", "distributed", "pandas"]
+datatable = ["datatable"]
+pandas = ["pandas"]
+plotting = ["graphviz", "matplotlib"]
+pyspark = ["cloudpickle", "pyspark", "scikit-learn"]
+scikit-learn = ["scikit-learn"]
+
+[[package]]
+name = "zope-event"
+version = "5.0"
+description = "Very basic event publishing system"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "zope.event-5.0-py3-none-any.whl", hash = "sha256:2832e95014f4db26c47a13fdaef84cef2f4df37e66b59d8f1f4a8f319a632c26"},
+    {file = "zope.event-5.0.tar.gz", hash = "sha256:bac440d8d9891b4068e2b5a2c5e2c9765a9df762944bda6955f96bb9b91e67cd"},
+]
+
+[package.dependencies]
+setuptools = "*"
+
+[package.extras]
+docs = ["Sphinx"]
+test = ["zope.testrunner"]
+
+[[package]]
+name = "zope-interface"
+version = "6.4.post2"
+description = "Interfaces for Python"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "zope.interface-6.4.post2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2eccd5bef45883802848f821d940367c1d0ad588de71e5cabe3813175444202c"},
+    {file = "zope.interface-6.4.post2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:762e616199f6319bb98e7f4f27d254c84c5fb1c25c908c2a9d0f92b92fb27530"},
+    {file = "zope.interface-6.4.post2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ef8356f16b1a83609f7a992a6e33d792bb5eff2370712c9eaae0d02e1924341"},
+    {file = "zope.interface-6.4.post2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e4fa5d34d7973e6b0efa46fe4405090f3b406f64b6290facbb19dcbf642ad6b"},
+    {file = "zope.interface-6.4.post2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d22fce0b0f5715cdac082e35a9e735a1752dc8585f005d045abb1a7c20e197f9"},
+    {file = "zope.interface-6.4.post2-cp310-cp310-win_amd64.whl", hash = "sha256:97e615eab34bd8477c3f34197a17ce08c648d38467489359cb9eb7394f1083f7"},
+    {file = "zope.interface-6.4.post2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:599f3b07bde2627e163ce484d5497a54a0a8437779362395c6b25e68c6590ede"},
+    {file = "zope.interface-6.4.post2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:136cacdde1a2c5e5bc3d0b2a1beed733f97e2dad8c2ad3c2e17116f6590a3827"},
+    {file = "zope.interface-6.4.post2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47937cf2e7ed4e0e37f7851c76edeb8543ec9b0eae149b36ecd26176ff1ca874"},
+    {file = "zope.interface-6.4.post2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f0a6be264afb094975b5ef55c911379d6989caa87c4e558814ec4f5125cfa2e"},
+    {file = "zope.interface-6.4.post2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47654177e675bafdf4e4738ce58cdc5c6d6ee2157ac0a78a3fa460942b9d64a8"},
+    {file = "zope.interface-6.4.post2-cp311-cp311-win_amd64.whl", hash = "sha256:e2fb8e8158306567a3a9a41670c1ff99d0567d7fc96fa93b7abf8b519a46b250"},
+    {file = "zope.interface-6.4.post2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b912750b13d76af8aac45ddf4679535def304b2a48a07989ec736508d0bbfbde"},
+    {file = "zope.interface-6.4.post2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4ac46298e0143d91e4644a27a769d1388d5d89e82ee0cf37bf2b0b001b9712a4"},
+    {file = "zope.interface-6.4.post2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86a94af4a88110ed4bb8961f5ac72edf782958e665d5bfceaab6bf388420a78b"},
+    {file = "zope.interface-6.4.post2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:73f9752cf3596771c7726f7eea5b9e634ad47c6d863043589a1c3bb31325c7eb"},
+    {file = "zope.interface-6.4.post2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00b5c3e9744dcdc9e84c24ed6646d5cf0cf66551347b310b3ffd70f056535854"},
+    {file = "zope.interface-6.4.post2-cp312-cp312-win_amd64.whl", hash = "sha256:551db2fe892fcbefb38f6f81ffa62de11090c8119fd4e66a60f3adff70751ec7"},
+    {file = "zope.interface-6.4.post2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96ac6b3169940a8cd57b4f2b8edcad8f5213b60efcd197d59fbe52f0accd66e"},
+    {file = "zope.interface-6.4.post2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cebff2fe5dc82cb22122e4e1225e00a4a506b1a16fafa911142ee124febf2c9e"},
+    {file = "zope.interface-6.4.post2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33ee982237cffaf946db365c3a6ebaa37855d8e3ca5800f6f48890209c1cfefc"},
+    {file = "zope.interface-6.4.post2-cp37-cp37m-macosx_11_0_x86_64.whl", hash = "sha256:fbf649bc77510ef2521cf797700b96167bb77838c40780da7ea3edd8b78044d1"},
+    {file = "zope.interface-6.4.post2-cp37-cp37m-win_amd64.whl", hash = "sha256:4c0b208a5d6c81434bdfa0f06d9b667e5de15af84d8cae5723c3a33ba6611b82"},
+    {file = "zope.interface-6.4.post2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d3fe667935e9562407c2511570dca14604a654988a13d8725667e95161d92e9b"},
+    {file = "zope.interface-6.4.post2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a96e6d4074db29b152222c34d7eec2e2db2f92638d2b2b2c704f9e8db3ae0edc"},
+    {file = "zope.interface-6.4.post2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:866a0f583be79f0def667a5d2c60b7b4cc68f0c0a470f227e1122691b443c934"},
+    {file = "zope.interface-6.4.post2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5fe919027f29b12f7a2562ba0daf3e045cb388f844e022552a5674fcdf5d21f1"},
+    {file = "zope.interface-6.4.post2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e0343a6e06d94f6b6ac52fbc75269b41dd3c57066541a6c76517f69fe67cb43"},
+    {file = "zope.interface-6.4.post2-cp38-cp38-win_amd64.whl", hash = "sha256:dabb70a6e3d9c22df50e08dc55b14ca2a99da95a2d941954255ac76fd6982bc5"},
+    {file = "zope.interface-6.4.post2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:706efc19f9679a1b425d6fa2b4bc770d976d0984335eaea0869bd32f627591d2"},
+    {file = "zope.interface-6.4.post2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3d136e5b8821073e1a09dde3eb076ea9988e7010c54ffe4d39701adf0c303438"},
+    {file = "zope.interface-6.4.post2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1730c93a38b5a18d24549bc81613223962a19d457cfda9bdc66e542f475a36f4"},
+    {file = "zope.interface-6.4.post2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bc2676312cc3468a25aac001ec727168994ea3b69b48914944a44c6a0b251e79"},
+    {file = "zope.interface-6.4.post2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a62fd6cd518693568e23e02f41816adedfca637f26716837681c90b36af3671"},
+    {file = "zope.interface-6.4.post2-cp39-cp39-win_amd64.whl", hash = "sha256:d3f7e001328bd6466b3414215f66dde3c7c13d8025a9c160a75d7b2687090d15"},
+    {file = "zope.interface-6.4.post2.tar.gz", hash = "sha256:1c207e6f6dfd5749a26f5a5fd966602d6b824ec00d2df84a7e9a924e8933654e"},
+]
+
+[package.dependencies]
+setuptools = "*"
+
+[package.extras]
+docs = ["Sphinx", "repoze.sphinx.autointerface", "sphinx-rtd-theme"]
+test = ["coverage (>=5.0.3)", "zope.event", "zope.testing"]
+testing = ["coverage (>=5.0.3)", "zope.event", "zope.testing"]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "~3.10"
+content-hash = "6bcf5787c5c5ea9f571129e0b0bf8a96277ec9c9396ae13e085ae5e3bf8f3167"
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..084b0da
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,49 @@
+[tool.poetry]
+name = "latam-challange"
+version = "0.1.0"
+description = ""
+authors = ["santiago suarez <santiago@tryolabs.com>"]
+readme = "README.md"
+packages = [
+    { include = "challenge" }
+]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.dependencies]
+python = "~3.10"
+fastapi = "^0.111.0"
+pydantic = "~1.10.2"
+uvicorn = "~0.15.0"
+numpy = "~1.22.4"
+pandas = "~1.3.5"
+scikit-learn = "~1.3.0"
+
+[tool.poetry.group.dev.dependencies]
+matplotlib = "~3.7.2"
+seaborn = "~0.12.2"
+black = "23.3.0"
+isort = "5.12.0"
+flake8 = "6.0.0"
+ipykernel = "^6.29.5"
+xgboost = "^2.1.0"
+ipdb = "^0.13.13"
+
+[tool.poetry.group.test.dependencies]
+locust = "^2.0"
+coverage = "~5.5"
+pytest = "~6.2.5"
+pytest-cov = "~2.12.1"
+mockito = "~1.2.2"
+flask = "^2.2.2"
+
+[tool.black]
+line-length = 88
+preview = true
+
+[tool.isort]
+atomic = true
+profile = "black"
+skip = [".venv"]
\ No newline at end of file
diff --git a/scripts/deploy.sh b/scripts/deploy.sh
new file mode 100644
index 0000000..7a7abdd
--- /dev/null
+++ b/scripts/deploy.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# notice that to perform the deploy you should:
+# * have a google could account
+# * have a project setted up on google cloud
+# * install and init google cloud cli
+# * have your apis enabled in run.googleapis.com in your project (will be prompted to enable them)
+#   * may cause an error the first time, as the request to run and enable the apis
+#     generate a race condition
+
+# settings to configure
+repo_name="delay-model-image"
+container_tag="delay-model-container"
+service_name="delay-model-api"
+current_project=$(gcloud config get-value project)
+region="us-west1"
+DOCKER_IMAGE_FORMAT="docker.pkg.dev" # script is not intended to work by modifying this value
+repo_address="${region}-${DOCKER_IMAGE_FORMAT}/${current_project}/${repo_name}"
+
+# run training
+python challenge/model.py
+
+# allow docker to authenticate to gcp
+gcloud auth configure-docker ${region}-${DOCKER_IMAGE_FORMAT}
+
+# create repo to store docker image
+gcloud artifacts repositories create \
+    --repository-format=docker \
+    --location=${region} \
+    ${repo_name}
+
+# build docker container with appropriate tag and push it
+docker build . -t ${repo_address}/${container_tag} --platform linux/amd64
+docker push ${repo_address}/${container_tag}
+
+# deploy the image
+gcloud run deploy ${service_name} \
+    --image ${repo_address}/${container_tag} \
+    --allow-unauthenticated \
+    --region ${region}
\ No newline at end of file
diff --git a/src/latam/test_script.py b/src/latam/test_script.py
new file mode 100644
index 0000000..0c3bc21
--- /dev/null
+++ b/src/latam/test_script.py
@@ -0,0 +1,2 @@
+def print_sth():
+    print("something was printed from this package")
diff --git a/tests/api/test_api.py b/tests/api/test_api.py
index 8f3c9b5..432fc5f 100644
--- a/tests/api/test_api.py
+++ b/tests/api/test_api.py
@@ -1,67 +1,44 @@
 import unittest
 
 from fastapi.testclient import TestClient
+
 from challenge import app
 
 
 class TestBatchPipeline(unittest.TestCase):
     def setUp(self):
         self.client = TestClient(app)
-        
+
     def test_should_get_predict(self):
         data = {
-            "flights": [
-                {
-                    "OPERA": "Aerolineas Argentinas", 
-                    "TIPOVUELO": "N", 
-                    "MES": 3
-                }
-            ]
+            "flights": [{"OPERA": "Aerolineas Argentinas", "TIPOVUELO": "N", "MES": 3}]
         }
-        # when("xgboost.XGBClassifier").predict(ANY).thenReturn(np.array([0])) # change this line to the model of chosing
+        # when("xgboost.XGBClassifier").predict(ANY).thenReturn(np.array([0])
+        # change this line to the model of chosing
         response = self.client.post("/predict", json=data)
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.json(), {"predict": [0]})
-    
 
     def test_should_failed_unkown_column_1(self):
-        data = {       
-            "flights": [
-                {
-                    "OPERA": "Aerolineas Argentinas", 
-                    "TIPOVUELO": "N",
-                    "MES": 13
-                }
-            ]
+        data = {
+            "flights": [{"OPERA": "Aerolineas Argentinas", "TIPOVUELO": "N", "MES": 13}]
         }
-        # when("xgboost.XGBClassifier").predict(ANY).thenReturn(np.array([0]))# change this line to the model of chosing
+        # when("xgboost.XGBClassifier").predict(ANY).thenReturn(np.array([0]))
+        # change this line to the model of chosing
         response = self.client.post("/predict", json=data)
         self.assertEqual(response.status_code, 400)
 
     def test_should_failed_unkown_column_2(self):
-        data = {        
-            "flights": [
-                {
-                    "OPERA": "Aerolineas Argentinas", 
-                    "TIPOVUELO": "O", 
-                    "MES": 13
-                }
-            ]
+        data = {
+            "flights": [{"OPERA": "Aerolineas Argentinas", "TIPOVUELO": "O", "MES": 13}]
         }
-        # when("xgboost.XGBClassifier").predict(ANY).thenReturn(np.array([0]))# change this line to the model of chosing
+        # when("xgboost.XGBClassifier").predict(ANY).thenReturn(np.array([0]))
+        # change this line to the model of chosing
         response = self.client.post("/predict", json=data)
         self.assertEqual(response.status_code, 400)
-    
+
     def test_should_failed_unkown_column_3(self):
-        data = {        
-            "flights": [
-                {
-                    "OPERA": "Argentinas", 
-                    "TIPOVUELO": "O", 
-                    "MES": 13
-                }
-            ]
-        }
+        data = {"flights": [{"OPERA": "Argentinas", "TIPOVUELO": "O", "MES": 13}]}
         # when("xgboost.XGBClassifier").predict(ANY).thenReturn(np.array([0]))
         response = self.client.post("/predict", json=data)
-        self.assertEqual(response.status_code, 400)
\ No newline at end of file
+        self.assertEqual(response.status_code, 400)
diff --git a/tests/model/test_model.py b/tests/model/test_model.py
index e4afabb..28772d8 100644
--- a/tests/model/test_model.py
+++ b/tests/model/test_model.py
@@ -1,14 +1,15 @@
 import unittest
-import pandas as pd
 
+import pandas as pd
 from sklearn.metrics import classification_report
 from sklearn.model_selection import train_test_split
+
 from challenge.model import DelayModel
 
-class TestModel(unittest.TestCase):
 
+class TestModel(unittest.TestCase):
     FEATURES_COLS = [
-        "OPERA_Latin American Wings", 
+        "OPERA_Latin American Wings",
         "MES_7",
         "MES_10",
         "OPERA_Grupo LATAM",
@@ -17,27 +18,18 @@ class TestModel(unittest.TestCase):
         "MES_4",
         "MES_11",
         "OPERA_Sky Airline",
-        "OPERA_Copa Air"
-    ]
-
-    TARGET_COL = [
-        "delay"
+        "OPERA_Copa Air",
     ]
 
+    TARGET_COL = ["delay"]
 
     def setUp(self) -> None:
         super().setUp()
         self.model = DelayModel()
-        self.data = pd.read_csv(filepath_or_buffer="../data/data.csv")
-        
-
-    def test_model_preprocess_for_training(
-        self
-    ):
-        features, target = self.model.preprocess(
-            data=self.data,
-            target_column="delay"
-        )
+        self.data = pd.read_csv(filepath_or_buffer="data/data.csv")
+
+    def test_model_preprocess_for_training(self):
+        features, target = self.model.preprocess(data=self.data, target_column="delay")
 
         assert isinstance(features, pd.DataFrame)
         assert features.shape[1] == len(self.FEATURES_COLS)
@@ -47,57 +39,44 @@ def test_model_preprocess_for_training(
         assert target.shape[1] == len(self.TARGET_COL)
         assert set(target.columns) == set(self.TARGET_COL)
 
-
-    def test_model_preprocess_for_serving(
-        self
-    ):
-        features = self.model.preprocess(
-            data=self.data
-        )
+    def test_model_preprocess_for_serving(self):
+        features = self.model.preprocess(data=self.data)
 
         assert isinstance(features, pd.DataFrame)
         assert features.shape[1] == len(self.FEATURES_COLS)
         assert set(features.columns) == set(self.FEATURES_COLS)
 
+    def test_model_fit(self):
+        features, target = self.model.preprocess(data=self.data, target_column="delay")
 
-    def test_model_fit(
-        self
-    ):
-        features, target = self.model.preprocess(
-            data=self.data,
-            target_column="delay"
+        _, features_validation, _, target_validation = train_test_split(
+            features, target, test_size=0.33, random_state=42
         )
 
-        _, features_validation, _, target_validation = train_test_split(features, target, test_size = 0.33, random_state = 42)
+        self.model.fit(features=features, target=target)
 
-        self.model.fit(
-            features=features,
-            target=target
-        )
+        predicted_target = self.model._model.predict(features_validation)
 
-        predicted_target = self.model._model.predict(
-            features_validation
+        report = classification_report(
+            target_validation, predicted_target, output_dict=True
         )
 
-        report = classification_report(target_validation, predicted_target, output_dict=True)
-        
+        print(report)
+
         assert report["0"]["recall"] < 0.60
         assert report["0"]["f1-score"] < 0.70
         assert report["1"]["recall"] > 0.60
         assert report["1"]["f1-score"] > 0.30
 
+    def test_model_predict(self):
+        features, target = self.model.preprocess(data=self.data, target_column="delay")
 
-    def test_model_predict(
-        self
-    ):
-        features = self.model.preprocess(
-            data=self.data
-        )
+        self.model.fit(features=features, target=target)
 
-        predicted_targets = self.model.predict(
-            features=features
-        )
+        predicted_targets = self.model.predict(features=features)
 
         assert isinstance(predicted_targets, list)
         assert len(predicted_targets) == features.shape[0]
-        assert all(isinstance(predicted_target, int) for predicted_target in predicted_targets)
\ No newline at end of file
+        assert all(
+            isinstance(predicted_target, int) for predicted_target in predicted_targets
+        )
diff --git a/tests/stress/api_stress.py b/tests/stress/api_stress.py
index 14c21fb..b8d958f 100644
--- a/tests/stress/api_stress.py
+++ b/tests/stress/api_stress.py
@@ -1,34 +1,21 @@
 from locust import HttpUser, task
 
+
 class StressUser(HttpUser):
-    
     @task
     def predict_argentinas(self):
         self.client.post(
-            "/predict", 
+            "/predict",
             json={
                 "flights": [
-                    {
-                        "OPERA": "Aerolineas Argentinas", 
-                        "TIPOVUELO": "N", 
-                        "MES": 3
-                    }
+                    {"OPERA": "Aerolineas Argentinas", "TIPOVUELO": "N", "MES": 3}
                 ]
-            }
+            },
         )
 
-
     @task
     def predict_latam(self):
         self.client.post(
-            "/predict", 
-            json={
-                "flights": [
-                    {
-                        "OPERA": "Grupo LATAM", 
-                        "TIPOVUELO": "N", 
-                        "MES": 3
-                    }
-                ]
-            }
-        )
\ No newline at end of file
+            "/predict",
+            json={"flights": [{"OPERA": "Grupo LATAM", "TIPOVUELO": "N", "MES": 3}]},
+        )