From 750bb1b348634018bfcbb3a3df5634802a59f214 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Sat, 21 Oct 2023 21:14:05 +0100 Subject: [PATCH 1/4] Write tests for rank conversion - utility to rank - preference to rank --- tests/test_convert.py | 71 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 tests/test_convert.py diff --git a/tests/test_convert.py b/tests/test_convert.py new file mode 100644 index 00000000..295ea9da --- /dev/null +++ b/tests/test_convert.py @@ -0,0 +1,71 @@ +"""Tests for the `matching.convert` module.""" + +import itertools + +import numpy as np +from hypothesis import given, settings +from hypothesis import strategies as st +from hypothesis.extra.numpy import arrays + +from matching import convert + + +@st.composite +def utilities(draw, smin=1, smax=10, unique=True): + """Create a utility matrix for a test.""" + + shape = draw(st.tuples(st.integers(smin, smax), st.integers(smin, smax))) + utilities = draw( + arrays(float, shape, elements=st.floats(0, 1), unique=unique) + ) + + return utilities + + +@st.composite +def preferences(draw, pmin=1, pmax=10): + """Create a preference dictionary to test.""" + + players = draw( + st.lists(st.integers(), min_size=pmin, max_size=pmax, unique=True) + ) + others = draw( + st.lists(st.text(), min_size=pmin, max_size=pmax, unique=True) + ) + + preference = {player: draw(st.permutations(others)) for player in players} + + return preference + + +@settings(deadline=600) +@given(utilities()) +def test_utility_to_rank(utility): + """Check that a utility matrix can be converted to ranks. + + We choose not to check that the ranking is correct because the + function is a wrapper for `scipy.stats.rankdata()`. + """ + + rank = convert.utility_to_rank(utility) + + assert isinstance(rank, np.ndarray) + assert rank.shape == utility.shape + assert (np.sort(rank) == np.arange(utility.shape[1])).all() + + +@given(preferences()) +def test_preference_to_rank(preference): + """Check that a preference dictionary can be converted to ranks.""" + + others = list(itertools.chain(*preference.values())) + rank = convert.preference_to_rank(preference, others) + + assert isinstance(rank, np.ndarray) + assert rank.shape == ( + len(preference.keys()), + len(list(preference.values())[0]), + ) + + for row, pref in zip(rank, preference.values()): + assert [others[r] for r in row] == pref From d9ab518a2a048add980a17e3e032e12cb4338e06 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Sat, 21 Oct 2023 21:14:49 +0100 Subject: [PATCH 2/4] Implement rank conversion (new dependency: scipy) --- pyproject.toml | 3 ++- src/matching/convert.py | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+), 1 deletion(-) create mode 100644 src/matching/convert.py diff --git a/pyproject.toml b/pyproject.toml index 09d9972a..848d7864 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,7 +29,8 @@ classifiers = [ "Topic :: Scientific/Engineering :: Information Analysis", ] dependencies = [ - "numpy>=1.19.2" + "numpy>=1.21.6", + "scipy>=1.11.3" ] dynamic = ["version"] diff --git a/src/matching/convert.py b/src/matching/convert.py new file mode 100644 index 00000000..f2aac697 --- /dev/null +++ b/src/matching/convert.py @@ -0,0 +1,22 @@ +"""A module for converting between different data structures.""" + +import numpy as np +from scipy.stats import rankdata + + +def preference_to_rank(preference, others): + """Convert a preference dictionary to a rank array.""" + + rank = np.array( + [[others.index(o) for o in prefs] for prefs in preference.values()] + ) + + return rank + + +def utility_to_rank(utility): + """Convert a utility array to a rank array.""" + + rank = rankdata(utility, method="ordinal", axis=1, nan_policy="omit") + + return rank - 1 From ee04279a8381492bece8b887672326e994f863f5 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 24 Oct 2024 16:02:47 +0100 Subject: [PATCH 3/4] `StableMarriage` rank internals (#175) * Write init test for new single matching * Move to ruff over black for formatting * Remove limit on parallel CI * Write test for SingleMatching repr dunder method * Check dictionary is in single matching repr * Write test for equivalence dunder * Write test for single matching inverter * Remove old SingleMatching tests * Implement SingleMatching class * Move matching classes to subpackage * Write test for instantiating SM classes * Fix ruff config and add pre-commit * Write tests for utility builder * Write test for preference list builder (slow!) * Reduce test size for preference builder * Implement builders for SM * Write input validator tests * Implement input validator * Ensure higher utility leads to higher ranking * Reintegrate tests into modular structure * Translate SM algorithm test to rankings * Write test for player set attribute inverter * Move rank matrices to class attributes * Write tests for solver * Implement solver and algorithm * Rewrite preference converter test * Write test for converting incomplete preferences * Reimplement preference converter * Include preference lookup in attributes * Write optimality tests * Rewrite example tests * Ensure rejections are recorded * Write test for preference matching converter * Revert example tests to use preference terms * Implement a preference matching converter * Reformat code base and drop deprecated np.infty * Bump actions and drop support for Python<3.10 * Stop doctesting paper and fix examples in README * Update all docs that SM touches * Remove creation from instances how-to * Remove SM solver test module * Wrap SR tutorial solution with `dict()` for now The changes to `SingleMatching` are causing issues downstream. Still not sure what this will look like for SR in the future, but this will do for now. * Make small formatting changes * Add in manual matching update for SR test Again, the new `SingleMatching` class is causing issues for SR... * Remove change to SM discussion * Stop rejections leading to immediate forget --- .github/workflows/ci.yml | 14 +- .github/workflows/docs.yml | 8 +- .pre-commit-config.yaml | 18 + CITATION.cff | 2 +- README.md | 46 +-- _quarto.yml | 6 +- docs/discussion/stable_marriage.md | 6 +- docs/how-to/choose_optimality.ipynb | 14 +- docs/how-to/create_from_instances.ipynb | 90 ----- docs/tutorials/hospital_resident.ipynb | 15 +- docs/tutorials/stable_marriage.ipynb | 103 ++--- docs/tutorials/stable_roommates.ipynb | 15 +- docs/tutorials/student_allocation.ipynb | 24 +- pyproject.toml | 26 +- src/matching/algorithms/__init__.py | 2 - src/matching/algorithms/stable_marriage.py | 64 --- src/matching/convert.py | 17 +- src/matching/games/stable_marriage.py | 378 ++++++++++++------ src/matching/matchings/__init__.py | 6 + .../{matchings.py => matchings/multiple.py} | 32 +- src/matching/matchings/single.py | 65 +++ tests/hospital_resident/data/issue_159.json | 2 +- tests/hospital_resident/test_algorithm.py | 2 +- tests/matchings/test_single.py | 106 +++++ tests/stable_marriage/strategies.py | 113 ++++++ tests/stable_marriage/test_algorithm.py | 75 ++-- tests/stable_marriage/test_examples.py | 96 ++--- tests/stable_marriage/test_game.py | 316 +++++++++++++++ tests/stable_marriage/test_solver.py | 192 --------- tests/stable_roommates/test_solver.py | 9 + tests/student_allocation/test_algorithm.py | 2 +- tests/test_convert.py | 35 +- tests/test_matchings.py | 42 +- tex/stable_marriage.tex | 12 +- 34 files changed, 1123 insertions(+), 830 deletions(-) create mode 100644 .pre-commit-config.yaml delete mode 100644 docs/how-to/create_from_instances.ipynb delete mode 100644 src/matching/algorithms/stable_marriage.py create mode 100644 src/matching/matchings/__init__.py rename src/matching/{matchings.py => matchings/multiple.py} (51%) create mode 100644 src/matching/matchings/single.py create mode 100644 tests/matchings/test_single.py create mode 100644 tests/stable_marriage/strategies.py create mode 100644 tests/stable_marriage/test_game.py delete mode 100644 tests/stable_marriage/test_solver.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ca158596..59935c25 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,17 +14,16 @@ jobs: run: shell: bash strategy: - max-parallel: 10 matrix: os: [ubuntu-latest, windows-latest] - python-version: [3.7, 3.8, 3.9, "3.10", "3.11"] + python-version: ["3.10", "3.11", "3.12"] steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} cache: "pip" @@ -37,16 +36,15 @@ jobs: - name: Run tests run: | python -m doctest README.md - python -m doctest paper.md python -m pytest docs --nbval --nbval-current-env -p no:randomly python -m pytest tests \ --cov=matching --cov-fail-under=100 --hypothesis-profile=ci - - name: Install and run linters (3.11-ubuntu only) + - name: Install and run linters (3.12-ubuntu only) if: | - matrix.python-version == '3.11' && + matrix.python-version == '3.12' && matrix.os == 'ubuntu-latest' run: | python -m pip install ".[lint]" - python -m black --check . python -m ruff check . + python -m ruff format --check . diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index b2fc4a8f..69039680 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -12,13 +12,13 @@ jobs: contents: write steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Set up Quarto uses: quarto-dev/quarto-actions/setup@v2 - name: Install Python and dependencies - uses: actions/setup-python@v4 + uses: actions/setup-python@v5 with: - python-version: "3.9" + python-version: "3.12" cache: "pip" - run: | python -m pip install ".[dev]" @@ -28,4 +28,4 @@ jobs: with: target: gh-pages env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..21d97611 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,18 @@ +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.6.0 + hooks: + - id: check-added-large-files + name: Check for files larger than 5 MB + args: [ "--maxkb=5120" ] + - id: end-of-file-fixer + name: Check for a blank line at the end of scripts (auto-fixes) + exclude: '\.Rd' + - id: trailing-whitespace + name: Check for trailing whitespaces (auto-fixes) + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.7.0 + hooks: + - id: ruff + args: [ --fix ] + - id: ruff-format diff --git a/CITATION.cff b/CITATION.cff index 594d3265..024243d6 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -27,4 +27,4 @@ keywords: - matching - python - game -license: MIT \ No newline at end of file +license: MIT diff --git a/README.md b/README.md index d21fcc47..6cb4767a 100644 --- a/README.md +++ b/README.md @@ -76,60 +76,42 @@ We can construct these preferences using dictionaries: Then to solve this matching game, we make use of the `StableMarriage` class, like so: - ```python >>> from matching.games import StableMarriage ->>> game = StableMarriage.create_from_dictionaries( +>>> game = StableMarriage.from_preferences( ... suitor_preferences, reviewer_preferences ... ) ->>> game.solve() -{A: E, B: D, C: F} +>>> matching = game.solve() +>>> dict(matching) +{'F': 'C', 'D': 'B', 'E': 'A'} ``` ## The `Matching` object -This matching is not a standard Python dictionary, though it does +The matching itself is not a standard Python dictionary, though it does largely look and behave like one. It is in fact an instance of the `SingleMatching` class: ```python ->>> matching = game.matching >>> type(matching) - + +>>> isinstance(matching, dict) +True +>>> matching +SingleMatching({'F': 'C', 'D': 'B', 'E': 'A'}, keys="reviewers", values="suitors") ``` -This dictionary-like object is primarily useful as a teaching device -that eases the process of manipulating a matching after a solution has -been found. - -## `Player` classes - -Despite passing dictionaries of strings here, the matching displays -instances of `matching.player.Player`: +This object allows for straightforward manipulation of the underlying +dictionary, for instance by inverting it: ```python ->>> matching = game.matching ->>> for suitor in matching: -... print(type(suitor)) - - - +>>> dict(matching.invert()) +{'C': 'F', 'B': 'D', 'A': 'E'} ``` -This is because `create_from_dictionaries` creates instances of the -appropriate player classes first and passes them to the game class. -Using dictionaries like this can be an efficient way of creating large -games but it does require the names of the players in each party to be -unique. - -With all games, Matching uses a `Player` class to represent the members -of the "applying" party, i.e. residents and students. For HR and SA, -there are specific classes to represent the roles of `Hospital`, -`Project` and `Supervisor`. - ## A note on performance One of the limitations of this library is the time complexities of the diff --git a/_quarto.yml b/_quarto.yml index 73c74a5c..6621cb9b 100644 --- a/_quarto.yml +++ b/_quarto.yml @@ -34,7 +34,7 @@ website: contents: docs/discussion - title: reference contents: docs/reference - + page-footer: left: > @@ -53,7 +53,7 @@ bibliography: docs/assets/bibliography.bib toc: true -metadata-files: +metadata-files: - docs/_sidebar.yml quartodoc: @@ -61,7 +61,7 @@ quartodoc: package: matching dir: docs/reference sidebar: docs/_sidebar.yml - + sections: - title: Games desc: Objects for handling game instances. diff --git a/docs/discussion/stable_marriage.md b/docs/discussion/stable_marriage.md index f18ed4ca..60bec788 100644 --- a/docs/discussion/stable_marriage.md +++ b/docs/discussion/stable_marriage.md @@ -91,10 +91,10 @@ efficient, robust extension of the original algorithm, taken from @GI89, is given below. 0. Assign all suitors and reviewers to be unmatched. -1. Take any suitor $s$ that is not currently matched, and consider - their favourite reviewer $r$. +1. Take any suitor $s$ that is not currently matched but has a non-empty + preference list, and consider their favourite reviewer $r$. 2. If $r$ is matched, get their current match $s' = M^{-1}(r)$ and - unmatch the pair. + unmatch them. 3. Match $s$ and $r$, i.e. set $M(s) = r$. 4. For each successor, $t$, to $s$ in $g(r)$, delete the pair $(t, r)$ from the game by removing $r$ from $f(t)$ and $t$ from $g(r)$. diff --git a/docs/how-to/choose_optimality.ipynb b/docs/how-to/choose_optimality.ipynb index c8db482e..9d78354a 100644 --- a/docs/how-to/choose_optimality.ipynb +++ b/docs/how-to/choose_optimality.ipynb @@ -47,7 +47,7 @@ { "data": { "text/plain": [ - "{A: X, B: Z, C: Y}" + "SingleMatching({'Y': 'C', 'Z': 'B', 'X': 'A'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 2, @@ -56,7 +56,7 @@ } ], "source": [ - "game = StableMarriage.create_from_dictionaries(\n", + "game = StableMarriage.from_preferences(\n", " suitor_preferences, reviewer_preferences\n", ")\n", "\n", @@ -71,7 +71,7 @@ { "data": { "text/plain": [ - "{A: Y, B: Z, C: X}" + "SingleMatching({'Y': 'A', 'Z': 'B', 'X': 'C'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 3, @@ -80,7 +80,7 @@ } ], "source": [ - "game = StableMarriage.create_from_dictionaries(\n", + "game = StableMarriage.from_preferences(\n", " suitor_preferences, reviewer_preferences\n", ")\n", "\n", @@ -90,9 +90,9 @@ ], "metadata": { "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -104,7 +104,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/how-to/create_from_instances.ipynb b/docs/how-to/create_from_instances.ipynb deleted file mode 100644 index 5227249b..00000000 --- a/docs/how-to/create_from_instances.ipynb +++ /dev/null @@ -1,90 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Create a game from `Player` instances\n", - "\n", - "Any game in Matching can be made by manually creating instances of the `Player` class (or its child classes) and setting their preferences using those instances.\n", - "\n", - "Consider the following instance of SM." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from matching import Player\n", - "\n", - "suitors = [Player(name=\"A\"), Player(name=\"B\"), Player(name=\"C\")]\n", - "reviewers = [Player(name=\"D\"), Player(name=\"E\"), Player(name=\"F\")]\n", - "\n", - "(A, B, C), (D, E, F) = suitors, reviewers" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The preferences are then set using the `set_prefs` method of whichever `Player` class you're using." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "A.set_prefs([D, E, F])\n", - "B.set_prefs([D, F, E])\n", - "C.set_prefs([F, D, E])\n", - "\n", - "D.set_prefs([B, C, A])\n", - "E.set_prefs([A, C, B])\n", - "F.set_prefs([C, B, A])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, the game can be made by passing the lists of players directly." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from matching.games import StableMarriage\n", - "\n", - "game = StableMarriage(suitors, reviewers)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "matching-docs", - "language": "python", - "name": "matching-docs" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.16" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/tutorials/hospital_resident.ipynb b/docs/tutorials/hospital_resident.ipynb index 8d487464..d136dbaf 100644 --- a/docs/tutorials/hospital_resident.ipynb +++ b/docs/tutorials/hospital_resident.ipynb @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -225,13 +225,6 @@ "unmatched_residents" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, @@ -245,9 +238,9 @@ ], "metadata": { "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -259,7 +252,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/tutorials/stable_marriage.ipynb b/docs/tutorials/stable_marriage.ipynb index a172ca2c..b4aa2ef7 100644 --- a/docs/tutorials/stable_marriage.ipynb +++ b/docs/tutorials/stable_marriage.ipynb @@ -27,74 +27,40 @@ "From here on out, we'll refer to the men and women as suitors and reviewers,\n", "respectively.\n", "\n", - "## Creating the players and their preferences\n", + "## Defining the players and their preferences\n", "\n", - "To begin, we create an instance of the `Player` class for each suitor and\n", - "reviewer:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from matching import Player\n", - "\n", - "suitors = [\n", - " Player(\"Bingley\"),\n", - " Player(\"Collins\"),\n", - " Player(\"Darcy\"),\n", - " Player(\"Wickham\"),\n", - "]\n", - "\n", - "reviewers = [\n", - " Player(\"Charlotte\"),\n", - " Player(\"Elizabeth\"),\n", - " Player(\"Jane\"),\n", - " Player(\"Lydia\"),\n", - "]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To set a player's preferences, we use the `Player.set_prefs()` method.\n", - "\n", - "Each player's preferences must be a list of all the `Player` instances in the\n", - "other party ordered according to how much they like them.\n", - "That is, put your favourite first, followed by your second,\n", - "and so on until you've put your least favourite last.\n", + "To begin, we create a dictionary of preference lists for the suitors and reviewers respectively.\n", + "These preference lists are ordered so your favourite comes first, then your second favourite, and\n", + "so on.\n", "\n", - "::: {.callout-warning}\n", - "The preference lists below are based on\n", - "some very loose interpretations of the original text\n", - "and the need to create full lists.\n", - "Please do not come for me about them.\n", - ":::\n", + "::: {.callout-note}\n", + "These preference lists are based purely on my interpretation of two adaptations of the book:\n", + "Gurinder Chadha's 2004 Bollywood-style adaptation, Bride and Prejudice, and Joe Wright's 2006 film,\n", + "starring Keira Knightley.\n", "\n", - "A nice way to do this is by unpacking `suitors` and `reviewers`:" + "I cannot and will not speak for Austen's intentions.\n", + ":::" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "bingley, collins, darcy, wickham = suitors\n", - "charlotte, elizabeth, jane, lydia = reviewers\n", + "suitors = {\n", + " \"Bingley\": (\"Jane\", \"Elizabeth\", \"Lydia\", \"Charlotte\"),\n", + " \"Collins\": (\"Jane\", \"Elizabeth\", \"Lydia\", \"Charlotte\"),\n", + " \"Darcy\": (\"Elizabeth\", \"Jane\", \"Charlotte\", \"Lydia\"),\n", + " \"Wickham\": (\"Lydia\", \"Jane\", \"Elizabeth\", \"Charlotte\"),\n", + "}\n", "\n", - "bingley.set_prefs([jane, elizabeth, lydia, charlotte])\n", - "collins.set_prefs([elizabeth, jane, lydia, charlotte])\n", - "darcy.set_prefs([elizabeth, jane, charlotte, lydia])\n", - "wickham.set_prefs([lydia, jane, elizabeth, charlotte])\n", - "\n", - "charlotte.set_prefs([collins, darcy, bingley, wickham])\n", - "elizabeth.set_prefs([wickham, darcy, bingley, collins])\n", - "jane.set_prefs([bingley, wickham, darcy, collins])\n", - "lydia.set_prefs([wickham, bingley, darcy, collins])" + "reviewers = {\n", + " \"Charlotte\": (\"Bingley\", \"Darcy\", \"Collins\", \"Wickham\"),\n", + " \"Elizabeth\": (\"Wickham\", \"Darcy\", \"Bingley\", \"Collins\"),\n", + " \"Jane\": (\"Bingley\", \"Wickham\", \"Darcy\", \"Collins\"),\n", + " \"Lydia\": (\"Bingley\", \"Wickham\", \"Darcy\", \"Collins\"),\n", + "}" ] }, { @@ -103,19 +69,19 @@ "source": [ "## Running the game\n", "\n", - "With our now complete `Player` instances,\n", - "we pass the lists of players to the `StableMarriage` class to create a game:" + "We create the game by passing our preference list dictionaries to the\n", + "`StableMarriage.from_preferences()` class method:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from matching.games import StableMarriage\n", "\n", - "game = StableMarriage(suitors, reviewers)" + "game = StableMarriage.from_preferences(suitors, reviewers)" ] }, { @@ -127,16 +93,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{Bingley: Jane, Collins: Charlotte, Darcy: Elizabeth, Wickham: Lydia}" + "SingleMatching({'Lydia': 'Wickham', 'Elizabeth': 'Darcy', 'Jane': 'Bingley', 'Charlotte': 'Collins'}, keys=\"reviewers\", values=\"suitors\")" ] }, - "execution_count": 9, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -156,13 +122,10 @@ } ], "metadata": { - "interpreter": { - "hash": "a8c967c2db996a903b0ac2ddddd52d1718dfee8994011f28d022363595a494ba" - }, "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -174,7 +137,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/tutorials/stable_roommates.ipynb b/docs/tutorials/stable_roommates.ipynb index 1f07d940..e1f3154d 100644 --- a/docs/tutorials/stable_roommates.ipynb +++ b/docs/tutorials/stable_roommates.ipynb @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -109,13 +109,13 @@ "{jerry: george, george: jerry, kramer: elaine, elaine: kramer}" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "game.solve()" + "dict(game.solve())" ] }, { @@ -129,13 +129,10 @@ } ], "metadata": { - "interpreter": { - "hash": "a8c967c2db996a903b0ac2ddddd52d1718dfee8994011f28d022363595a494ba" - }, "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -147,7 +144,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/tutorials/student_allocation.ipynb b/docs/tutorials/student_allocation.ipynb index 2a8fb77e..303114aa 100644 --- a/docs/tutorials/student_allocation.ipynb +++ b/docs/tutorials/student_allocation.ipynb @@ -1083,7 +1083,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACAoAAASUCAYAAADk0n3YAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAC4jAAAuIwF4pT92AADEHklEQVR4nOzdd5RV1dk/8OfSe5MiShNFRRRBLIgFVGyxgr0FMWqseTUmsSbRxPIz8TUxtlhBY2IH1KhEMYAFC4gVEaQMiIqA9M4w5/eHi3m93BmYBsN4Pp+1ZmXOvmfv/dx77h2yPN+7dyZJkiQAAAAAAAAAgFSoVtkFAAAAAAAAAACbj6AAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAABsRqNGjYpMJpP1M2rUqMouixJatGhR3HXXXXHSSSdFp06dolmzZlG9evWs69mtW7fKLhMAAAA2qEZlFwAAAFCR8vPz47PPPouJEyfGwoULY+HChbF27dqoX79+NGjQINq0aRMdOnSIDh06RO3atSu7XKAK+fvf/x6/+c1vYsmSJZVdCgAAAJSLoAAAAFDlrVq1KoYOHRoPP/xwvPnmm7FixYqN9qlZs2bsuuuusddee0Xv3r3jsMMOi+bNm2+GaoGq6I9//GP87ne/q+wyAAAAoEIICgAAAFXa888/HxdffHHMmjWrVP3WrFkTH3zwQXzwwQdx//33R7Vq1eLiiy+Ov/3tb5uoUqCqev/99+P666/Pac9kMtG2bdto0qRJZDKZwvaddtppM1YHAAAApScoAAAAVElJksTFF18c9957b4WMV1BQEDNnzqyQsYAfl9tvvz0KCgqy2q6++ur41a9+Fc2aNaukqgAAAKDsBAUAAIAq6YILLoj777+/yMfatWsXBx98cHTp0iVatGgR9evXj6VLl8aCBQviiy++iPfffz8++uijWLVq1WauGqhqCgoK4oUXXshqO+mkk+Lmm2+upIoAAACg/AQFAACAKmfYsGFFhgT22GOP+NOf/hQHH3xw1jLgRVm+fHkMHz48hg4dGkOHDo1ly5ZtqnIhS58+fSJJksougxKaOHFiLFmyJKvtlFNOqaRqAAAAoGIICgAAAFVKkiRx+eWX57T3798//vWvf0Xt2rVLNE69evWif//+0b9//1i0aFEMGjQovvrqq4ouF6jiitqSZKeddqqESgAAAKDiCAoAAABVypgxYyIvLy+rbdttt43BgweXOCSwvsaNG8dll11W/uKAH51FixbltNWvX78SKgEAAICKU62yCwAAACiNl19+Oaft7LPPjoYNG1ZCNcCP3cqVK3PaNra1CQAAAGzprCgAAABUKTNmzMhp69GjRyVUsmVbuXJlvPvuu/H555/HggULombNmrHNNtvEjjvuGHvssccmu9G5ePHieO+99+Lbb7+NuXPnxsqVK6N58+bRokWL2HPPPWPbbbfdJPP+0Jw5c2LcuHExffr0WLRoUWQymWjevHn069cvmjdvvsnn35y+/fbb+Oijj2LGjBmxePHiWLFiRdSpUyfq1asXW2+9dXTo0CF23HHHaNCgQYXMt3bt2hg/fnxMnz495s6dG4sWLYpmzZpFixYtYscdd4zddtutQubZmB/rNV64cGGMHTs2pk6dGgsXLoyCgoJo1qxZHHnkkdG+ffsSjVFQUBAffPBB5OXlxdy5c2P+/PnRqFGjaNGiReywww7RvXv3qFZt03xvZMWKFfHee+/FN998E3PmzImlS5fGVlttFS1atIjdd989tt9++00yb1kkSRLTpk2Ljz/+OGbPnh2LFy+O/Pz8qFu3bjRo0CDatGlT+PmpUaPi//PZ119/HWPHjo3p06fHsmXLolmzZrHNNtvEXnvtFdtss02FzrVixYqYPHlyfP755zFv3rxYvHhx1KhRI5o2bRrNmzePbt26RYcOHSp0zvWtXbs2Pvzww8jLy4t58+bF/Pnzo0aNGtGoUaPo0KFDdO7cOdq1a1dh882aNSs++uijmDt3bsydOzcymUy0aNEiWrduHT179oxGjRpV2Fxr1qyJiRMnxqeffhrz58+PxYsXRyaTibp160aTJk2iXbt20bFjx03+GgMAQKklAAAAVchhhx2WRETWz3/+85/NNv/06dNz5h80aFCZxurdu3fWOL17995on5EjR+bMP3LkyMLHp06dmgwcODCpV69eznnrftq1a5dce+21ydKlS8tU9/pWrlyZ3HnnnckBBxyQ1KhRo9h5IyLZZZddkptvvjlZsmRJqefZ0OtVUFCQ/POf/0x69uyZZDKZIuceOXJksmrVqmSrrbbKau/WrVu5X4Obb745Z74XX3yxyHM3dg03ZsGCBclNN92U7LLLLht8rdf9VK9ePdl9992Tyy67LHnzzTeTgoKCUj+/sWPHJqeeemrSrFmzDc61zTbbJOedd14yZcqUUs+RJBVzjctrwIABJXpdi/sZMGDARsds37591uMvvfRS0rdv36R69epFjlmSvzGvv/56csopp2z0GjVr1iw588wzkwkTJpT7tUqSJFm7dm3y6KOPJoceemhSp06dDc693XbbJVdeeWUyd+7cCpm7LCZNmpT84he/SFq1alWi61m3bt3kgAMOSG666aZk0qRJGx1/Y9d66NChyb777lvsfNWqVUsOOOCA5Nlnny3zcywoKEjefPPN5De/+U2y9957b/TvckQkbdq0SX7xi18kM2bMKPO8RXnuueeS4447LmncuPFGa2jXrl1y7rnnJqNHjy7TXN9++21y1VVXJV26dNngPDVq1Ej222+/5F//+leydu3aMj+3//73v8kpp5yS1K1bt0TvpebNmydHH310cv/991fqZwAAANYRFAAAAKqUY489Nuc/vt9///2bbf4tOSjw8MMPl/iGxbqbMiNGjChT7es89thjSdu2bUt9M7VFixbJE088Uaq5inu9Zs+enRx44IEbnXPd63TppZfmPPbBBx+U63XYaaedssZr3bp1kp+fX+S55QkKPPXUU0mLFi1K/Xr/8GfixIklfl5z585NTjnllGJvzBf3U7NmzeQXv/hFsnLlyhLPlSQVd43LY3MGBZYsWZKccMIJGx1zQ39jJk2alBx55JGlrrNatWrJz372s2TFihVlfq1efvnlEgdWfvjTsGHD5K9//WuZ5y2LgoKC5Lrrrktq1apV5mvbqlWrjc5T3LVetmxZ0r9//1LNd9xxx5X6hvKoUaPK9Dd53U+NGjWS6667rlw30JPk+79z3bt3L3Mdl156aYnnWrVqVfLb3/42qV+/fqnn2XXXXZOPPvqoVM9twYIFSb9+/cr1d+KUU04p7UsKAAAVbtOsNQcAALCJbL311jltTz31VCVUsmW5995745xzzokVK1aUuM/MmTPjJz/5Sbz44oulnq+goCAuv/zyOPPMM+PLL78sdf+5c+fGqaeeGr///e9L3feHZs+eHb169YrXX3+9xH0GDhyY0zZo0KAy1zBmzJiYNGlSVttPf/rTqF69epnHLMqDDz4Yp5xySsydO7dCxy3OtGnTolevXvHkk09GkiSl6rtmzZr429/+FoceemgsWLCgXHWU5RpXBcuWLYtDDjkknn322TKP8dprr8U+++wTL7/8cqn7FhQUxEMPPRS9e/eOb7/9ttT9b7vttjjqqKPis88+K3XfJUuWxGWXXRbnnntu5Ofnl7p/WQwYMCBuvPHGWL169WaZ74dWrVoVRx55ZAwZMqRU/Z577rk45JBD4rvvvitxn+nTp5fpb/I6+fn5ceONN8Zxxx1X5mvz17/+Nfr27RsffPBBmetYvHhxic6bP39+HHbYYfHHP/4xli1bVup5Pv3009hvv/3ihRdeKNH5CxYsiN69e8fQoUNLPRcAAGxpKn6TNQAAgE2oV69ecf/992e1jRgxIu6888649NJLK6mqyvXOO+/EddddV3hco0aNOPjgg6Nv376x7bbbxqpVq2LGjBnx/PPP59y4Wb16dZxwwgkxatSo6NmzZ4nnPOOMM+KJJ57Iad9mm23ikEMOie7du0fz5s2jTp06MX/+/Pjggw/i5ZdfjpkzZ2ad/4c//CFatGgRl1xySSmf9fc3Ok8++eSYNm1aYVvHjh3jqKOOip133jmaN28e3333XUyfPj2eeeaZwnO6d+8e3bp1iw8//LCw7V//+lfcdtttUbNmzVLXMXjw4Jy2osII5TF58uS45JJLcm7Y161bNw4++ODYa6+9on379tGgQYPIz8+PxYsXxzfffBMTJkyIsWPHRl5eXqnmmzNnTuy///7xzTff5DzWpk2b6N+/f3Tu3DmaNWsWc+bMiY8++iiGDh2ac0PzjTfeiL59+8aYMWOidu3apX7eZb3G5dGuXbvYfffdC4/nz5+fc+O1c+fOUatWrWL7l8T5558f7733XuHxNttsEz/5yU+ia9eu0bJly1i8eHHh57YoL7zwQpxwwgmxZs2arPZatWrFwQcfHPvss0+0bds2GjduHEuXLo28vLz473//G2+88UbW+e+9914cf/zx8frrr5f4/X/VVVfFrbfemtPerFmzOPTQQ6NHjx7RsmXLqFevXixcuDAmTJgQw4cPzwnUPPTQQ9GkSZO47bbbSjRvWT3yyCPxj3/8I6e9RYsWcfjhh8duu+0W22yzTdStWzdWrFgRS5YsienTp8eECRPi7bffLnfY5YorrsgKujRv3jz69+8fXbt2jebNm8e8efPik08+iSFDhuQEgT7++OM4/PDD4+233y7T36ett946evToEZ07d44OHTpEo0aNol69erFs2bKYM2dOfPLJJzF8+PCYM2dOVr9///vfcc0118Sf/vSnUs13zTXXxC233FLkYzvssEMcdthhsdNOO0WLFi0iSZJYsGBBTJ48OcaNGxfvvfdeqcIJCxcujP322y8+//zznMd23XXX6N27d3Tp0iWaNGkSEd//XXv77bfjpZdeiiVLlhSeu3Tp0jjppJPirbfeih49emxwzl/+8pfx8ccf57TvuOOO0bdv39h5551jq622itq1a8fSpUtj4cKFMXny5Pj000/j3XffjVWrVpX4+QEAwCZXySsaAAAAlMqcOXOKXV7/mGOOSd54441NOv+WuPXAD/cF33fffZPPP/+82P4vvfRSsu222+aMsfPOO5d4mfjbb789p3+bNm2Sp556qtjl9pMkSdasWZM88MADSYMGDbL61qpVKxk3btxG513/9frhfu5bbbVV8uijjyYFBQVF9i0oKMh6fnfccUfOcyjLnuDLly9PGjVqlDVOr169NtinLFsP/OxnP8vpc+aZZyZz5swpUZ0TJkxIbrjhhmTbbbfd6NYDBQUFRS5lX7du3eT2228v9hovX748+fWvf51Uq1Ytp+9ll11Wojor8hpXlEGDBuU8n+nTp5dqjPWXo//h86pbt27y17/+NVm9enWx/dffHmDatGlJkyZNcpaM//Wvf73R98QHH3yQ9OjRI+c5/fKXvyzRcxkyZEhO36ZNmyb33XffBrcxKCgoSIYMGZK0bNkyp/9zzz1XornLaocddsh5/f/0pz+V6P2Sn5+fvPnmm8n555+fbL/99hs9f/1rXbt27cKtO6pVq5ZceeWVxb5OK1asSK666qoiP0PXX399iZ7roEGDko4dOyY33nhjiZfUz8/PTx577LFk6623zpozk8kk7733XonGSJIkefrpp4v8t7lbt27Jf/7zn432nzdvXvLAAw8kXbt2LXILj/Udf/zxOXP16tUreeeddzbYb8GCBckvf/nLnC1VOnTokCxevLjYfjNnzszp06JFi+T555/faK1JkiRLly5Nhg4dmhx11FHJ6aefXqI+AACwKQkKAAAAVc6vf/3rIm9GrPvZdtttk4EDByb3339/8uGHHyZr1qypsLm3xKDAup8+ffqUaL/xqVOnJttss01O/z/84Q8b7fvJJ58kNWvWzOrXs2fPZOHChSV5ykmSJMmHH36Yc3P9iCOO2Gi/9V+vdT+tWrVKJkyYUOL5k+T7G1Lr71V+zDHHlGqMJEmSxx57LKeeBx54YIN9yhIUaN68edb5Bx10ULE3zDdkzZo1yapVqzZ4zj//+c+c+urUqZOMGDGiRHPcd999Of0zmUwyduzYjfatyGtcUTZFUGDdT/369ZPRo0eXuqZ99903a5x69eolr732Won7r1q1Kjn00EOzxqhZs2Yyc+bMDfb79ttvk8aNG2f169SpU/Lll1+WeO6ZM2cmbdq0yRpjl112KdP7uSQ+/fTTMt90X9+yZcs2ek5x1zoiknvvvbdE89x77705fWvWrJlMmTJlo30XL15c5tdyxowZSbt27bLmPe2000rUd86cOUnDhg1z6j7ppJPKFODJy8vb4ONF/Z256KKLSvXcH3744Zwx/t//+3/Fnn/XXXflnD9q1KgSz/dDJXkvAQDAplYtAAAAqpg//OEPse+++xb7+FdffRWDBg2K888/P7p16xYNGzaMffbZJ37xi1/EM888U6b9uLd0W221VTzzzDNRp06djZ7bsWPH+Oc//5nTfs899+QsY76+W265Jeuc1q1bx0svvRSNGzcuca2777573HPPPVltw4cPz9oKoDQefPDB2GWXXUrVZ6uttopjjjkmq+3ll18u9Xtj0KBBWcf16tWLU045pVRjbMySJUti3rx5WW3nnntuZDKZUo9Vo0aNYpfMX+f222/PafvTn/4UhxxySInmOP/88+OCCy7IakuSpMhxS6os17gq+H//7//FgQceWKo+r776arz99ttZbQ8//HAcfPDBJR6jVq1a8fTTT0fz5s0L29asWbPRa3THHXfEokWLCo/r1asXw4cPjzZt2pR47rZt2+ZsW/LZZ58Vu8VCef1w24p1zjvvvDKNVa9evTLXcfbZZ+d8LopzwQUXxNlnn53VtmbNmrj33ns32rdhw4Zl+tsQ8f22Gev/bX766aezrnlx/vKXv2Qt5x8RccABB8Tjjz9epm1H2rdvX+xj+fn5cfPNN2e1HXHEEXH33XeX6rkPHDgwzj333Ky2v/zlL8VuD7D+e6lTp07Ru3fvEs/3Q+V5LwEAQEURFAAAAKqcOnXqxEsvvZRzo7c4K1eujPfeey/uvPPOOOmkk6J169bRp0+fePjhh2PlypWbuNrN4/rrr4+tttqqxOf36dMnTjjhhKy22bNnx3PPPVdsn7y8vHjqqaey2m688cZo2rRp6YqNiNNPPz06deqU1TZs2LBSj3PQQQfF0UcfXep+ERHnnHNO1nF+fn6R+5gXZ+bMmfHf//43q+3EE0+Mhg0blqme4qx/8y0iSnWtS+Odd96J999/P6ttt912i4svvrhU49xyyy0574uyhnTKc423ZNtvv32pX9eIiFtvvTXr+IADDihTOKVx48bxP//zP1ltQ4cOLfb8pUuX5txEvuKKK6Jjx46lnnu//fbLCZ5saO7y2Jyfn+LUrVs357ptzK233hp169bNahs0aNAm3+P+yCOPzAqQ5Ofnx7vvvrvBPkuXLo277747q61WrVrxj3/8I6pXr17hNT7xxBMxY8aMwuNMJhN33nlnmcb63e9+lxUu+Pbbb3OCOOus/17a3O8jAACoaIICAABAldSkSZN47rnn4tFHH40ddtihVH2TJInRo0fHz372s9hpp52K/HZ9VVKnTp0466yzSt3v/PPPz2l7+eWXiz1/2LBhkZ+fX3hcv379OPXUU0s9b8T3N3aOPPLIrLbRo0eXepyf/exnZZo/IuLwww+PbbbZJqtt8ODBJe7/yCOPRJIkWW0DBw4scz3FadasWc63ZN98880Knyfi+2+rr+/nP/95VKtWuv980KRJkzjttNOy2tasWROjRo0qdU3lucZbsoEDB5b6m9/z58/PCaes/43o0jjqqKOyjmfMmJF1A/aHRowYEQsXLsxqK8+1WX/usnz+S6Kom7mb6vNTnOOOOy5atmxZqj4tW7aM448/Pqtt/vz58d5771VgZbmqVasW22+/fVbbO++8s8E+o0ePjsWLF2e1nXLKKRtcFaA8nnnmmazjPn36lPr/B6zTtm3b2G233bLainsvrv9e+uSTT0q02gIAAGypBAUAAIAqK5PJxFlnnRUTJ06MF154IU477bRo1KhRqcaYOXNmnHnmmTFw4MBN/k3NTaVPnz6lWvp/nb59++a8Xhu6IbT+zZNu3bqVa/nk7bbbLuv4gw8+KPUYBx10UJnnr169ek7AYsKECTF27NgS9X/kkUeyjjt27FjmZag3pE6dOtG1a9estttuuy2effbZCp/rrbfeymlbf+WJkjr55JNLNP7GlOcab8nK8rzeeOONnHBKr169ylzD+p/BiOI/h+t//rfddtty3Qhef+68vLycIEJF2GuvvXKCLuedd15MmDChwucqzvo3/Euqf//+OW0bu2lflE8//TQGDRoUl19+efTv3z/69u0b++yzT3Tr1q3In08//TSr/8yZMzc4flEBoLKE10oiSZJ44403strK8xmIKPm/Rfvss0/W8bJly+LUU0+N+fPnl2t+AACoLDUquwAAAIDyqlGjRhx99NFx9NFHx9q1a+PDDz+MN998M8aNGxfjx4+PSZMmxdq1azc4xuDBg2PZsmU5S+tXBT169ChTv2rVqsXuu++eddNl4sSJsXz58iIDAOvf5J0wYUJ069atTHNHRM7NlUWLFsWaNWuiZs2aJerfsmXLnBUBSuucc87JWRJ88ODBsddee22w3+uvvx5Tp07Najv77LPLvDf4xgwcODAuu+yywuOVK1fGiSeeGD179owBAwbE0UcfXap94oszfvz4rOM2bdrE1ltvXaaxevToEdWqVYuCgoJix9+YirjGW6JMJlOmz05xQY6KfN/NmzevRHMvWLCgXJ//pUuXFjl3kyZNyjxmUZo1axbHHnts1tYm06dPj9133z2OO+64OO200+Kwww4rdcisNMr6N3qPPfbIaVt/a5DirFq1Ku68884YNGhQfPbZZ2Waf52NBTjWX6q/WrVq0bNnz3LNWZyJEyfm/NvxyCOPxL///e8yj7l+EKK4z8Dhhx8erVu3jm+++aawbfjw4dGxY8c444wz4sQTT4z999+/xP+GAQBAZRMUAAAAflSqV68ePXr0yLoxs3z58nj33Xdj5MiR8fTTT8fnn39eZN+nn3467rzzzrj00ks3V7kVYqeddipz35133jkrKJAkScybNy/atWuXdd7q1atj7ty5WW0LFy6s8G8Az58/P1q1alWic0t63obsuOOO0atXrxgzZkxh2+OPPx6333571K5du9h+gwYNyjquVq1aDBgwoNz1FOeCCy6If/3rXznLjr/zzjvxzjvvxIUXXhg77LBD7L///rHnnnvG/vvvH127di3VDeQkSXJuwHXu3LnMNTdo0CDatm2btZR9cTfgilMR13hL1KBBgzKtxjFr1qycto8//rgiSir03XfflWju5cuXx0cffVThc5d1CfkNue222+L111/Pen+vXbs2hgwZEkOGDInq1atH9+7dY99994299torDjzwwApbNr9GjRo5S/mXVMeOHaNWrVqxevXqwrY5c+ZstN9bb70VAwYMyAkzldXGltf/9ttvs447dOgQDRs2rJC511fUZ2DWrFlFtpdVcZ+BunXrxl133RUnnnhi1soeixYtinvuuSfuueeeqFevXuy7776xzz77xD777BMHHHBANG3atMJqAwCAimTrAQAA4EevXr16cdBBB8Uf/vCHmDhxYgwfPjy6dOlS5Lk33nhjLF++fDNXWD5l2XZgQ32Luvlf3I2TirZixYoSn1tR3wAeOHBg1vGCBQviueeeK/b8ZcuW5eyRfcghh+SEKypS7dq148UXX4y+ffsWe86UKVNi8ODBcckll0S3bt2iefPmcdZZZ8VLL72U9a3+4ixevDhn5Y3yfrt7/RtkpV2ie1N+y7sylfV5bY7PYXGfwc2xvHppPv+lsf3228eIESOK3Goh4vvQwLhx4+LOO++Mn/70p9GhQ4fYbrvt4oorrij1Khjra9iwYblWfFj/vbKxcNbIkSPjsMMOq7CQQETEmjVrNvj4+u+NTXljvDI/AxHfbwfx2GOPRf369Yt8fPny5fHaa6/FzTffHMcdd1w0b9489txzz7j11lvjyy+/3FQlAwBAmQgKAAAAqXP44YfH2LFj48gjj8x5bM6cOfH8889XQlVlV9wNi7L2XbJkSU7bggULyjzHplKjRsUsknfKKafkfLt7/RUDfujpp5/OWTZ9/bDBptC8efN45ZVX4sknnyzRUubz58+Pxx57LI466qjYZZdd4tlnn93g+UVd9/K8t4rqX9QcG1JR13hLU9bnVVmfw+XLl8eqVasqZe6K0r179/j000/j1ltvjbZt2270/Ly8vLj99tujR48e0bdv3/jwww/LNO/m/AwtXLgwTjnllJywW7Vq1eKwww6LW265JYYPHx4TJkyIefPmxdKlS2Pt2rWRJEnWT+/evUtV4+LFi7OOGzRoUKr+pbEl/Ft0+umnx6RJk+Kiiy7aaOinoKAg3n///bjqqqti++23j3PPPTdndR4AAKgsggIAAEAq1a1bN5544olo3rx5zmOvvfZaJVRUdsuWLavQvkUtGV23bt2ctssuuyznBlN5fzp06FDm51JWDRs2jBNPPDGr7ZVXXomvvvqqyPPXDxE0adIk+vXrt8nq+6FMJhMnn3xyjBs3Lj777LO47bbb4phjjomtttpqg/0mTZoUJ554Ylx44YVZS2b/UFHXvTzvraL6b6rlyNNi/c9hkyZNKvwzeP311+fMW6dOnahWLfs/IR1//PEVPnefPn024av3/eoyv/nNb2LGjBkxevTouO666+LAAw8s8u/bD7322muxzz77xCOPPFLqOTfnZ+imm27KuQm95557xueffx7/+c9/4qqrrorDDz88dtlll9hqq62ifv36Odc1ovQrO6x/s3z9IFVFKupaDRs2rELfh3l5eRutY9ttt4277747Zs+eHUOGDIlLLrkkdt9996hevXqxfdasWRMPPfRQdO3atdwrVQAAQEUQFAAAAFKrUaNGcfbZZ+e0T5o0abPMv7HlnEtqY/tHl7ZvUcvNFxWomD59epnn3dKsvyJAQUFB/OMf/8g5b9q0afHGG29ktZ122mlRp06dTVpfUTp37hxXXHFFPP/88zFv3ryYPHlyPPTQQ3HWWWcVeb0iIv7+97/HzTffXORjjRo1yrnJtbFlzjdm/f7NmjUr13hpt/51XbhwYbmvUUlUq1Yt5+9CVf78ZzKZOPDAA+OPf/xjjB49OhYvXhxjx46N22+/PX7yk58UeTN69erV8bOf/Sxef/31Us21ZMmSYsM5JbH+t/U3tB3IE088kXXctm3bGDFiRHTq1KlUc5Z2m4n1g0qb8lv/W9q/RXXr1o1+/frFnXfeGR9++GEsXLgwXn311fj9738f++yzT5FBjNmzZ8dRRx212bb0AQCA4ggKAAAAqbb33nvntM2bN6/Y82vWrJnTVtYb/hV1k2Dy5Mll7rt+KCKTyRR5I6Zhw4Y5N88+/vjjMs+7pendu3d07Ngxq23w4ME55w0ePDjnpt/m2HagJDp16hTnnHNOPProozF79ux44YUXYq+99so57+abby7yPZ7JZHJu+E2cOLHM9SxbtixmzpyZ1VZcgIGSadWqVU7b5vocrj/35MmTq/x2BOvUqFEj9txzz7j88svjxRdfjDlz5sTf//732GabbbLOW7t2bfz6178u1dj5+fkxbdq0MtU1ffr0WL16dVZby5Ytizx34sSJMWvWrKy2X/ziF9G4ceNSzblmzZqccTZm6623zjrOy8sr9TYjJVWZn4GSaNCgQfTt2zeuv/76eOedd2LGjBlx9dVX54TJZs+eHX/6058qqUoAAPieoAAAAJBqRd1E2dD+4UXtR7z+Nz5LYs2aNTk3Ucvq/fffL1O/goKCnH23O3fuHPXq1Svy/PVDFdOnT99sqy9saplMJmd1iUmTJsXbb79deJwkSTz66KNZ53Tp0qXIm/GVrXr16nH00UfHmDFj4sgjj8x6bPny5TF8+PAi++2xxx5Zx7NmzYpvv/22TDW8//77UVBQkNXWo0ePMo3F94oKNr388suVMveKFSti1KhRm2Xuza1Bgwbx85//PMaPHx9t27bNeuy9996LL7/8slTjlfVvdFH9ivsMFVXTAQccUOo5P/jgg1i5cmWp+uy7775ZxwUFBVl/OytS165dc266F/f3bEvQpk2buPnmm+OVV17JWbHl2WefraSqAADge4ICAABAqhV1E7Sobyyu06BBg5z/2F+Wb4u+9957pd4HujgjR44s0/YDI0aMyAk59OzZs9jzDz300Jy2xx57rNTzbqkGDBiQs0z0oEGDCn//73//GzNmzMh6/JxzztkstZVVjRo14pZbbslpL+4buL169cppe+aZZ8o099NPP12i8Sm5oj6DTz75ZOTn51fK3D+mz39RWrVqFVdccUVO+yeffFKqcYYNG1am+YcMGZLTVtzf6KJWCSnLVh9PPvlkqfv06dMnp62orVsqQp06dWL//ffPavvmm2/itdde2yTzVZQDDjggjjnmmKy2qVOnxvLlyyupIgAAEBQAAABS7r///W9O2/bbb1/s+ZlMJnbcccestvfee6/U895///2l7lOclStXlumG3QMPPJDTtv63z3/o2GOPzWn729/+Vur9rLdU7dq1i0MOOSSr7cknnywMdKy/FUGNGjXizDPP3FzlldnOO++c01ZcsOTwww/Pabv//vtzVgbYmEWLFsW//vWvrLaaNWvGQQcdVKpxyLbtttvmfKN8+vTpRW6TUdEOP/zwnG9yP/744z+aVUWKU5rPT3GGDRsWc+fOLVWfuXPnxnPPPZfV1qxZsyJXlYiIqF+/fk7bhrbRKcrChQvj4YcfLlWfiO+3bmnatGlW21NPPZUTrKooxx13XE7b9ddfv0nmqkgV8V4CAICKJCgAAABUKS+88EJMnz69QsaaOnVqPPXUUzntRx999Ab7rX+jbty4cTF58uQSz/v+++/H448/XuLzS+L666+PBQsWlPj8N954I+eb4ltvvXWRN2DW2W233XLCAosXL46zzjqr1DeSt1QDBw7MOl68eHEMGTKk8H9/6Kijjip2v/AtyTfffJPT1qJFiyLP3XvvvWPPPffMavv444/j73//e6nmvPbaa3MCJCeffHKVeL22dNdee21O269+9atS/Q0qi+bNm8f555+f1bZ27do4/fTTK2x1lC1RaT4/xVmxYkVcddVVpepz1VVX5XzbfODAgVG7du0iz2/dunVO2yuvvFKqOS+55JJYuHBhqfpERNSrVy8uvfTSrLbVq1dvsn8bfvazn8XWW2+d1fbmm2/GrbfeWuFzVaT130uZTCaaN29eSdUAAICgAAAAUMW8+OKLseOOO8bAgQPj888/L/M4X3/9dfTr1y/nRkyLFi2ib9++G+xb1Lfuf/WrX5Vo3pkzZ8bJJ58ca9asKXmxJTBv3rw46aSTYtWqVRs9Ny8vL04//fSc9gsvvDBq1qy5wb5/+MMfcrZeeOmll2LgwIGl3td6nQkTJsRPf/rTUgUdNpV+/fpFkyZNstoGDRoUTz75ZM57ZXNtOzBmzJi44447YsmSJWXqf8cdd+S07b777sWe/8tf/jKn7Ve/+lWMHj26RPM9/PDDcc8992S1ZTKZuPzyy0vUnw3r169fTphj0aJFceSRR8aECRPKNOaSJUviz3/+80ZXJrn66qtzvrk+fvz46NevX5k/vzNmzIhLL700Pv300zL135jBgwfHs88+G2vXri113zVr1uS8l6tVqxa77rprqcd6+OGHi1zFpSgPPPBAzjf7a9asGRdeeGGxfbp37x4NGjTIarvjjjti1qxZJZrzj3/8Y/zzn/8s0blF+Z//+Z+cv51vvPFGnHbaaSX6d2l9G1qNoG7dukUGZq655pq46667Sj3XOsOHD4+LLrqo2Mevv/76ePfdd8s09pdffhlDhw7NauvcufNG/80FAIBNSVAAAACocvLz82Pw4MHRuXPn6NmzZ9x1111FfuuzKMuXL4+///3v0b179yL3mf7zn/+cs7z2+vr375+z9/MLL7wQ55133gb3Gx4yZEj07Nkzpk2bFhGx0XlKat04r732WhxyyCEb/Gbxf/7znzjwwANzbh7tvPPO8Zvf/Gajc+2+++7xpz/9Kaf90UcfjZ49e8YLL7wQSZJsdJwFCxbEww8/HIcddljstttu8Y9//KNMN/IqWp06deK0007Lahs5cmT87//+b1Zby5Yt4yc/+clmqWnOnDlx2WWXRZs2beKCCy6IV155pURBk6VLl8aVV14Zf/3rX7PaGzduvMFVM0477bSc57ZixYo46qij4q677ir2G8IrV66Mq6++Os4777yc98Bll12WsxIHZff444/n/A2aNm1a7LPPPnHTTTeVaDnzgoKCGDlyZFxwwQXRrl27+M1vfhOzZ8/eYJ+tt946HnnkkchkMlnt//nPf6JHjx7x2GOPRX5+/kbnXrZsWTz55JPRv3//2GGHHeKuu+4qc9BoYz788MM48cQTY4cddojrrrsuxo8fX6J+M2bMiGOPPTbGjh2b1d63b9+cb7NvSO3atQtfrwsuuCCuvfbaYm+cr1q1Kq699tq44IILch679tprN7gtTs2aNeP444/PaluwYEEccsgh8fHHHxfb7+uvv47TTz89fve73xW2NWrUaENPqUjNmjUr8r3x1FNPxb777hsjRozY6Bjr/l3Yfffd4/e///0Gz7344otzVsApKCiISy+9NPr16xcfffRRieqePn163HrrrdG1a9c48sgj4/XXXy/23GHDhkXPnj2jZ8+ecccdd8TMmTNLNMeYMWPi4IMPjsWLF2e1V4WtawAA+HHLJCX5LzgAAABbiAsuuCDuu+++Ih/r0KFD7LPPPrHLLrtE8+bNY6uttopMJhOLFy+OGTNmxMcffxyvvfZaLFu2rMj+J598cjz55JMlquOOO+6Iyy67LKe9devWceKJJ0a3bt2iYcOGsWDBgvj888/jpZdeytrL+9RTT41vvvkm61vavXv3jlGjRm1w3lGjRuXs837LLbfEddddV3ijvUaNGtG3b9845JBDYtttt43Vq1dHXl5evPDCC/H+++/njFmrVq0YPXp09OzZs0TPPSLi3HPPjYceeqjIx9q1axcHHXRQdOvWLbbaaquoU6dOLFq0qPC1eP/992PChAk5NxTnzp27wWWY+/TpU+rXqyzGjh1b7D7g61xxxRVx2223lWn8oq7hyJEjo0+fPkWeP2zYsOjXr19WW8OGDWOPPfaI7t27x3bbbRdNmjSJ+vXrx8qVK2PWrFkxfvz4+M9//lPkDeMHHnggzj333A3WOGfOnOjWrVuRAZx27dpF//79o3PnztGkSZOYN29efPjhhzF06NAi90TfY489YsyYMcUumf5Dm+sal8bgwYNztqSYPn16dOjQocRjnH322fHII48UHrdv3z7y8vLKVddrr70WP/nJT2L16tU5j9WvXz/233//2G+//aJ169bRpEmTWL58eSxcuDC+/PLLGD9+fIwfPz5nmfk///nPJVod5cYbb4zf/va3RT7WqlWr6NOnT+y5557RokWLqF+/fixevDgWLlwYU6ZMiXHjxsXHH3+cc7N87NixOSslVITLLrssZ1WN1q1bxx577BHdunWLbbbZJpo0aRK1atWKpUuXRl5eXowZMyZGjRqVE8ipXbt2jBs3boMrChR1rY866qislQlatGgRJ5xwQnTt2jW22mqr+O677+Ljjz+OIUOGxJw5c3LG7NGjR7z99tsb/fb55MmTY9ddd82pu1q1anHEEUfEwQcfHG3atIn8/Pz45ptvYtSoUTFixIisa3HOOefE1KlTy/w5/O1vfxs33nhjkY916tQpDjvssNhpp52iRYsWkSRJLFy4MCZPnhzjx4+Pt99+u7D2AQMGxODBgzc419KlS2P//fcvNhSw++67R58+faJTp06x1VZbRUTEwoULY968efHxxx/H+++/XxjcW6dLly7Frm7RrVu3nLl22mmn6NatW+y2227RokWLwlUV1j2vkSNHFhlO6dSpU3z44YdRr169DT5HAADYpBIAAIAq5Oc//3kSERX+M2DAgCQ/P7/Edaxduzbp27dvmeY68MADk+XLlye9e/fOau/du/dG5x05cmTOeCNHjkzuvvvuMtVSq1at5IUXXij1dSgoKEhuvPHGpFq1ahV2DebOnbvBOcvyepXVrrvuusFaP/300zKPXdw1LM7QoUMr7DW+/PLLS1zn1KlTk06dOpVrvv333z+ZP39+iefcnNe4pAYNGpTzvKZPn16qMQYMGJDVv3379hVS27vvvpu0bdu2wt4ff/7zn0s890MPPZTUqVOnwuYeO3Zshbwm6/uf//mfCqmvdu3ayVNPPbXR+Yq61itXrkwOOOCAMs3btWvXZN68eSV+vvfdd1+Zn+PBBx+crFy5styfw9tvvz2pXr16uV7vAQMGlGiuxYsXJyeccEKFvQ+7dOlS7Fy77757hczRpk2bcv0bAgAAFcXWAwAAQJVy1llnxRlnnJGzF3JZdezYMZ577rkYPHhwVK9evcT9qlWrFs8///wGl3AvyhlnnBH/+c9/om7duqUtdYMuuuiieOCBB0q1nUHbtm3jxRdfLPVziPh+z/lrr702RowYUe5vATdq1CjOPffcnP21K9P63yD/ob333ju6dOmy2Wpp3LhxubepaN68eTz00ENx++23l7hPx44d46233oqTTz45ZznxjalZs2Zceuml8eqrr0bTpk1LWy4ltPfee8f48eNj4MCB5drrPJPJRJ8+feKAAw4ocZ9zzjkn3n777Tj44IPLPG/E99t9nHrqqdGuXbtyjVOcli1blvr9u75dd901/vvf/8ZJJ51Upv61a9eOl19+OWep/I059thj47XXXiv8NnxJnH/++XHPPfdErVq1SjXXOeecEy+99FKJVv7YmMsvvzyGDx8eu+22W5nHaNmyZYnOa9iwYTzzzDNx7733xrbbblvm+SK+Xy1lQ3/7S7PlRHGOOeaYeOeddzbrvyEAAFAcQQEAAKBK2W+//eKxxx6LOXPmxGuvvRa/+93v4uCDDy7VTeZWrVrFGWecES+++GJMmjQpjj322DLVUrdu3XjhhRfiySefjK5duxZ7XiaTif333z9eeumleOyxx8p907c45557bnz88cdx1llnbTCI0LZt27jmmmvis88+i759+5ZrzoMOOijGjh0bw4cPj5NOOilatGhRon7bbbddnHvuufH000/H7NmzSx1y2NTOPPPMYm+8buhG0qZw0EEHxXfffRfPPfdcXHTRRdGtW7cSh1p69OgRt912W0yZMiXOOeecUs/dokWLePLJJ+O9996LU045ZaM3/Vu3bh3nnXdeTJw4Mf72t79tUdf0x6p58+bx8MMPx5QpU+JXv/pVdOnSpUQ3xhs2bBhHHXVU/OUvf4np06fHyJEjY5999inV3N26dYvXXnst3nnnnfjpT38abdq0KVG/1q1bx5lnnhmPPPJIzJ49Ox5//PES3xgurWuuuSZmz54dDz/8cJxxxhmx3XbblahfzZo148gjj4x//vOf8eGHH0avXr3KVUf9+vVj2LBh8fTTT8dee+1V7Hnr/r149tln47nnntvgdizFufDCC2P8+PFxyimnbDBAUqtWrTjmmGPi9ddfj4ceeqhCQgLr9O3bNz766KN44okn4ogjjijREvudOnWKX/ziFzF+/Pj405/+VKr5Lrjggpg2bVo88MAD0bdv3xLNV61atejevXv8+te/jpEjR0ZeXl5cccUVxZ4/fPjwmDhxYtx2221x9NFHl/jaNG7cOAYMGBCjR4+O559/vtyBBgAAqCiZJEmSyi4CAACgvJIkia+++iq++OKLmDlzZixevDiWLFkSmUwmGjVqFA0bNozWrVvHbrvtViHfCizKl19+GW+//XbMmTMnFi5cGPXq1YvtttsuevbsGa1bt66QOUq6v/2KFSvi3Xffjc8//zzmz58ftWvXjtatW0enTp1izz33LPc3bIuTJEl89tlnMXny5Pjuu+/iu+++i4KCgmjYsGE0adIktt9++9h55519y7ycli1bFl988UVMmzYtZs+eHUuWLIk1a9ZEgwYNonHjxrHDDjtE165do3HjxhU679q1a2PcuHGRl5cXc+fOjcWLF0eTJk2iZcuWseOOO24wMMPmM3fu3Hj//fdj7ty58d1338XSpUujfv360bBhw2jTpk3svPPO0b59+03yd2DKlCnx2WefFX7+V69eXfi+3G677WLnnXfeZKGAkvruu+8KPz/z5s2LpUuXRsT34YlmzZpF586do0uXLmW6cX722WfHI488Unjcvn37yMvLyzlv1qxZMXbs2MjLy4tly5ZFs2bNonXr1rH33ntX6I3kZcuWxZgxY2LatGkxf/78yGQy0axZs+jUqVPstddem20ll1WrVsXYsWNj1qxZMXfu3Fi0aFHUrVs3GjduHB07doxddtmlQv9tXr16dbz//vsxa9asmDdvXixYsCBq1KgRDRs2jObNm8eOO+4YO+64Y7lX95k5c2ZMnTo18vLyYuHChbFs2bKoWbNmNGrUKFq2bBm77bZb7LDDDlGtmu9qAQCw5REUAAAAqEJKGhQAYPMraVAAAACgsomzAgAAAAAAAECKCAoAAAAAAAAAQIoICgAAAAAAAABAiggKAAAAAAAAAECKCAoAAAAAAAAAQIoICgAAAAAAAABAiggKAAAAAAAAAECKCAoAAAAAAAAAQIpkkiRJKrsIAAAAAAAAAGDzsKIAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApEiNyi4AirNw4cIYPXp04XHbtm2jdu3alVgRAAAAAAAAQMVYtWpVfPnll4XHvXv3jiZNmmyWuQUF2GKNHj06jj/++MouAwAAAAAAAGCTGzZsWBx33HGbZS5bDwAAAAAAAABAiggKAAAAAAAAAECK2HqALVbbtm2zjocNGxY77LBDJVUDAAAAAAAAUHGmTJmStRX7+vdHNyVBAbZYtWvXzjreYYcdokuXLpVUDQAAAAAAAMCms/790U3J1gMAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCI1KrsAYPPKXPLPyi4BgIhI7jqjsksAAAAAACClrCgAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApUqOyC0irtWvXxpQpU+Kzzz6Lr7/+OhYtWhS1a9eOpk2bxvbbbx977rln1K9fv0LnXLNmTbz11lsxc+bM+Oabb6JBgwaxzTbbRPfu3aNDhw4VOhcAAAAAAAAAWyZBgc1o5syZMWTIkBgxYkS88cYbsXjx4mLPrV69ehx66KFxySWXxFFHHVWueefOnRu///3v48knn4z58+cXeU6vXr3il7/8ZZxwwgnlmgsAAAAAAACALZugwGZy+umnx+OPP17i89euXRvDhw+P4cOHx9FHHx0PPvhgtGrVqtTzvvzyy3H22WfHnDlzNnjemDFjYsyYMXHGGWfEfffdV+GrGQAAAAAAAACwZRAU2EwmT55cZPu2224bnTp1ilatWkV+fn5MmzYtPvrooygoKCg859///ncceOCBMXr06Nh6661LPOeoUaPi+OOPj9WrVxe2ZTKZ2GOPPaJjx46xcOHC+OCDD2LevHmFj//zn/+MxYsXx7Bhw6JatWpleKYAAAAAAAAAbMncCa4E3bt3jzvvvDOmTJkSs2bNipEjR8YTTzwRzzzzTIwfPz5mzpwZ559/flafyZMnx0knnRRJkpRojlmzZkX//v2zQgL77bdfTJgwIcaNGxdPPfVUvPLKKzFr1qy44447ombNmoXnvfDCC3HddddVzJMFAAAAAAAAYIsiKLCZZDKZOOqoo2Ls2LExfvz4uOSSS2L77bcv8txtt9027rvvvrj77ruz2t9888148sknSzTf73//+1iwYEHhca9evWLEiBHRuXPnrPNq164dv/jFL+Kpp57Kar/99ttjxowZJZoLAAAAAAAAgKpDUGAzefrpp+Pf//537LnnniXuc9FFF8UJJ5yQ1faPf/xjo/2++OKLeOSRRwqPa9WqFYMHD446deoU2+f444+PAQMGFB6vWrUqbrjhhhLXCgAAAAAAAEDVICiwmXTo0KFM/S6++OKs45EjR260z7/+9a9Yu3Zt4XH//v2jU6dOG+135ZVXZh0/9dRTsXLlyhJWCgAAAAAAAEBVICiwhevevXvW8YoVK2LhwoUb7DN06NCs44EDB5Zors6dO8c+++xTeLxs2bJ45ZVXSlYoAAAAAAAAAFWCoMAWrkaNGjltq1evLvb82bNnx0cffZTVf7/99ivxfH369Mk6fvnll0vcFwAAAAAAAIAtn6DAFm7KlClZxzVq1IjmzZsXe/6nn36addy1a9eoX79+iefr1atX1vGECRNK3BcAAAAAAACALZ+gwBbumWeeyTrec889o1q14i/bZ599lnW8ww47lGq+7bfffoPjAQAAAAAAAFC1CQpswZYuXRoPPfRQVlu/fv022Gf9FQjatWtXqjnbt2+fdfzdd9/FggULSjUGAAAAAAAAAFuuGpVdAMW7+uqrY/bs2YXHTZo0iXPPPXeDfRYuXJh13LJly1LN2aBBg6hTp06sXLmysG3RokXRtGnTUo2zvjlz5sTcuXNL1Wf90AMAAAAAAAAA5ScosIUaOnRo3HXXXVltN910UzRr1myD/ZYuXZp1XLdu3VLPXbdu3aygwJIlS0o9xvruueeeuOGGG8o9DgAAAAAAAADlY+uBLdBHH30UP/3pT7PaDjvssLjwwgs32nf9oECdOnVKPf/64YL1xwQAAAAAAACg6hIU2MLMnDkzjjrqqKyb8+3bt4/HHnssMplMqcfbXH0AAAAAAAAAqBpsPbAFmTNnThx66KHx1VdfFbZtvfXW8eqrr0aLFi1KNEaDBg2yjlesWFHqOtbvs/6YZXHRRRfFSSedVKo+U6ZMieOPP77ccwMAAAAAAADwfwQFthDz58+Pvn37xuTJkwvbmjdvHiNGjIhOnTqVeJwtNSjQsmXLaNmyZbnHAQAAAAAAAKB8bD2wBVi0aFEcdthh8cknnxS2NW3aNF599dXo0qVLqcZq3Lhx1vHcuXNL1X/p0qU5QYEmTZqUagwAAAAAAAAAtlyCApVsyZIlccQRR8T7779f2NaoUaMYPnx4dOvWrdTjrb/6wIwZM0rVf/3zmzVrFk2bNi11HQAAAAAAAABsmQQFKtGyZcviJz/5SbzzzjuFbQ0aNIiXX3459t577zKN2blz56zjKVOmlKr/tGnTso532WWXMtUBAAAAAAAAwJZJUKCSrFixIo4++uh48803C9vq1asXL774YvTq1avM4+66665Zxx9//HEsX768xP3feuutDY4HAAAAAAAAQNUmKFAJVq5cGccee2yMGjWqsK1OnTrx/PPPx4EHHliusVu3bh1du3YtPM7Pz88KI2zMD2uKiDjyyCPLVQ8AAAAAAAAAWxZBgc1s9erV0b9//xgxYkRhW+3atWPYsGFxyCGHVMgc/fr1yzoeNGhQifp9/vnn8e677xYe169fPw477LAKqQkAAAAAAACALYOgwGaUn58fJ598crz88suFbTVr1oxnnnkmDj/88Aqb54wzzojq1asXHg8ZMiS++OKLjfa79dZbs45PPvnkqFOnToXVBQAAAAAAAEDlExTYTNauXRtnnHFGPPfcc4VtNWrUiCeffDKOPvroCp2rU6dOMWDAgMLj1atXx9lnnx0rV64sts9zzz0XgwcPLjyuVatW/P73v6/QugAAAAAAAACofDUqu4C0OOecc+Kpp57Karv55puje/fukZeXV6qxtt56641+0/+GG26IoUOHxoIFCyIiYsyYMdG3b9948MEHY+eddy48b9WqVXH//ffHFVdckdX/iiuuiPbt25eqLgAAAAAAAAC2fJkkSZLKLiINMplMhY01cuTI6NOnz0bPGzVqVBx++OGxevXqrDp69OgRHTt2jEWLFsX48eNj7ty5Wf2OPvroGDZsWNb2BZVhwoQJseuuuxYef/rpp9GlS5dKrOjHIXPJPyu7BAAiIrnrjMouAQAAAACASlSZ90OtKPAj1qdPnxg6dGicffbZhWGAJEli3LhxMW7cuCL7nHbaafHAAw9UekgAAAAAAAAAgE2jWmUXwKb1k5/8JD799NO44IILomnTpsWe17Nnz3jmmWfiX//6V9SvX38zVggAAAAAAADA5mRFgc2kMnd4aNmyZdx7771xxx13xFtvvRUzZsyI2bNnR/369WPbbbeN7t27x3bbbVdp9QEAAAAAAACw+QgKpEitWrXioIMOquwyAAAAAAAAAKhEth4AAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBSpUdkFpNW0adNi7NixMW7cuBg7dmyMHz8+lixZUvh4+/btIy8vr0xjZzKZctU2ffr06NChQ7nGAAAAAAAAAGDLJCiwGY0aNSpuueWWGDduXMyfP7+yywEAAAAAAAAghQQFNqMPP/wwXnnllcouAwAAAAAAAIAUExTYAtSuXTvatGkTU6dOrfCx99lnn3jiiSdK1adNmzYVXgcAAAAAAAAAWwZBgc2sZs2a0aVLl9hzzz1jr732ij333DN22223eOutt+Kggw6q8Pnq1KkTHTp0qPBxAQAAAAAAAKiaBAU2owEDBsQFF1wQderUqexSAAAAAAAAAEgpQYHNqGnTppVdAgAAAAAAAAApV62yCwAAAAAAAAAANh9BAQAAAAAAAABIEUEBAAAAAAAAAEiRGpVdAJvWzJkzY+DAgfHee+/F119/HcuWLYumTZtG8+bNo3v37nHggQfGiSeeGM2aNavsUgEAAAAAAADYDAQFfuSmT58e06dPz2qbM2dOzJkzJz777LP45z//Gb/85S/jvPPOiz/+8Y/RoEGDTVLHnDlzYu7cuaXqM2XKlE1SCwAAAAAAAECaCQoQy5Yti7/+9a/x0ksvxZAhQ6JLly4VPsc999wTN9xwQ4WPCwAAAAAAAEDpCAr8SNWoUSP233//6Nu3b3Tt2jXatGkTDRs2jKVLl8bMmTPjjTfeiEcffTTmzJlT2Gfy5MnRt2/feOedd6J9+/aVWD0AAAAAAAAAm4qgwI/QjTfeGOedd160bNmyyMe7desWxx57bPzxj3+MG264IW699dZIkiQiImbPnh39+/ePcePGRSaT2ZxlAwAAAAAAALAZCAr8CF177bUlOq9OnTpxyy23RJs2beKSSy4pbB8/fnw8/vjjcfrpp1dYTRdddFGcdNJJpeozZcqUOP744yusBgAAAAAAAAAEBYiIiy++OF555ZV4/vnnC9vuueeeCg0KtGzZstgVDgAAAAAAAADYfKpVdgFsGa6++uqs43feeScWLlxYOcUAAAAAAAAAsMkIChAREXvvvXc0bdq08Hjt2rXx2WefVWJFAAAAAAAAAGwKggJERES1atWiXbt2WW1z586tpGoAAAAAAAAA2FQEBShUt27drOMVK1ZUUiUAAAAAAAAAbCqCAhSaN29e1nHz5s0rqRIAAAAAAAAANhVBASLi+5DAtGnTstq22WabSqoGAAAAAAAAgE1FUICIiHjiiSeioKCg8LhVq1bRuXPnSqwIAAAAAAAAgE1BUID49ttv48Ybb8xqO+aYYyKTyVRSRQAAAAAAAABsKoICPyKTJk2KF154oVR9Zs+eHUcffXR8++23hW21atWKq6++uqLLAwAAAAAAAGALUKOyCyipU045JS666KLo3bt3ZZdSLrNmzYr8/Pyc9tmzZ2cd5+fnR15eXpFjNGjQIJo3b57T/s0338Sxxx4bu+22W5x55pnRr1+/6NSpU5FjLFmyJB555JG48cYbs0ICERHXXXdddOzYsYTPCAAAAAAAAICqpMoEBZ5++ul45plnYscdd4wLL7wwfvrTn0aTJk0qu6xS23///WPGjBkbPe+rr76K7bbbrsjHBgwYEIMHDy627yeffBJXXnllXHnlldG4cePYddddo3nz5tGwYcNYunRpfPnll/HRRx8VGVg4//zz47e//W2Jnw8AAAAAAAAAVUuVCQqsM2nSpLj88svj6quvjlNPPTV+/vOfx957713ZZW2xFi1aFG+99dZGz6tfv3785S9/ifPOO28zVAUAAAAAAABAZalW2QWUViaTiSRJYsWKFTF48ODYd999o0ePHvHggw/G8uXLK7u8StW5c+e45pprYr/99ou6deuWqM+OO+4YN998c+Tl5QkJAAAAAAAAAKRAlVlR4Pnnn4+///3vMXz48EiSJDKZTEREJEkSH3zwQfz85z+PX/3qV3HWWWfFz3/+89h1110rueKi5eXlbbKxW7VqFTfddFNERBQUFMQXX3wRU6dOja+++ioWLlwYK1eujLp160bTpk2jdevWsddee0WLFi02WT0AAAAAAAAAbHmqTFDg6KOPjqOPPjq+/PLLuO+++2LQoEHxzTffRMT/rTKwePHiuOeee+Kee+6JXr16xUUXXRQnnnhi1KxZs5Kr3/yqVasWO+20U+y0006VXQoAAAAAAAAAW5Aqt/VA27Zt48Ybb4yZM2fGU089FYccckjhYz9cZWDMmDFx5plnxrbbbhtXXXVVTJs2rbJKBgAAAAAAAIAtRpULCqxTvXr1OPHEE+PVV1+NyZMnxy9/+cto1qxZJElSeE6SJDFv3rz485//HDvuuGMcccQR8dxzz0VBQUElVg4AAAAAAAAAlafKBgV+aPvtt4/bbrstvvrqq3j00Udjv/32KwwMrFtloKCgIF599dXo379/tG/fPv7whz/E119/XZllAwAAAAAAAMBm96MICqxTq1atOPPMM+ONN96ITz/9NC666KJo1KhRYWggSZJIkiS++uqruOGGG6JDhw5xwgknxIgRIyq5cgAAAAAAAADYPH5UQYEf2mWXXeKuu+6Kr7/+Ou6///7o0aNHRHy/wkAmk4kkSSI/Pz+GDRsWhx9+eOy4447xt7/9LZYsWVLJlQMAAAAAAADApvOjDQqsU7du3RgwYEBcfvnl0b59+6wtCdZtS5AkSUyZMiUuv/zy6NChQ9x6662xZs2ayiwbAAAAAAAAADaJH3VQYOrUqXHllVdGmzZt4qyzzoqZM2dmhQPW/URE4SoDCxYsiGuuuSb23HPPyMvLq8TqAQAAAAAAAKDi/eiCAmvXro0hQ4bEYYcdFjvttFPcdtttMXfu3MJAwLpwQJ8+feLpp5+OV155JU488cSoUaNGRPxfYOCTTz6Jgw46yFYEAAAAAAAAAPyo1KjsAirKl19+Gffff388/PDDMXv27Ij4PhSwbouBJEmiQYMGcdZZZ8XFF18cnTt3Luzbt2/f+Pbbb+P222+Pu+66K1auXBlJksTMmTPjjjvuiOuuu66ynhYAAAAAAAAAVKgqvaJAkiTx73//O4455pjo2LFj3HzzzfHNN98Urh6w7pxddtkl7r777vjqq6/irrvuygoJrNOqVau49dZbY/z48dGqVavCcMGwYcM24zMCAAAAAAAAgE2rSq4oMHv27HjwwQfjwQcfjC+//DIiclcPqF69evTr1y8uuuii6N27d4nH3mmnneK6666LSy65JCIiJk+evEmeAwAAAAAAAABUhioVFHj11Vfj73//e/z73/+O/Pz8wpUDMplMRHwfFmjdunWcf/75cf7550fr1q3LNM++++5b+PuyZcvKXzgAAAAAAAAAbCGqTFCgU6dOMW3atIjIXT0gSZLo3bt3XHTRRdGvX7+oUaN8T6tZs2YR8X8BBAAAAAAAAAD4sagyQYGpU6cW3rhfFxBo0KBBnHXWWXHxxRfHLrvsUuFzrgskAAAAAAAAAMCPRZUJCqyTJEnssssuceGFF8aAAQOiQYMGFT7H1ltvHSNHjqzwcQEAAAAAAACgslWZoECNGjXiuOOOi4svvjj69OmzSeeqXbt29O7de5POAQAAAAAAAACVocoEBfLy8mKbbbap7DIAAAAAAAAAoEqrVtkFlJSQAAAAAAAAAACUX5UJCgAAAAAAAAAA5ScoAAAAAAAAAAApUmWCAmPGjImOHTtGx44do1OnTjFnzpxSj/Htt9/GjjvuGB07doztt98+xo8fvwkqBQAAAAAAAIAtV5UJCjz44IORl5cXM2bMiO7du0fLli1LPUarVq1i9913j7y8vMjLy4sHH3xwE1QKAAAAAAAAAFuuKhMUePHFFwt/P/PMM8s8zllnnVX4+/PPP1+umgAAAAAAAACgqqkSQYGJEyfG3LlzIyKiZs2accQRR5R5rMMPPzxq1qwZSZLEN998E1988UVFlQkAAAAAAAAAW7wqERT47LPPIiIik8lEly5dolatWmUeq3bt2tGlS5fC4wkTJpS7PgAAAAAAAACoKqpEUOCrr74q/L1du3blHq99+/aFv8+aNavc4wEAAAAAAABAVVElggJLly4t/L1hw4blHq9BgwZFjg0AAAAAAAAAP3ZVIijwwxv7CxYsKPd4ixYtKvy9Zs2a5R4PAAAAAAAAAKqKKhEUaN68eeHvU6dOLfd4Pxzjh2MDAAAAAAAAwI9dlQgKdOzYMSIikiSJSZMmxaxZs8o81qxZs2LixImFx+3bty93fQAAAAAAAABQVVSJoMCee+4Z9evXj0wmExER//u//1vmsW6//fbC3+vUqRP77rtvuesDAAAAAAAAgKqiSgQFatSoEYceemgkSRJJksS9994bo0aNKvU4o0aNirvvvjsymUxkMpk45JBDonbt2hVfMAAAAAAAAABsoapEUCAi4qqrroqIiEwmE6tXr47jjz8+nn766RL3HzJkSPTr1y/y8/MjSZKsMQEAAAAAAAAgLapMUGDvvfeOk046KZIkiUwmE4sXL45TTz01DjnkkHjqqadizpw5OX3mzp0bTz/9dPTt2zdOOumkWLRoUUR8Hzbo169f9OrVa3M/DQAAAAAAAACoVDUqu4DSeOihh+LTTz+NiRMnRiaTiSRJYtSoUYXbEDRr1iyaNm0amUwm5s+fH/Pnzy/suy5gkCRJ7LrrrvHII49U0rMAAAAAAAAAgMpTZVYUiIho0KBBvPrqq7H33nsX3viP+D4EkCRJfPfddzFlypT44osv4rvvvitsj4jCkMC+++4br7zyStSvX78ynwoAAAAAAAAAVIoqFRSIiNhmm23i9ddfj6uuuioaNGiQFQQo6ifi+yBBo0aN4ne/+12MHj06tt5668p8CgAAAAAAAABQaarU1gPr1KpVK26++eb4zW9+E//4xz/itddeizFjxsS8efOyzmvRokXst99+0bdv3zjzzDOjUaNGlVQxAAAAAAAAAGwZqmRQYJ0mTZrEpZdeGpdeemlERKxduza+++67iIjYaqutonr16pVZHgAAAAAAAABscap0UGB91atXj5YtW1Z2GQAAAAAAAACwxapW2QUAAAAAAAAAAJuPoAAAAAAAAAAApIigAAAAAAAAAACkSI3KLqAiLF++PBYtWhRr1qwpdd927dptgooAAAAAAAAAYMtUJYMCM2fOjIceeij++9//xocffhjLly8v0ziZTCby8/MruDoAAAAAAAAA2HJVqaBAfn5+/Pa3v43//d//jbVr10ZERJIklVwVAAAAAAAAAFQdVSYokCRJnHLKKTFs2LDCcEAmk4lMJiMsAAAAAAAAAAAlVGWCAnfffXcMHTo0KxyQJEl06NAhOnfuHE2bNo2aNWtWdpkAAAAAAAAAsEWrEkGBJEnipptuylo94Ljjjoubbropdtlll0quDgAAAAAAAACqjioRFBg3blx8++23hasJnH322fHQQw9VdlkAAAAAAAAAUOVUq+wCSuKTTz6JiO9XFqhTp07cfvvtlVwRAAAAAAAAAFRNVSIoMG/evIiIyGQy0bNnz2jcuHElVwQAAAAAAAAAVVOVCArUrVu38PfWrVtXYiUAAAAAAAAAULVViaBAmzZtCn9ftmxZJVYCAAAAAAAAAFVblQgK7LXXXlGt2velTpo0qZKrAQAAAAAAAICqq0oEBdq0aRMHHXRQJEkSkyZNismTJ1d2SQAAAAAAAABQJVWJoEBExA033BDVq1ePiIhrrrmmkqsBAAAAAAAAgKqpygQFevXqFTfccEMkSRJDhw4VFgAAAAAAAACAMqgyQYGI71cS+POf/xyZTCZuvfXW6NOnT7z66quRn59f2aUBAAAAAAAAQJVQo7ILKKmDDz648PcmTZrE/Pnz44033ogjjjgi6tatG9tvv300bdo0qlUrefYhk8nEa6+9tinKBQAAAAAAAIAtUpUJCowaNSoymUzhcSaTiSRJIiJi+fLl8cknn2Q9vjFJkpTqfAAAAAAAAAD4MagyQYGiuNEPAAAAAAAAAKVTpYIC61YQAAAAAAAAAADKpsoEBQoKCiq7BAAAAAAAAACo8qpVdgEAAAAAAAAAwOYjKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKVKjsgsojw8//DCef/75eOONN2Lq1Kkxf/78WLJkSWQymcjPz885f+HChbF48eKIiKhdu3a0atVqc5cMAAAAAAAAAJWqSgYFPvnkk7j88stj5MiRhW1Jkmy038iRI+PEE0+MiIj69evH7Nmzo169epusTgAAAAAAAADY0lS5rQcGDx4cPXv2jJEjR+aEAzKZzAb7HnfccdGuXbtIkiSWLVsWzz777KYsFQAAAAAAAAC2OFUqKPDss8/Gz372s1ixYkVhW5Ik0bZt2+jWrdtGVxWoVq1anHLKKYXHzz///CarFQAAAAAAAAC2RFUmKPDNN9/EgAEDIuL/Vg646KKLYurUqZGXlxdDhgwp0TjHHXdcRHwfMBg9evSmKRYAAAAAAAAAtlA1KruAkvrDH/4Qy5cvj4iI6tWrxxNPPBEnnHBC4eMb23Zgnb322itq1qwZa9asie+++y6mT58e22233SapGQAAAAAAAAC2NFViRYG1a9fG448/HplMJjKZTFx55ZVZIYHSqFGjRuy8886Fx59//nlFlQkAAAAAAAAAW7wqERR45513YvHixZEkSdSsWTN+85vflGu8Nm3aFP7+5Zdflrc8AAAAAAAAAKgyqkRQYMqUKRHx/fYCe+21VzRq1Khc4/2w/+LFi8s1FgAAAAAAAABUJVUiKDB37tzC39u2bVvu8apV+7+nnZ+fX+7xAAAAAAAAAKCqqBJBgUwmU/j72rVryz3e/PnzC39v0qRJuccDAAAAAAAAgKqiSgQFWrRoUfj7119/Xe7xPv3008Lft9pqq3KPBwAAAAAAAABVRZUICrRr1y4iIpIkiQ8++CDWrFlT5rEmT54cX331VeFx165dy10fAAAAAAAAAFQVVSIosO+++0bdunUjk8nEihUr4vHHHy/zWH/7298Kf2/VqlXstNNOFVEiAAAAAAAAAFQJVSIoULt27TjkkEMiSZJIkiSuvfbaWLhwYanHeeutt+K+++6LTCYTmUwm+vfvX/HFAgAAAAAAAMAWrEoEBSIirr322oiIyGQy8dVXX8Vhhx0Wc+bMKXH/kSNHxrHHHhsFBQWRJElUr149fvWrX22qcgEAAAAAAABgi1RlggL77LNPnHrqqZEkSWQymRg37v+zd99hUldn//jvYZfe24KigggqYAMbIAaMvUTBoFieBI2mqahJNNHoI6DRaDQkllhiNJZYQB5LooKKkYgFBAUVUXqRjtQFqcv8/sjP+TrUXVh2dvm8Xte1l3OfOed87t0d2QvmveczJg488MC45ZZbYuLEibFx48bN1hQVFcWbb74Z5513XpxwwgmxdOnSzPqrrroqWrRoUfafCAAAAAAAAADkUH6uGyiJRx55JCZOnBhjx46NVCoVy5Yti379+kW/fv2iSpUqWXPbtGkT06dPj/Xr10dEZAIC6XQ6OnfuHLfffnsuPgUAAAAAAAAAyKkKc6JARET16tXjtddei+9+97uZN/4j/hsCWLt2bVY9ceLEWLduXaTT6YiITEjgpJNOildeeSXy8vJy9nkAAAAAAAAAQK5UqKBARESjRo3ijTfeiDvuuCMaNWqUFQT45r/f/oj4b3Cgbt26ceutt8Yrr7wSderUyVn/AAAAAAAAAJBLFS4oEPHfMMC1114bM2fOjEceeSTOO++8aNasWebUgG8+6tWrF6effnrcc889MX369Lj++uudJAAAAAAAAABAouXnuoGdUa1atbj44ovj4osvjoj/nhywdOnSWLduXTRs2DAqV66c4w4BAAAAAAAAoHyp0EGBTaVSqWjQoEGu2wAAAAAAAACAcqtC3noAAAAAAAAAANgxggIAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAg+bluoLhatmxZ6numUqmYOnVqqe8LAAAAAAAAAOVVhQkKzJgxI1KpVKTT6VLbM5VKldpeAAAAAAAAAFARVJigwDd29s39dDpd6oEDAAAAAAAAAKgoKkxQYJ999ilRSKCoqCiWLl0aq1atioj/FzCoWbNmNGrUaJf0CAAAAAAAAADlXYUJCsyYMWOH1n355Zfxr3/9KwYMGBDTpk2LDRs2xA033BCXXnpp6TYIAAAAAAAAABVApVw3sKvtvffecdlll8Wnn34a5557bqxduzZ++tOfxoMPPpjr1gAAAAAAAACgzO32QYFvVK9ePZ566qk45phjIp1Ox5VXXhljx47NdVsAAAAAAAAAUKYSExSIiMjLy4s//vGPERFRVFQU/fv3z3FHAAAAAAAAAFC2EhUUiIg46qijonnz5pFOp2PIkCGxaNGiXLcEAAAAAAAAAGUmcUGBiIhDDjkkIiI2bNgQ77//fo67AQAAAAAAAICyk8igQJ06dTKPZ8+encNOAAAAAAAAAKBsJTIo8O3bDRQWFuawEwAAAAAAAAAoW4kLCqxZsybrdgMNGjTIYTcAAAAAAAAAULYSFxS45ZZbsk4RaNu2bQ67AQAAAAAAAICylZigwLJly+KXv/xl3H777ZFKpSIiol69etGxY8ccdwYAAAAAAAAAZSc/1w0U180331ziNRs2bIhly5bFhAkT4t13341169ZFOp2OiIhUKhW/+MUvIi8vr7RbBQAAAAAAAIByq8IEBfr165c5CWBHfDsgkE6no3PnzvHrX/+6tNoDAAAAAAAAgAohMbce+CZkkE6n45xzzomXX345qlSpkuOuAAAAAAAAAKBsVZgTBSL+36kAO2KPPfaI448/Pn784x/HscceW4pdAQAAAAAAAEDFUWGCAm+99VaJ1+Tn50edOnWioKAgmjRpsgu6AgAAAAAAAICKpcIEBbp27ZrrFgAAAAAAAACgwquU6wYAAAAAAAAAgLIjKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACZKf6waK6+abb87ZtW+66aacXRsAAAAAAAAASlOFCQr069cvUqlUTq4tKAAAAAAAAADA7qLCBAW+LZ1Ob3F80yBBcedt6zq5CicAAAAAAAAAwK5QoYIC337j/9tv4H8zXpxgQDqd3uo8AAAAAAAAANjdVZigwFtvvRUREVOmTIlf//rXsWzZskin01G5cuU46aST4uijj479998/6tatGxERy5cvj0mTJsWoUaPi9ddfj/Xr10cqlYoGDRrEHXfcEa1atcrlpwMAAAAAAAAAOVFhggJdu3aN9957LxMSSKVScfnll8dNN90UjRo12ubar776Kvr37x8PPPBALF26NK699tp4+eWXo3PnzmXUPQAAAAAAAACUD5Vy3UBxzZs3L84888xYunRpVK5cOQYNGhT33HPPdkMCERGNGjWKe++9NwYNGhT5+fmxbNmyOPPMM2POnDll0DkAAAAAAAAAlB8VJijQt2/fWLJkSaRSqbjhhhvi7LPPLvEeZ599dtxwww0REbF06dLo27dvabcJAAAAAAAAAOVahQgKrF69OgYOHBgREdWrV49f/epXO7zXNddcE9WrV490Oh3PPfdcrF69urTaBAAAAAAAAIByr0IEBUaMGBGFhYWRSqWiY8eOUaNGjR3eq0aNGtGpU6eIiFi5cmWMGDGitNoEAAAAAAAAgHKvQgQFZs+enXncpEmTnd7v23t8e28AAAAAAAAA2N1ViKDAwoULM4+XLVu20/stX74883jRokU7vR8AAAAAAAAAVBQVIijQoEGDiIhIp9MxduzYndornU7Hhx9+mKnr16+/U/sBAAAAAAAAQEVSIYIC++67b+bxggUL4vnnn9/hvZ5//vlYsGDBFvcGAAAAAAAAgN1dhQgKdO3aNerUqROpVCrS6XRceeWVMXPmzBLvM2PGjLjyyisjlUpFRETt2rWjW7dupdwtAAAAAAAAAJRfFSIoUKVKlejdu3ek0+lIpVIxd+7cOOaYY2LIkCHF3uPVV1+NY489NubPn5/Z56KLLorKlSvvws4BAAAAAAAAoHzJz3UDxXXLLbfE4MGDY/78+ZmwwBlnnBFHHnlknH/++XH00UdH69ato06dOhERsWLFipg8eXKMHDkynnnmmRgzZkwmIBARsccee8Qtt9ySy08JAAAAAAAAAMpchQkK1KlTJ1599dU44YQTYsmSJZnbEHzwwQcxevToba5Np9MREZk1DRs2jFdffTVq165dFq0DAAAAAAAAQLlRIW498I1DDz00/vOf/8QhhxySOR3gmzf/t/Xx7Xnf3gMAAAAAAAAAkqZCBQUiItq2bRujR4+Ou+66K5o3b545LeAb34QCvi2dTkfz5s3jrrvuitGjR0fbtm3LsmUAAAAAAAAAKDcqzK0Hvi0/Pz9++ctfxi9+8Yt4++2345133okxY8bEggULYunSpRERUb9+/WjSpEkcccQR0aVLl/jOd76zWYAAAAAAAAAAAJKmQgYFvpFKpaJr167RtWvXXLcCAAAAAAAAABVChbv1AAAAAAAAAACw4wQFAAAAAAAAACBBBAUAAAAAAAAAIEHyc93Azpo1a1aMGDEipk6dGkuWLInCwsKIiHjkkUdy3BkAAAAAAAAAlD8VMiiQTqfjqaeeirvuuis+/fTTzZ5LpVJbDAq88MILce+990ZERIMGDWLw4MFl0i8AAAAAAAAAlBcVLigwd+7cOP/88+Odd96JiP8GAyIiUqlU5vHWHHvssXHBBRfE2rVrI5VKxXvvvRedO3fe5T0DAAAAAAAAQHlRKdcNlMTcuXOjY8eO8c4772wWCvjmJIFtadSoUfTo0SNTDxo0aJf0CQAAAAAAAADlVYUJChQVFcUZZ5wRs2fPzow1btw4/vd//zf+/e9/xxtvvLHdEwUiIrp37555PGzYsF3RKgAAAAAAAACUWxXm1gOPPvpojBs3LnNqwNlnnx2PP/541KxZMyIiZs6cWax9TjzxxIj47wkEn3/+eSxdujTq16+/a5oGAAAAAAAAgHKmwpwocNddd2UeH3vssTFo0KBMSKAk6tevH3vttVem/vzzz0ulPwAAAAAAAACoCCpEUGD69OkxefLkTH333XdHpUo73vr++++feTxlypSd6g0AAAAAAAAAKpIKERQYPXp0RESkUqlo3bp1HHrooTu1X7169TKPly5dulN7AQAAAAAAAEBFUiGCAgsXLsw8btu27U7vV6NGjczjVatW7fR+AAAAAAAAAFBR5Oe6geJYuXJl5nHNmjV3er8VK1aU6n4Vwfr16+Pdd9+NWbNmxbx586JWrVqx5557Rvv27aNFixa5bg8AAAAAAACAMlIhggINGzbMPF6yZMlO7zdr1qwt7l2Wpk2bFqNHj44xY8bE6NGj46OPPorCwsLM882bN48ZM2bs9HUWLVoUffv2jYEDB271a9e5c+f45S9/Gd///vd3+noAAAAAAAAAlG8VIihQUFAQERHpdDo+/vjjndpr5cqV8emnn2bq5s2b79R+JTF8+PD4/e9/H2PGjCmVwMP2DBkyJC666KKsWzdsyXvvvRfvvfdeXHjhhfHQQw8l5pQFAAAAAAAAgCSqEEGBo48+OvN43rx58eGHH8bhhx++Q3v94x//iKKiooiIqFq1atbeu9q4cePi9ddfL5NrDR8+PLp37x7r1q3LjKVSqejQoUO0bNkyli1bFmPHjo2vvvoq8/xTTz0VK1asiBdffDEqVapUJn0CAAAAAAAAULYqxLvBTZs2jYMPPjhT9+3bd4f2WbZsWdx2222RSqUilUrFscceG1WqVCmtNndY1apVY7/99iu1/WbPnh1nn312VkjgmGOOic8++yzGjBkTgwYNitdffz1mz54dd999d1SuXDkz71//+lfceOONpdYLAAAAAAAAAOVLhQgKRET8/Oc/zzweMmRI/O53vyvR+q+//jrOPffcmD17dqTT6YiIuOqqq0q1x+KoXLlyHHbYYXHppZfGQw89FB9++GEUFhbG3/72t1K7Rt++fWPp0qWZunPnzjFs2LBo06ZN1ryqVavGlVdeGYMGDcoaHzBgQMycObPU+gEAAAAAAACg/KgwQYFLL7009t1334iISKfT0bdv37jggguK9Yb20KFD46ijjoo333wzc5rAEUccEaeddtqubjtL7969Y8WKFTF27Nh4+OGH4yc/+Ul06NAh6zf6d9bkyZPj8ccfz9RVqlSJxx57LKpVq7bVNd27d4/evXtn6rVr10b//v1LrScAAAAAAAAAyo8KExTIz8+PQYMGRfXq1SOVSkU6nY6BAwfGfvvtF506dYrf/va3WfPvuOOOuOSSS2KfffaJ008/PSZMmBAR/w0Z1K1bN5555pky/xzq16+/zTfsS8PTTz8dRUVFmfrss8+O1q1bb3fdb37zm6x60KBBsWbNmlLvDwAAAAAAAIDcqjBBgYiIww8/PJ599tmoUaNGpFKpiIjYuHFjfPDBB/Hss89m5qXT6fjtb38bjz32WOZWA9+EC+rUqRPPPfdctGzZMlefxi71wgsvZNUXX3xxsda1adMmjj766Ey9atWqeP3110u1NwAAAAAAAAByr0IFBSIizjjjjBg1alS0bds20ul01nPf3Fbgm1DAN2MR/w0PHHjggfHee+/F8ccfX+Z9l4X58+fHxx9/nKnz8/PjmGOOKfb6bt26ZdVDhgwprdYAAAAAAAAAKCcqXFAgIqJt27bxySefxKBBg+LYY4+N/Pz8SKfTWR8Rkflvhw4d4tFHH43x48dH27Ztc9n6LjV+/Pis+pBDDomaNWsWe33nzp2z6s8++6xU+gIAAAAAAACg/MjPdQM7KpVKRc+ePaNnz57x9ddfx8iRI+PLL7+MxYsXx7p166JRo0bRpEmT6NSpUzRq1CjX7ZaJCRMmZNWtWrUq0fr99ttvm/sBAAAAAAAAUPFViKBAUVFRrFq1KlPXqlUrKlX6f4ch1KhRI7773e/morVyZcqUKVn1PvvsU6L1zZs3z6oXL14cS5cujfr16+90bwAAAAAAAACUDxXi1gOPP/541K9fP+rXrx+NGjWKefPm5bqlcmnZsmVZdUFBQYnW16pVK6pVq5Y1tnz58p1tCwAAAAAAAIBypEKcKLBgwYJIp9MREdGhQ4do1qxZjjsqn1auXJlVV69evcR7VK9ePdasWZOpCwsLd7qviIiFCxfGokWLSrRm0xMSAAAAAAAAANh5FSIoULNmzYiISKVSJT5OP0k2DQpsejpAcVSvXj2WLl261T131P333x/9+/cvlb0AAAAAAAAA2HEV4tYDTZs2zXULFVIqlSqTNQAAAAAAAABUHBUiKHDAAQdkHn/55Zc57KR8q1WrVla9evXqEu+x6ZpN9wQAAAAAAACgYqsQtx449NBDo1WrVjFlypT48MMPY+nSpVG/fv1ct1XulOegwGWXXRbnnHNOidZMmTIlunfvXirXBwAAAAAAAOC/KkRQICLixz/+cfzmN7+JoqKiuP322+OOO+7IdUvlTt26dbPqRYsWlWj9ypUrNwsK1KtXb2fbioiIgoKCKCgoKJW9AAAAAAAAANhxFeLWAxERv/rVr6Jjx46RTqdjwIABMXDgwFy3VO60bt06q545c2aJ1m86v0GDBk5uAAAAAAAAANjNVJigQKVKleL555+Po48+OoqKiuKCCy6In/zkJzF16tRct1ZutGnTJqueMmVKidZPmzYtq27btu1O9wQAAAAAAABA+VJhbj1w8803R0TEcccdFxMmTIjCwsJ45JFH4pFHHol27dpF+/bto6CgIGrXrl2ifW+66aZd0W5OHHTQQVn1J598El9//XXUqFGjWOvffffdbe4HAAAAAAAAQMVXYYIC/fr1i1QqlalTqVSk0+mIiBg/fnx89tlnO7Tv7hQU2GOPPeKQQw6JTz75JCIiNmzYEO+8806cdNJJxVo/fPjwrPrUU08t7RYBAAAAAAAAyLEKc+uBLUmlUpmPkvomZLC76dGjR1b997//vVjrvvjiixg1alSmrlmzZrEDBgAAAAAAAABUHBUqKJBOp0vtY3d14YUXRl5eXqZ+/vnnY/Lkydtdd8cdd2TV5557blSrVq3U+wMAAAAAAAAgtyrMrQfeeuutXLdQIbRu3Tp69+4djz76aERErFu3Li666KJ48803t/rG/0svvRSPPfZYpq5SpUr07du3LNoFAAAAAAAAoIxVmKBA165dc91CqZg9e3Zs2LBhs/H58+dn1Rs2bIgZM2ZscY9atWpFo0aNtnqN/v37xwsvvBBLly6NiIj33nsvTjjhhPjb3/4WBx54YGbe2rVr469//Wv86le/ylr/q1/9Kpo3b17cTwkAAAAAAACACqTcBAV++ctfZh7fdNNNUa9evdw1swt16dIlZs6cud15c+bMiX333XeLz/Xu3TvrBIBN7bXXXvH888/HySefHOvWrYuIiHfffTfatm0bhx9+eLRs2TKWL18eH330USxatChr7RlnnBG33HJL8T8hAAAAAAAAACqUchMU+POf/xypVCoiIq6++urtBgXefvvtzOOOHTtGlSpVdmV7FU63bt3ihRdeiIsuuigTBkin0zFmzJgYM2bMFtecf/758fDDD0deXl5ZtgoAAAAAAABAGaqU6wa+LZ1OF3tut27d4rjjjovjjjtus2P7+a/TTjstxo8fHz/72c+ifv36W53XsWPHGDx4cDz99NNRs2bNMuwQAAAAAAAAgLJWbk4U2BHpdDpzCkFFMWPGjDK9XkFBQTzwwANx9913x7vvvhszZ86M+fPnR82aNaNZs2bRvn37rd7iAAAAAAAAAIDdT4UOClS0kEAuValSJY477rhctwEAAAAAAABAjpWrWw+UVEluVQAAAAAAAAAAVPCgAAAAAAAAAABQMoICAAAAAAAAAJAgggIAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAgggIAAAAAAAAAkCCCAgAAAAAAAACQIPm5buDbUqlURESMHDkyZsyYUex1JZ3/bd/5znd2aB0AAAAAAAAAVETlKigQEZFOp+P888/fZfO/LZVKxYYNG3ZoLQAAAAAAAABUROUuKJBKpSKdThdr3jeKMx8AAAAAAAAAKIdBgYjsEMCumB8hXAAAAAAAAABAMpWboMA+++yzQ2/4AwAAAAAAAADFV26CAjNmzMh1CwAAAAAAAACw26uU6wYAAAAAAAAAgLIjKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIiiwG+rXr1+kUqkd/rjoooty/SkAAAAAAAAAsIsICgAAAAAAAABAgggKAAAAAAAAAECC5Oe6AXa9Z555Jjp27Fjs+bVq1dqF3QAAAAAAAACQS4ICCdC0adNo0aJFrtsAAAAAAAAAoBxw6wEAAAAAAAAASBBBAQAAAAAAAABIEEEBAAAAAAAAAEgQQQEAAAAAAAAASBBBAQAAAAAAAABIEEGBBHjooYfihBNOiGbNmkW1atWidu3a0aJFi+jatWvccMMNMWLEiFy3CAAAAAAAAEAZyc91A+x6zz77bFa9du3aWLlyZcycOTPefvvtuO222+KII46I3//+93HCCSfskh4WLlwYixYtKtGaKVOm7JJeAAAAAAAAAJJMUICIiBgzZkycdNJJcf3118fvfve7SKVSpbr//fffH/379y/VPQEAAAAAAAAoOUGB3VizZs3itNNOi6OOOiratGkTDRo0iEqVKsXixYvjo48+ipdffjlee+21zPx0Oh233XZbbNy4MX7/+9/nsHMAAAAAAAAAdhVBgd3QUUcdFa+99lqceOKJWz0ZoHPnznHFFVfEmDFj4oILLojJkydnnrv99tujY8eOcdZZZ5VVywAAAAAAAACUkVQ6nU7nuglya8mSJdGpU6eYNGlSZuzAAw+M8ePHR15eXqlcY+HChbFo0aISrZkyZUp07949U48fPz7atWtXKv0kWeqKp3LdAgARkb7vwly3AAAAAABADn322Wdx0EEHZeqyfD/UiQJEgwYN4plnnokjjjgivsmNfPHFF/HWW2/FCSecUCrXKCgoiIKCglLZCwAAAAAAAIAdVynXDVA+dOjQIU466aSssaFDh+aoGwAAAAAAAAB2FUEBMk455ZSs+pNPPslRJwAAAAAAAADsKoICZLRo0SKrXrRoUW4aAQAAAAAAAGCXERQgo3r16ln16tWrc9QJAAAAAAAAALuKoAAZX331VVbdqFGjHHUCAAAAAAAAwK4iKEDGqFGjsuo999wzR50AAAAAAAAAsKsIChAREWvWrInnn38+a6xbt265aQYAAAAAAACAXUZQgIiIuOOOO2LOnDmZOi8vL04//fQcdgQAAAAAAADAriAosJt58sknY8GCBSVa8/DDD0f//v2zxi666KJo3rx5abYGAAAAAAAAQDkgKLCbeeSRR2LfffeN3r17xyuvvBKrVq3a6twxY8bE2WefHT/5yU8inU5nxps1axa/+93vyqJdAAAAAAAAAMpYfq4boPStXr06nnjiiXjiiSeiUqVK0bp162jRokXUrVs38vLyYvHixfHxxx9v8eSBBg0axNChQ6Np06Y56BwAAAAAAACAXU1QYDe3cePGmDhxYkycOHG7c48//vh47LHHYq+99iqDzgAAAAAAAADIBUGB3cxVV10VzZo1i3fffTdmzpy53fk1a9aMk046KS6//PI4/vjjy6BDAAAAAAAAAHJJUGA306NHj+jRo0dERCxbtiw+++yz+PLLL2PBggXx9ddfx8aNG6NevXpRv379aNOmTRxyyCGRl5eX464BAAAAAAAAKCuCAruxevXqxTHHHJPrNgAAAAAAAAAoRyrlugEAAAAAAAAAoOwICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECCCAoAAAAAAAAAQIIICgAAAAAAAABAgggKAAAAAAAAAECC5Oe6AQAAAAB2XOqKp3LdAgARkb7vwly3AABQbE4UAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEyc91AwAAAAAAANuTuuKpXLcAQESk77sw1y1QCpwoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJkp/rBihb06dPj3HjxsXcuXNj5cqVsccee0Tz5s2jc+fOUbly5Vy3BwAAAAAAAMAuJiiQEIMHD44BAwbE+++/v8XnGzRoEL169Yqbb745GjVqVMbdAQAAAAAAAFBW3HpgN7dy5co4//zz45xzztlqSCAiYsmSJfHAAw/EQQcdFK+99loZdggAAAAAAABAWXKiwG6sqKgoevXqFa+++mrWeOPGjaN9+/ZRt27dmDp1aowdOzbS6XRERCxYsCDOOuusGDZsWHTp0iUXbQMAAAAAAACwCzlRYDd23XXXZYUEKleuHPfee2/Mnj07XnvttRg0aFB8+OGHMX78+OjUqVNm3tq1a6N79+4xb968XLQNAAAAAAAAwC4kKLCbmjZtWtx9991ZY88991xcccUVUaVKlazxtm3bxptvvpkVFli8eHH079+/THoFAAAAAAAAoOwICuym+vfvH+vXr8/UF110UZx11llbnV+9evV47LHHskIEjzzySEybNm2X9gkAAAAAAABA2RIU2A2tXr06Bg8enDX2m9/8Zrvr9t9//+jevXum3rBhQzz99NOl3R4AAAAAAAAAOSQosBt67bXX4uuvv87UnTp1igMPPLBYay+++OKs+vnnny/V3gAAAAAAAADILUGB3dDQoUOz6m7duhV77bHHHhv5+fmZeuzYsbFgwYLSag0AAAAAAACAHBMU2A2NHz8+q+7UqVOx19asWTMOPvjgrLHPPvusVPoCAAAAAAAAIPcEBXZDn3/+eVbdqlWrEq3fb7/9suoJEybsdE8AAAAAAAAAlA+CAruZJUuWxJIlS7LG9tlnnxLtsen8yZMn73RfAAAAAAAAAJQP+dufQkWybNmyrLpGjRpRs2bNEu1RUFCQVS9fvnxn24qFCxfGokWLSrRm05MMpkyZstN9EBGLZ+e6AwDCrX0AgFLk73kA5YK/55UBP/MAygU/80rPpu9/rl27tsyuLSiwm1m5cmVWXb169RLvsemawsLCneopIuL++++P/v3779Qe3bt33+k+AKC8OOjZ63LdAgAAAKXI3/MASAo/83adL7/8Mjp06FAm13Lrgd3MpkGBatWqlXiPTYMCm+4JAAAAAAAAQMUlKLCbS6VSZbIGAAAAAAAAgIrBrQd2M7Vq1cqqV69eXeI9Nl2z6Z474rLLLotzzjmnRGtWrFgRY8aMiTp16kS9evVi7733jqpVq+50L0DFNWXKlKzbkLz44ovRqlWr3DUEALuIn3kAJIWfeQAkhZ95wJasXbs2vvzyy0zdtWvXMru2oMBuprwGBQoKCqKgoKDE6zp16rTT1wZ2X61atYp27drlug0A2OX8zAMgKfzMAyAp/MwDvtGhQ4ecXNetB3YzdevWzaq//vrrWLVqVYn2WLhwYVZdr169nW0LAAAAAAAAgHJCUGA307Bhw6hfv37W2KxZs0q0x8yZM7Pq1q1b73RfAAAAAAAAAJQPggK7oTZt2mTVU6ZMKdH6adOmbXM/AAAAAAAAACouQYHd0EEHHZRVv//++8Veu2rVqvjkk0+2uR8AAAAAAAAAFZegwG7olFNOyaqHDx9e7LUjRoyIDRs2ZOr27dtHkyZNSqs1AAAAAAAAAHJMUGA3dPLJJ0f16tUz9fvvvx9ffPFFsdY+9thjWXWPHj1KszUAAAAAAAAAckxQYDdUo0aN6NmzZ9bYHXfcsd11kyZNihdeeCFT5+fnxwUXXFDq/QEAAAAAAACQO4ICu6l+/fpF5cqVM/Vjjz0W//znP7c6f82aNXHxxRfHunXrMmOXXHJJ7Lfffru0TwAAAAAAAADKlqDAbqply5Zx1VVXZY317Nkz7rvvvqwwQETE559/Hscff3y89957mbGGDRtG3759y6RXAAAAAAAAAMpOfq4bYNe5/fbb47PPPoshQ4ZERMT69eujT58+ccstt0SHDh2idu3aMW3atPjoo48inU5n1lWpUiVeeOGF2GOPPXLVOgAAAAAAAAC7iKDAbiwvLy8GDRoUl156aQwcODAzvnDhwhg6dOgW1xQUFMTjjz8exx57bFm1CQAAAAAAAEAZEhTYzdWqVSueffbZ6NmzZ/zxj3+MkSNHbnFegwYNolevXtG/f/9o3LhxGXcJUDyNGzfOui2KP68A2F35mQdAUviZB0BS+JkHlDep9LfPnGe3N3369Pjoo49i7ty5sWrVqmjatGk0b948jjnmmKhSpUqu2wMAAAAAAABgFxMUAAAAAAAAAIAEqZTrBgAAAAAAAACAsiMoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAmSn+sGAKC4pk+fHuPGjYu5c+fGypUrY4899ojmzZtH586do3LlyrluDwAAgO0oKiqKKVOmxIQJE2Lu3LmxfPnyqFq1atSvXz/222+/OOKII6JmzZq5bhMAdtrq1avjiy++iJkzZ8bcuXOjsLAw1q9fH3Xq1ImGDRvGQQcdFO3atYv8fG/VAbnhTx8Ayr3BgwfHgAED4v3339/i8w0aNIhevXrFzTffHI0aNSrj7gCgdEybNi1Gjx4dY8aMidGjR8dHH30UhYWFmeebN28eM2bMyF2DALCDZs2aFc8//3wMGzYsRowYEStWrNjq3Ly8vDjxxBPjiiuuiNNPP70MuwSAnff3v/89/v3vf8eoUaNi6tSpsXHjxm3Or1WrVpx77rnRp0+fOOyww8qmSYD/XyqdTqdz3QQAbMnKlSvjxz/+cTz77LPFmt+kSZN4/PHH4+STT97FnQFA6Rg+fHj8/ve/jzFjxsSSJUu2OVdQAICK6IILLohnnnlmh9aeccYZ8be//S2aNGlSyl0BwK6x1157xZw5c0q8Li8vL/r06RN33nmnEwaAMuNPGwDKpaKioujVq1e8+uqrWeONGzeO9u3bR926dWPq1KkxduzY+CbztmDBgjjrrLNi2LBh0aVLl1y0DQAlMm7cuHj99ddz3QYA7DKTJk3a4nizZs2idevW0aRJk9iwYUNMmzYtPv7446zfvHz55ZfjO9/5TvznP/+Jpk2bllXLAFBqatSoEfvtt1/ss88+UadOndi4cWMsWbIkPv3005g/f35mXlFRUfz5z3+OGTNmxODBgyMvLy+HXQNJISgAQLl03XXXZYUEKleuHAMGDIif/OQnUaVKlcz4hAkT4tJLL83clmDt2rXRvXv3+PTTT2OPPfYo874BoDRUrVo19tprr5g6dWquWwGAUtO+ffv40Y9+FKeeemrst99+mz0/Z86cuPnmm+Ovf/1rZmzSpElxzjnnxNtvvx2pVKos2wWAEqtZs2aceeaZceqpp0bnzp3joIMOikqVKm1x7siRI+PGG2+MN998MzP24osvxoABA+Laa68tq5aBBHPrAQDKnWnTpsWBBx4Y69evz4y9+OKLcdZZZ21x/urVq+P444/PhAUiIn7605/Ggw8+uMt7BYCd8ec//zl+/etfR7t27eKII46II488Mo444og4+OCD4913343jjjsuM9etBwCoiI488sho0qRJ9OvXL4444ohirbn//vvj8ssvzxp75pln4rzzztsVLQJAqVm/fn1Urly52PM3btwYvXv3jn/84x+Zsbp168aCBQuiatWqu6JFgAxBAQDKnd69e8cTTzyRqS+66KL4+9//vs01kyZNioMPPjjWrVsXERH5+fkxceLEaNmy5S7tFQB2xtKlS6N69epRrVq1zZ4bPny4oAAAFd6MGTOiRYsWJV7Xs2fP+L//+79Mfdppp8Urr7xSip0BQPmwYsWK2HPPPWPVqlWZsSFDhsQpp5ySw66AJNjyeScAkCOrV6+OwYMHZ4395je/2e66/fffP7p3756pN2zYEE8//XRptwcApap+/fpbDAkAwO5iR0ICEbHZiQJvvfVWKXQDAOVPnTp1okuXLlljU6ZMyVE3QJIICgBQrrz22mvx9ddfZ+pOnTrFgQceWKy1F198cVb9/PPPl2pvAAAAlI327dtn1atXr45ly5blphkA2MUaNGiQVRcWFuaoEyBJBAUAKFeGDh2aVXfr1q3Ya4899tjIz8/P1GPHjo0FCxaUVmsAAACUkW//3e4b39xqDgB2NzNnzsyq99xzzxx1AiSJoAAA5cr48eOz6k6dOhV7bc2aNePggw/OGvvss89KpS8AAADKzqZHLufn50ejRo1y1A0A7DqTJk2KUaNGZepUKhVdu3bNYUdAUggKAFCufP7551l1q1atSrR+v/32y6onTJiw0z0BAABQtgYPHpxVH3HEEVGpkn/KBGD3Mm/evDjnnHOiqKgoM9azZ89o0aJF7poCEmPzM7wAIEeWLFkSS5YsyRrbZ599SrTHpvMnT568030BAABQdlauXBmPPPJI1liPHj1y1A0AlJ4NGzbE0qVL4/PPP4+XX345HnrooVixYkXm+ZYtW8Z9992Xww6BJBEUAKDcWLZsWVZdo0aNqFmzZon2KCgoyKqXL1++s20BAABQhq6//vqYP39+pq5Xr15ceumlOewIAHbM1VdfHXfffXex5h533HHx5JNPbvbvmwC7ivO6ACg3Vq5cmVVXr169xHtsuqawsHCnegIAAKDsvPDCC5v9JuWtt94aDRo0yFFHALBrnXnmmfHaa6/Fv//972jWrFmu2wESxIkCAJQbmwYFqlWrVuI9Ng0KbLonAAAA5dPHH38cP/zhD7PGTjrppPj5z3+eo44AYNcbMmRIFBUVRbVq1eI73/lOrtsBEsSJAgCUW6lUqkzWAAAAkFuzZs2K008/PSvs3bx58/jHP/7h73kAVFg33XRTTJ8+PfMxYcKEGDFiRNx7773x3e9+NyIi1q9fH6+88kp07do1rrjiiigqKspx10BSOFEAgHKjVq1aWfXq1atLvMemazbdEwAAgPJl4cKFceKJJ8acOXMyY02bNo033ngjGjdunMPOAGDnNGjQYIu3z+nSpUtcccUV8c4778T//M//xMyZMyMi4i9/+UusXr06HnnkkbJuFUggJwoAUG4ICgAAACTLkiVL4oQTTohJkyZlxho1ahTDhg2L1q1b57AzANj1unTpEm+99VY0bNgwM/boo4/GSy+9lMOugKQQFACg3Khbt25W/fXXX8eqVatKtMfChQuz6nr16u1sWwAAAOwCy5cvj5NOOik+/fTTzFj9+vXjjTfeiHbt2uWwMwAoO/vuu2/cdNNNWWN/+MMfctQNkCSCAgCUGw0bNoz69etnjc2aNatEe3xzTNc3/AYKAABA+VNYWBinnHJKfPjhh5mxOnXqxNChQ+Owww7LXWMAkAPnnXdeVj1y5MhYtmxZbpoBEkNQAIBypU2bNln1lClTSrR+2rRp29wPAACA3Fq1alWcdtppMXLkyMxYrVq1YsiQIXHUUUflsDMAyI2CgoKsX6DauHFjTJ8+PYcdAUkgKABAuXLQQQdl1e+//36x165atSo++eSTbe4HAABA7qxevTrOOOOMeOeddzJjNWrUiFdeeSU6d+6cw84AILcqV66cVa9duzZHnQBJISgAQLlyyimnZNXDhw8v9toRI0bEhg0bMnX79u2jSZMmpdUaAAAAO2HNmjVx5plnZv09r1q1avHPf/4zvvOd7+SuMQDIsTVr1sRXX32VNebfNYFdTVAAgHLl5JNPjurVq2fq999/P7744otirX3sscey6h49epRmawAAAOygdevWxdlnnx3Dhg3LjFWtWjVefPHFOP7443PYGQDk3ptvvhkbN27M1DVq1IhmzZrlsCMgCQQFAChXatSoET179swau+OOO7a7btKkSfHCCy9k6vz8/LjgggtKvT8AAABKZsOGDXHuuefGkCFDMmOVK1eOwYMHx8knn5zDzgAg9zZu3Bi33HJL1tgpp5wSVapUyVFHQFIICgBQ7vTr1y/rnlyPPfZY/POf/9zq/DVr1sTFF18c69aty4xdcsklsd9+++3SPgEAANi2oqKiuPDCC+Oll17KjOXn58fAgQPjjDPOyGFnAFC67r333pg3b16J1qxfvz4uueSSGDVqVNb45ZdfXpqtAWxRKp1Op3PdBABs6tprr4277rorU1euXDkGDBgQP/nJT7LStJ9//nlceuml8d5772XGGjZsGJ9++mnsscceZdozAOyI2bNnx4YNGzYbHzlyZJx//vmZulmzZvHOO+9scY9atWpFo0aNdlmPALCjevfuHU888UTW2B/+8Ic455xzSrxX06ZNo1q1aqXVGgCUqsMOOywmTZoUZ599dvTq1Su6desWtWvX3uLc1atXx4svvhi33nprfPbZZ1nP/eAHP9jsZyfAriAoAEC5VFRUFN/73veyjqaMiCgoKIgOHTpE7dq1Y9q0afHRRx/Ft3+UValSJYYNGxbHHntsWbcMADukRYsWMXPmzJ3ao3fv3vHYY4+VTkMAUIpSqVSp7fXWW29Ft27dSm0/AChNhx12WHz88ceZOpVKRatWraJFixZRr169qFKlShQWFsbMmTNjwoQJsX79+s32OOOMM2Lw4MFRtWrVsmwdSKj8XDcAAFuSl5cXgwYNiksvvTQGDhyYGV+4cGEMHTp0i2sKCgri8ccfFxIAAAAAAHIqnU7H5MmTY/LkydudW7169bjxxhvj2muvzbolK8CuVCnXDQDA1tSqVSueffbZeO6556Jjx45bndegQYP4+c9/HuPHj49TTjmlDDsEAAAAAIh4+OGH48Ybb4xOnToV+0SAAw88MG655ZaYNGlS/Pa3vxUSAMqUWw8AUGFMnz49Pvroo5g7d26sWrUqmjZtGs2bN49jjjkmqlSpkuv2AAAAAABi/fr18fnnn8e0adNizpw5sXLlyli/fn3UqlUr6tSpEy1atIj27dtH/fr1c90qkGCCAgAAAAAAAACQIG49AAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAmzdu3aePzxx+Pss8+OFi1aRK1atSKVSmU+unXrlusWAQAAgF0oP9cNAAAAwLa0aNEiZs6cmTW27777xhdffBFVqlTZqb0WLVoUjRo1KpU+K4qJEydG9+7d44svvsh1KwAAAECOOFEAAACACmf69Onx4IMP5rqNCqewsDBOP/10IQEAAABIOCcKAAAAUCH97ne/i4svvjhq166d61YqjIcffjimTp2aqQ844IC48cYbo3379lGzZs3MeLVq1XLRHgAAAFBGBAUAAACokBYtWhR33XVX9O/fP9etVBjPPfdc5nGVKlXizTffjGbNmuWwIwAAACAX3HoAAACACmvAgAGxYMGCXLdRIRQVFcXYsWMzdceOHYUEAAAAIKEEBQAAAKhQunfvnnm8cuXKuPnmm3PXTAWyfPnyWLt2babea6+9ctgNAAAAkEuCAgAAAFQo/fv3j+rVq2fqhx9+OKZMmZLDjiqGlStXZtWVK1fOUScAAABAruXnugEAAAAoiT333DOuuuqquP322yMiYv369XHjjTfGs88+WybXLywsjHfffTfmzJkTixYtiqpVq0ZBQUG0adMm2rdvH6lUqkz6KKmNGzfusr3HjRsXEydOjPnz58eqVauiSZMm8cMf/nC7YYR58+bFqFGjYuHChbF48eKoVatWFBQUxJFHHhktW7Ysld7S6XSMHTs2Jk6cGIsWLYpVq1ZFo0aNYq+99oouXbpE7dq1S+U6JfHll1/GuHHjYtasWVFYWBhFRUVRo0aNaNy4cbRo0SIOPvjgqFu37k5fZ/78+fHBBx/EnDlzYvny5dGkSZM48MADo2PHjjv1Ot24cWNMnDgxJk6cGLNnz47CwsLIz8+P+vXrxz777BNHH310qfT/jTVr1sTIkSNj1qxZ8dVXX8Xq1aujdu3a0bx58zjooINiv/322+G9lyxZEu+9917Mnz8/vvrqq6hWrVo0btw4DjvssGjXrt1O9b106dIYN25cTJ48OXOiR/Xq1aNevXrRvHnzaNOmjdt/AAAAOZNKp9PpXDcBAAAAW9OiRYuYOXNmpl60aFFUrlw5WrZsGUuWLImIiFQqFaNHj47DDz+8xHs1atSoWH289957cfPNN8e///3vWL9+/RbnFBQUxA9+8IO4/vrro2HDhsXad1fq1q1b/Oc//ynRmq5du8bw4cMz9fDhw+O4447L1H379o1+/fpFUVFRDBgwIP76179u8USHpUuXRr169TYbX79+fTzyyCNx//33x6effrrVPlq3bh3XXHNN/OhHP4r8/JL/nsOXX34Zt912WwwePDi++uqrLc6pXLlynHDCCXHzzTfHEUccUeJrlMTGjRvj0Ucfjb/85S8xbty4bc5NpVLRtm3b+N73vhe/+MUvoqCgYIvzNv3+fvNPPKNGjYpbbrklhg4dGkVFRZut23PPPeOXv/xlXHXVVcX+2i5dujReeOGFeOmll+Ltt9+OZcuWbXVupUqVokuXLnHttdfGGWecUaz9t+T111+Pu+66K95+++2s22Zsaq+99oqzzjorfvrTn8bBBx+83X3T6XQMHDgw/vznP8fo0aO3GqJp1qxZ9OnTJ6688sqsU0y256233orbb7893nzzzS1+/Te9xqmnnhpXXHFFHHroocW+BgAAwM4SFAAAAKBc29qb+3fddVdce+21mfHjjz8+hg0btkN7bcv69evjZz/7WTz66KPF7rlu3brx5JNPxve+971ir9kVdlVQ4Kc//Wl8//vfj/fff3+r+2wpKPDhhx/GueeeG9OmTSt2P4cddli8/PLLJfrN6zvuuCP69u27zTeXvy2VSsU111wTd9xxxy45EWLZsmVx5plnxogRI0q89o033ogTTjhhi89tKShw//33R58+fYp1gsThhx8eQ4YMicaNG2937iGHHLLNYMfWnHfeefG3v/0tatasWew1CxYsiPPPPz/eeuutEl1r09fulkybNi169uwZY8eOLfa+LVq0iJdffnm7Jwyk0+m4+uqr45577in23t+44YYb4ne/+12J1wEAAOwotx4AAACgQurTp0/ce++9MWvWrIiIePPNN+ONN96IE088sdSusX79+jj99NPjjTfeyBrPz8+PI488Mvbee+9YvXp1TJgwIaZOnZp5fvny5dGjR4949NFH44c//GGp9VMerF27Nnr06BGjRo2KiIi8vLw4/PDDY++9946IiFmzZsWHH3642bqXX345evXqFV9//XXW+B577BGHHnpoNGjQIFatWhUTJkyIyZMnZ54fN25cHH300TFy5MjYa6+9ttnbxo0b40c/+lE8/vjjWeOVKlWKgw8+OFq0aBE1a9aMRYsWxQcffBDLly+PiP++wXvnnXfGwoUL47HHHivx12R7zj333M1CArVq1YpDDz009txzz6hatWqsXLkyFi5cGBMmTNjmb+tvy3PPPRdXXHFF5mSBgoKC6NChQ9SrVy8WLFgQI0eOjNWrV2fmf/jhh3HcccfFiBEjon79+tvce9PgQYMGDaJt27bRqFGjqFWrVqxatSpmzJgR48ePzzpx49lnn42VK1fGP//5z2KFMMaPHx+nnHJKzJkzJ2s8lUrFwQcfHM2bN486derE8uXLY+rUqTFx4sRi31bjgw8+iNNPP32zEyYaNmwY7du3j0aNGsXatWtj8uTJMX78+MzzM2bMiGOOOSaGDx8ehx122Fb3v+222zYLCeTn58chhxwSzZs3j5o1a8bq1atj6dKl8cUXX8TcuXOL1TcAAMAukQYAAIByrHnz5umIyHwsWrQo89zf//73rOc6dOiQ3rhx4w7ttSXXXntt1vxUKpW+7LLL0gsXLtxs7jvvvJM++OCDs+ZXq1Yt/fHHH+/4J7+T5s2bl54+fXp6+vTp6REjRmT19v3vfz/z3Lc/5s2bl7XHW2+9lbWudu3a6YhIV6pUKf2rX/0q/dVXX2123VmzZqXXr1+fqT/77LN0zZo1s/Y55ZRT0qNGjdpi3x999FH62GOPzZrfpUuX9IYNG7b5+fbr1y9rTdWqVdN9+/bd4vdr/fr16UcffTRdv379rDUPPvhgcb60xTZ06NCs/Rs2bJj+xz/+kV63bt1W14wfPz79hz/8IX3AAQek33jjja3O69q1a9be33wuTZo0SQ8cOHCzr9fKlSvTN998c7pKlSpZ6y688MLtfh4HHXRQukuXLun77rsvPW3atK3OW7JkSfrOO+/MvE6++XjggQe2e43Fixen991336x1NWvWTN90001b/B6m0+n08uXL00899VT6pJNOSnfr1m2re8+bNy+9xx57ZO199NFHp19//fUt/pkxefLkdPfu3bPmt27dOr1ixYot7r9s2bJ0tWrVMnPz8vLS/fr1Sy9dunSrPc2dOzf96KOPprt165a+8cYbt/3FAQAAKGWCAgAAAJRr23pzv6ioKH3QQQdlPf/000/v0F6bGjduXDqVSmXNv+eee7bZa2FhYbpjx45Za4488siSf9K7wPTp07P66t27d7HWbRoU+ObjqaeeKtb6LX2P+vXrt91169evT5999tlZ6x5//PGtzh85cmS6UqVKWW+af/TRR9u9zsSJE9MNGzbMrKtbt+5W3wzeET//+c+zPoe33nqr2Gs3btyYXrNmzVaf3zQoEBHppk2bpidPnrzNfV944YV0Xl5e1rphw4Ztc8306dOL3Xc6/d//f+rWrZvZv2XLlumioqJtrjn//POzetpjjz3SY8eOLfY1Nw25fNtpp52Wtfcll1yy3eBJOp1OX3nllVnr+vfvv8V5AwcOzJrXt2/fYvedTqfTX3/9dYnmAwAA7KxKAQAAABVUpUqV4rbbbssau/HGG7OOPt9RAwYMyBzhHhHx/e9/P/r06bPNNbVq1YqBAwdm3Y999OjR8fbbb+90P+XJj370o7jggguKNff555/POsb93HPPjb59+253XX5+fjz++ONRUFCQGbvrrru2Ov+WW27JOoL+qaeeivbt22/3Ovvvv3888MADmXr58uXx8MMPb3ddcc2cOTPzuGHDhtGtW7dir02lUlG1atUSXe/BBx+MVq1abXNO9+7d4/LLL88au/vuu7e5pkWLFiXq49BDD43//d//zdTTpk2L999/f6vzJ06cGAMHDszUeXl58dxzz23zqP9NNW3adIvjY8aMiVdffTVTd+rUKf76179GXl7edvccMGBAHHLIIZn6vvvui7Vr124279vf54iInj17FrftiIioXr16ieYDAADsLEEBAAAAKrTvfe97ceyxx2bqadOmxUMPPbRTe65duzbrTcuI2CyQsDX77LNP/PznP88a2xX3vc+l6667rthzv33P9lQqFbfffnux19aqVSt++tOfZupPP/00ZsyYsdm8qVOnxiuvvJKpu3btGqeeemqxr9OzZ89o3rx5pv7nP/9Z7LUlsWLFilizZs0u2Tsi4vDDD4+zzjqrWHNvuummqFKlSqZ+5ZVXYtGiRaXaz/e///2s+r333tvq3Iceeigr6PE///M/ccwxx5RKH99+DUb89//lSpWK909ieXl5cdVVV2XqRYsWbTPw8I2FCxeWrEkAAIAyJigAAABAhXfHHXdk1bfcckusXLlyh/cbPXp01m8NH3nkkbH//vsXe/0Pf/jDrPqdd97Z4V7Km3bt2kXr1q2LNXfVqlUxcuTITH3kkUfGvvvuW6LrHXfccVn1iBEjNpszbNiwrLpXr14lukYqlYquXbtm6lGjRsW6detKtMfWHHjggZnH69evj1//+tdZJ1WUpuKe8hDx39MNTjrppEy9cePGYr0BvqmioqJYvnx5zJ49O2bMmJH1UVRUlDX3888/3+o+b775Zlb9s5/9rMS9bM23Xx9NmzbN+l4XR3Feg9/+PkdE3HDDDTv1ZxAAAMCulp/rBgAAAGBnderUKc4666x46aWXIuK/v8171113Rb9+/XZovzFjxmTVnTt3LtH6gw46KOrUqRMrVqyIiIjJkyfH8uXLo27dujvUT3lSnOP8vzFy5Mis20C0bNlyiycCbMu3f8s84r+nB2xq0yBGQUFBia9To0aNzOM1a9bE3LlzS3zc/pacf/75MWDAgEx97733xn/+85+45JJL4nvf+16JgxPbcvTRR5d4/ssvv5ypR48eHWeeeeY21yxdujReeOGFeOWVV+KTTz6JadOmbfY92tbaLSksLIxPP/00U9esWTOOPPLIYu25PVOnTo158+Zl6latWm12m4Dt2TQ0sqXX4PHHHx8FBQWZkwRGjhwZrVu3jksuuSR69OgR7du3L/YpBgAAAGVBUAAAAIDdwu9///t4+eWXM7/F/Mc//jEuu+yyrHvcF9emx4aX5DSBiP/+hvr++++fFThYuHDhbhEUKMnX88svv8yqn3322Xj22Wd36vpLlizZ7nVKen/4rV2nNIICRxxxRFx99dXx5z//OTP2ySefxFVXXRVXXXVV7L333tG5c+fo3LlzfOc734lDDz00UqnUDl2rpK/TTU+G2NZx+UVFRXHnnXfGrbfeusO/Kb98+fItji9YsCDrlIUDDjgg8vLydugam9r0tfHOO+/sdDhjS6/BGjVqxIMPPhg9e/bMBCfmz58ft956a9x6661Rr1696NSpU3Tq1CmOPfbY6NixY1SrVm2n+gAAANgZoswAAADsFtq0aRMXXXRRpl65cmXccsstO7TXpr/5vCNv8G+6ZktvLlZEtWvXLvbcxYsXl/r1CwsLc3adHfWnP/0p/vSnP23xdfTll1/GwIED46qrror27dvH3nvvHddcc03Mnj27xNepU6dOieYX9zW6YcOGOO+88+L666/fqeP0t3bywKbfv/r16+/wNba3d2nY2mujR48eMXTo0GjVqtVmzy1btiyGDBkSN910Uxx33HHRuHHjuPDCC2P06NGl3h8AAEBxCAoAAACw2+jfv39Ur149Uz/00ENbPCZ8eza9h/yO/oZ3ae9R0Wx6ZHtp2PR7U5bX2RlXX311zJw5Mx544IE46aSTombNmlucN2fOnPjjH/8YrVq1irvvvrtUe9ierb1G//SnP8XgwYOzxjp27Bh33nlnvPXWWzFlypRYvnx5rF27NtLpdNZHafaxI8r6tXHiiSfG559/Hs8//3ycd9550aRJky3OW7lyZTz99NNx1FFHxY9+9KNYvXp1qfcJAACwLYICAAAA7DaaNWsWffr0ydTr16+PG2+8scT7NGjQIKve2pHp27LpmtL8LemKolGjRln1bbfdttkbySX9eOyxx7Z7nblz5+70dbp161bqX4+6devGz372s3jttddi2bJl8eGHH8Z9990XvXr12uw1t3bt2rj66qvjnnvuKfb+K1asKFE/xXmNrlu3Lm699dZMnUql4rHHHov3338/rrnmmujWrVvst99+UadOnahSpcoO9bPp9680T9/YdO+f/OQnO/3aGD58+DavmZ+fHz169Ihnnnkm5s+fH5MnT44nnngifvrTn0bLli03m//3v/89LrzwwlL7nAEAAIpDUAAAAIDdyvXXX5/1hufAgQPjo48+KtEeBQUFWfWkSZNKtD6dTsfkyZOzxho3blyiPXYHm/42dUm/juXtOqUpPz8/OnToEJdffnk8++yzsXDhwnj11VfjyCOPzJp3ww03xLJly4q1Z0k/701fo5u+7iMi/vOf/2QFCn7wgx9E7969i7X/3LlzizWvSZMmWacITJo0KYqKioq1tjh7f1suXhutWrWKH/zgB/Hggw/G1KlTY+zYsXH++ednzXnhhRdi2LBhZd4bAACQXIICAAAA7Fbq1asX119/faZOp9Nx3XXXlWiPI444Iqt+7733SrT+s88+y3pztXXr1lGvXr0S7bE76NSpU9YbwG+88UapH+kfEdG5c+es+vXXXy/1a+xqeXl5ceqpp8aIESOiffv2mfGVK1fGG2+8Uaw9Ro4cWaJrjho1KqveNKQQsXmY4Iwzzij2/sX9/6ZWrVpx6KGHZuqVK1fGmDFjin2dbWnXrl3UrVs3U7///vtRWFhYKnvvqMMOOyyefvrpuOyyy7LGX3jhhRx1BAAAJJGgAAAAALudPn36xF577ZWp33jjjRL9tu4RRxwRVatWzdQffPDBZm+YbsuTTz6ZVXfp0qXYa3cnjRs3znrTe86cOTFkyJBSv87JJ5+cVT/55JOxZs2aUr9OWahatWr8z//8T9bY9OnTi7X2mWeeKfZ1Fi9enBWoqFSpUnTq1GmzeZueZvDtN923Z0u3idiaE044Iat+6KGHir12W/Ly8uL444/P1GvXrt3s/89cueSSS7Lq4n6fAQAASoOgAAAAALudatWqRf/+/bPGrrvuumL/Nnu1atXi3HPPzRq78cYbi7V29uzZcf/992eNFfeo9t3RFVdckVVfc801sXLlylK9xsEHHxxdu3bN1F9++WXcdtttpXqNspSfn59Vfzu0si0ffvhhvPTSS8Wae/PNN8e6desy9WmnnbbF22N8+zYeERFffPFFsfZ/6aWXYsSIEcWaGxHxs5/9LPLy8jL1k08+WeITEramT58+WXX//v1j3rx5pbL3ztjR7zMAAEBpEBQAAABgt9S7d+9o165dpv7www9j1qxZxV7/i1/8IuvY/EGDBsUDDzywzTWrVq2KXr16Zb0Rfvjhh2e9ib2pbt26RSqVynz069ev2D1WBD/84Q/jwAMPzNSff/559OjRI5YuXVqifRYtWhTPP//8Vp+/9dZbs75ft9xyS9x3330l7nfUqFExduzYEq/bmj//+c/x1VdfFXt+UVFRPP3001ljbdq0Kfb6n/3sZzF16tRtznnxxRfjL3/5S9bYVVddtcW5374lQETEfffdF6tWrdrm/mPGjImLL764GN3+P/vtt19ceOGFmXrDhg3Rs2fP+PTTT4u9x/z587c43q1btzjxxBMz9cKFC+O0006L2bNnl6jHwsLCzb4333jqqafi888/L9F+TzzxRFZdku8zAADAzhIUAAAAYLeUl5e3U79V3r59+/jlL3+ZNXb55ZfHlVdeGYsXL95s/vvvvx9dunTJui971apV429/+9sO97A7yMvLi8GDB0edOnUyY8OGDYtDDjkkHnjggW3eL37JkiUxcODAOP/882PvvfeOe+65Z6tzjznmmM1CFn369IlTTz01hg8fHhs3btziunQ6HV988UXceeedcdRRR0XHjh3j448/LtknuQ39+vWLvffeO3r16hUDBw6MJUuWbHXu559/Ht/73vdi1KhRmbG99torvvvd7xbrWvXr14/58+dHly5dYtCgQZt9zqtWrYrf/e530atXrygqKsqMX3DBBZsd/f+No48+Opo3b56pJ0+eHCeeeOIW3xRfuXJl/OEPf4hu3brF0qVLt3hCwbbcfffd0apVq0w9Z86c6Ny5c9x8881bDVsUFhbGM888EyeffHKcf/75W9378ccfz7odybhx4+KQQw6JP/zhD9sMchQWFsY///nPuOSSS6JZs2bx29/+dovznnvuuWjXrl0cd9xx8Ze//CVmzJix1T0XLVoU11xzTQwYMCAzVqlSpc1uOQEAALAr5W9/CgAAAFRMZ555ZhxzzDHx7rvv7tD62267LcaOHRv//ve/I+K/byrfe++98cADD8TRRx8de+21V6xZsyY+++yzmDJlStbaSpUqxf333x+HHXbYzn4aFV67du3i//7v/6Jnz56xfPnyiPjvLRouu+yy6NOnTxx88MGxzz77RJ06deLrr7+OZcuWxaRJk0r8G9833XRTLFq0KOskgaFDh8bQoUOjbt260b59+2jcuHFUrlw5VqxYEQsXLowJEyaU+q0QNrVmzZoYNGhQDBo0KCIimjdvHq1bt4769etH1apVY9myZfH5559vdhJAXl5ePPLII5sdUb81DzzwQJx33nkxf/786NWrVzRp0iQOP/zwqFu3bixYsCBGjhwZX3/9ddaadu3axb333rvVPfPy8uIPf/hD9OrVKzP2/vvvR7t27eKQQw6JAw44IFKpVMydOzc++OCDWLt2bUT891j9J554Ik499dRi9R4RUa9evXjppZfi5JNPznzvV65cGX379o3+/fvHIYccEvvss0/Url07VqxYEVOnTo2JEydmQg/bOrljjz32iJdffjlOO+20mDt3bkRELF26NH7zm9/EddddF23atImWLVtG3bp1Y+3atbFs2bKYOnVqzJgxI+uWJQ0aNNjqNdLpdAwfPjyGDx8eV1xxRTRs2DDatWsXDRs2jJo1a8bXX38d06ZNi08//TQrqBER8dvf/jbatm1b7K8VAADAzhIUAAAAYLd2xx13RJcuXXZobZUqVWLIkCHx4x//OOuY8A0bNmwzfFCnTp14/PHHo3v37jt03d3RCSecEGPGjInzzz8/xowZkxkvKiqKcePGxbhx47a7R/369bc75957740jjzwy+vTpEytWrMiML1++PIYPH77d9ZUqVYq6detud97OmDlzZsycOXObc+rXrx9PPvlknHTSScXet1evXrFw4cK4+uqrY+PGjbFgwYJ49dVXtzq/Q4cOMXTo0G2++R0Rce6558akSZPipptuyrxpnk6n4+OPP97i6QvVq1ePJ554Ik455ZRi9/6Ntm3bxujRo+Pcc8+NESNGZMY3btxY7NfJ1hx66KExduzY+MEPfhCvv/56ZjydTseECRNiwoQJ292jOK/BbyxevDjefvvtbc7Jz8+P//3f/42bbrqp2PsCAACUBrceAAAAYLd2zDHHxJlnnrnD66tUqRKPP/54jBgxIk488cSoXLnyVuc2btw4fvGLX8TUqVOFBLagVatW8cEHH8S//vWvOOGEE6Jq1arbXdOmTZvo06dPjBgxIp5//vliXeeHP/xhzJo1K2677bY44IADtju/WrVq8d3vfjfuvPPOmDVrVvTo0aNY1ymOYcOGRd++faNz585RrVq17c7fZ5994rrrrospU6bE6aefXuLr9enTJ95+++046aSTIi8vb4tz9txzz7jzzjtj1KhRxb49wI033hivvvpqdOjQYatz6tSpE717945PP/00evbsWeLev9G0adN4++2341//+ld07dp1uycq7LvvvvGLX/wiHnzwwe3uXVBQEK+99lq8/fbb0b1796hZs+Z21+y7775x6aWXxpAhQ7JCLt929913xz333BOnnXZascIE33ytPvnkEyEBAAAgJ1Lpb5+fBgAAAGxTYWFhjBgxIubMmRNfffVVVK1aNRo3bhxt2rSJww8/PFKpVK5brDDWrFkTo0aNipkzZ8bixYtj1apVUbNmzahfv360atUq2rRpEw0bNtzp68ybNy8++OCDWLhwYSxZsiQ2btwYtWvXjqZNm8YBBxwQBxxwQFSpUqUUPqNtW79+fXz22WcxderUmDt3bhQWFkZERO3atWPPPfeMQw45JFq1alXs11C3bt3iP//5T6be9J945s2bF6NGjYo5c+ZEYWFhFBQUxIEHHhgdO3aMSpV2/HdHJk2aFCNHjowFCxZEOp2OJk2axF577RXHHHNMscIQJVVYWBjvvvtuzJkzJxYvXhxFRUVRp06d2GeffeLggw+OFi1a7PDeGzZsiDFjxsSUKVNi8eLFUVhYGDVq1Ii6detGy5Yt/7/27tA2YiAIoOiGuwC3YMn9N2Mjd2BssGFhp1PIRdF/r4DVgIVfM2PbtrGu66/enHOO8zzHcRzjuq5x3/d4nmcsy/JzjmDf94/8OQAAgFeEAgAAAAD/0LtQAAAAAF5xegAAAAAAAAAAQoQCAAAAAAAAABAiFAAAAAAAAACAEKEAAAAAAAAAAIQIBQAAAAAAAAAgRCgAAAAAAAAAACFCAQAAAAAAAAAI+Zpzzr8eAgAAAAAAAAD4DBsFAAAAAAAAACBEKAAAAAAAAAAAIUIBAAAAAAAAAAgRCgAAAAAAAABAiFAAAAAAAAAAAEKEAgAAAAAAAAAQIhQAAAAAAAAAgBChAAAAAAAAAACECAUAAAAAAAAAIEQoAAAAAAAAAAAhQgEAAAAAAAAACBEKAAAAAAAAAECIUAAAAAAAAAAAQoQCAAAAAAAAABAiFAAAAAAAAACAEKEAAAAAAAAAAIQIBQAAAAAAAAAgRCgAAAAAAAAAACFCAQAAAAAAAAAIEQoAAAAAAAAAQIhQAAAAAAAAAABChAIAAAAAAAAAECIUAAAAAAAAAIAQoQAAAAAAAAAAhAgFAAAAAAAAACBEKAAAAAAAAAAAIUIBAAAAAAAAAAgRCgAAAAAAAABAyDeM7krMFgePVAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -1117,7 +1117,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -1126,7 +1126,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1202,7 +1202,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1235,7 +1235,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 30, @@ -1244,7 +1244,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1572,7 +1572,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1618,7 +1618,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 36, @@ -1627,7 +1627,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1891,9 +1891,9 @@ "metadata": { "celltoolbar": "Tags", "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1905,7 +1905,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 848d7864..3033b7c1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,7 +10,7 @@ authors = [ ] description = "A package for solving matching games" readme = "README.md" -requires-python = ">=3.7" +requires-python = ">=3.10" license = {text = "MIT License"} keywords = [ "game-theory", @@ -30,7 +30,7 @@ classifiers = [ ] dependencies = [ "numpy>=1.21.6", - "scipy>=1.11.3" + "scipy>=1.11.3", ] dynamic = ["version"] @@ -50,13 +50,8 @@ docs = [ "PyYAML>=6", "quartodoc>=0.5.0; python_version>'3.8'", ] -lint = [ - "black[jupyter]>=22.6.0,<23", - "ruff>=0.1.1", -] -dev = [ - "matching[docs,lint,test]", -] +lint = ["ruff<1.0"] +dev = ["matching[docs,lint,test]", "pre-commit"] [project.urls] homepage = "https://github.com/daffidwilde/matching" @@ -66,26 +61,25 @@ changelog = "https://github.com/daffidwilde/matching/blob/main/CHANGES.md" [tool.setuptools.dynamic] version = {attr = "matching.__version__"} -[tool.black] -line-length = 79 - [tool.coverage.report] omit = ["src/**/__init__.py"] [tool.ruff] extend-include = ["*.ipynb"] +line-length = 79 + +[tool.ruff.lint] extend-select = ["D", "I", "W"] ignore = ["D105", "D107", "D202"] -line-length = 79 -[tool.ruff.isort] +[tool.ruff.lint.isort] known-first-party = ["matching"] -[tool.ruff.per-file-ignores] +[tool.ruff.lint.per-file-ignores] "docs/*" = ["D100", "D103", "E402"] "tests/**/*.py" = ["D104", "D401", "E741"] "src/**/*.py" = ["D105", "D107"] "src/matching/base.py" = ["D401"] -[tool.ruff.pydocstyle] +[tool.ruff.lint.pydocstyle] convention = "numpy" diff --git a/src/matching/algorithms/__init__.py b/src/matching/algorithms/__init__.py index 56b2fffd..853ea60a 100644 --- a/src/matching/algorithms/__init__.py +++ b/src/matching/algorithms/__init__.py @@ -1,13 +1,11 @@ """Top-level imports for the `matching.algorithms` subpackage.""" from .hospital_resident import hospital_resident -from .stable_marriage import stable_marriage from .stable_roommates import stable_roommates from .student_allocation import student_allocation __all__ = [ "hospital_resident", - "stable_marriage", "stable_roommates", "student_allocation", ] diff --git a/src/matching/algorithms/stable_marriage.py b/src/matching/algorithms/stable_marriage.py deleted file mode 100644 index 39cfe868..00000000 --- a/src/matching/algorithms/stable_marriage.py +++ /dev/null @@ -1,64 +0,0 @@ -"""Functions for the SM algorithms.""" - -from .util import _delete_pair, _match_pair - - -def _unmatch_pair(suitor, reviewer): - """Unmatch a (suitor, reviewer) pair.""" - - suitor._unmatch() - reviewer._unmatch() - - -def stable_marriage(suitors, reviewers, optimal="suitor"): - """Solve an instance of SM. - - This function uses an extended version of the original Gale-Shapley - algorithm that makes use of the inherent structures of SM instances. - A unique, stable and optimal matching is found for any valid set of - suitors and reviewers. The optimality of the matching is with - respect to one party and is subsequently the worst stable matching - for the other. - - Parameters - ---------- - suitors : list of Player - The suitors in the game. Each must rank all of those in - ``reviewers``. - reviewers : list of Player - The reviewers in the game. Each must rank all of those in - ``suitors``. - optimal : str, optional - Which party the matching should be optimised for. Must be one of - ``"suitor"`` and ``"reviewer"``. Defaults to the former. - - Returns - ------- - matching : Matching - A dictionary-like object where the keys are given by the members of - ``suitors``, and the values are their match in ``reviewers``. - """ - - if optimal.lower() == "reviewer": - suitors, reviewers = reviewers, suitors - - free_suitors = suitors[:] - while free_suitors: - suitor = free_suitors.pop() - reviewer = suitor.get_favourite() - - if reviewer.matching: - current_match = reviewer.matching - _unmatch_pair(current_match, reviewer) - free_suitors.append(current_match) - - _match_pair(suitor, reviewer) - - successors = reviewer.get_successors() - for successor in successors: - _delete_pair(successor, reviewer) - - if optimal.lower() == "reviewer": - suitors, reviewers = reviewers, suitors - - return {s: s.matching for s in suitors} diff --git a/src/matching/convert.py b/src/matching/convert.py index f2aac697..80220591 100644 --- a/src/matching/convert.py +++ b/src/matching/convert.py @@ -4,19 +4,22 @@ from scipy.stats import rankdata -def preference_to_rank(preference, others): - """Convert a preference dictionary to a rank array.""" +def preference_to_rank(preferences, others): + """Convert a preference list dictionary to a rank array.""" - rank = np.array( - [[others.index(o) for o in prefs] for prefs in preference.values()] - ) + sorted_preferences = sorted(preferences.items(), key=lambda x: x[0]) + sorted_others = sorted(others) + ranks = [ + [prefs.index(o) if o in prefs else len(others) for o in sorted_others] + for _, prefs in sorted_preferences + ] - return rank + return np.array(ranks) def utility_to_rank(utility): """Convert a utility array to a rank array.""" - rank = rankdata(utility, method="ordinal", axis=1, nan_policy="omit") + rank = rankdata(-utility, method="ordinal", axis=1, nan_policy="omit") return rank - 1 diff --git a/src/matching/games/stable_marriage.py b/src/matching/games/stable_marriage.py index a24e3ece..b0ff8d54 100644 --- a/src/matching/games/stable_marriage.py +++ b/src/matching/games/stable_marriage.py @@ -1,192 +1,304 @@ """The SM game class and supporting functions.""" -import copy +import warnings -from matching import BaseGame, Player, SingleMatching -from matching.algorithms import stable_marriage -from matching.exceptions import MatchingError +import numpy as np +from matching import convert +from matching.matchings import SingleMatching -class StableMarriage(BaseGame): - """Solver for the stable marriage problem (SM). + +class StableMarriage: + """ + Solver for the stable marriage problem (SM). Parameters ---------- - suitors : list of Player - The suitors in the game. Each suitor must rank all elements in - ``reviewers``. - reviewers : list of Player - The reviewers in the game. Each reviewer must rank all elements - in ``suitors``. + suitor_ranks : np.ndarray + The rank matrix of all reviewers by the suitors. + reviewer_ranks : np.ndarray + The rank matrix of all suitors by the reviewers. Attributes ---------- + num_suitors : int + Number of suitors. + num_reviewers : int + Number of reviewers. matching : SingleMatching or None Once the game is solved, a matching is available. This uses the - suitors and reviewers as keys and values, respectively, in a - ``SingleMatching`` object. Initialises as ``None``. - blocking_pairs : list of (Player, Player) - The suitor-reviewer pairs that both prefer one another to their - current match. Initialises as ``None``. + indices of the reviewer and suitor rank matrices as keys and + values, respectively, in a `SingleMatching` object. + Initialises as `None`. """ - def __init__(self, suitors, reviewers): - suitors, reviewers = copy.deepcopy([suitors, reviewers]) - self.suitors = suitors - self.reviewers = reviewers + def __init__(self, suitor_ranks, reviewer_ranks): + self.suitor_ranks = suitor_ranks.copy() + self.reviewer_ranks = reviewer_ranks.copy() - super().__init__() - self.check_inputs() + self.num_suitors = len(suitor_ranks) + self.num_reviewers = len(reviewer_ranks) + self.matching = None + self._preference_lookup = None - @classmethod - def create_from_dictionaries(cls, suitor_prefs, reviewer_prefs): - """Create an instance of SM from two preference dictionaries.""" + self.check_input_validity() - suitors, reviewers = _make_players(suitor_prefs, reviewer_prefs) - game = cls(suitors, reviewers) + @classmethod + def from_utilities(cls, suitor_utils, reviewer_utils): + """ + Create an instance of SM from utility matrices. + + Higher utilities indicate higher preferences. If there are any + ties, they are broken in order of appearance. + + Parameters + ---------- + suitor_utils : np.ndarray + Suitor utility matrix. + reviewer_utils : np.ndarray + Reviewer utility matrix. + + Returns + ------- + game : StableMarriage + An instance of SM with utilities resolved as rank matrices. + """ - return game + suitor_ranks = convert.utility_to_rank(suitor_utils) + reviewer_ranks = convert.utility_to_rank(reviewer_utils) - def solve(self, optimal="suitor"): - """Solve the instance of SM. Return the matching. + return cls(suitor_ranks, reviewer_ranks) - The party optimality can be controlled using the ``optimal`` - parameter. + @classmethod + def from_preferences(cls, suitor_prefs, reviewer_prefs): + """ + Create an instance of SM from preference list dictionaries. + + Each dictionary contains a strict ordering of the other side by + each player. The ranking is taken by the order of the preference + list. + + Parameters + ---------- + suitor_prefs : dict + Suitor preference lists. + reviewer_prefs : dict + Reviewer preference lists. + + Returns + ------- + game : StableMarriage + An instance of SM with preference lists resolved as rank + matrices. """ - self.matching = SingleMatching( - stable_marriage(self.suitors, self.reviewers, optimal) - ) - return self.matching + suitors, reviewers = sorted(suitor_prefs), sorted(reviewer_prefs) - def check_validity(self): - """Check whether the current matching is valid.""" + suitor_ranks = convert.preference_to_rank(suitor_prefs, reviewers) + reviewer_ranks = convert.preference_to_rank(reviewer_prefs, suitors) - unmatched_issues = self._check_for_unmatched_players() - not_in_matching_issues = self._check_for_players_not_in_matching() - inconsistency_issues = self._check_for_inconsistent_matches() + game = cls(suitor_ranks, reviewer_ranks) + game._preference_lookup = {"suitors": suitors, "reviewers": reviewers} - if unmatched_issues or not_in_matching_issues or inconsistency_issues: - raise MatchingError( - unmatched_players=unmatched_issues, - players_not_in_matching=not_in_matching_issues, - inconsistent_matches=inconsistency_issues, - ) + return game - return True + def _check_number_of_players(self): + """ + Check whether the player sets are the same size. - def check_stability(self): - """Check for the existence of any blocking pairs.""" + Warns + ----- + UserWarning + If the sizes of the player sets do not match. + """ - blocking_pairs = [] - for suitor in self.suitors: - for reviewer in self.reviewers: - if suitor.prefers( - reviewer, suitor.matching - ) and reviewer.prefers(suitor, reviewer.matching): - blocking_pairs.append((suitor, reviewer)) + ns, nr = self.num_suitors, self.num_reviewers + if ns != nr: + warnings.warn( + f"Number of suitors ({ns}) and reviewers ({nr}) " + "do not match. Your matching will not be truly stable.", + UserWarning, + ) - self.blocking_pairs = blocking_pairs - return not any(blocking_pairs) + def _check_player_ranks(self, player, ranks, side): + """ + Check that a player has made a strict ranking of the other side. + + Parameters + ---------- + player : int + Player to check. + ranks : np.ndarray + The player's ranking. + side : str + Name of the side to which the player belongs. + + Warns + ----- + UserWarning + If the player has not made a strict and unique ranking of + the other side in the game. + """ - def _check_for_unmatched_players(self): - """Check everyone has a match.""" + others = "suitors" if side == "reviewer" else "reviewers" + num_others = getattr(self, f"num_{others}") + if not np.array_equal(np.sort(ranks), np.arange(num_others)): + warnings.warn( + f"{side.title()} {player} has not strictly ranked " + f"all {num_others} {others}: {ranks}. " + "You may not be able to find a stable matching.", + UserWarning, + ) - issues = [] - for player in self.suitors + self.reviewers: - issue = player.check_if_match_is_unacceptable(unmatched_okay=False) - if issue: - issues.append(issue) + def check_input_validity(self): + """ + Determine whether this game instance is valid or not. - return issues + Invalid games can still be solved, but the matching will not be + truly stable in the absence of blocking pairs. - def _check_for_players_not_in_matching(self): - """Check that everyone appears in the matching.""" + Warns + ----- + UserWarning + If (a) the player sets are not the same size; or (b) any + player has not made a strict, exhaustive, and unique ranking + of the players on the other side of the matching. + """ - players_in_matching = set(self.matching.keys()) | set( - self.matching.values() - ) + self._check_number_of_players() - issues = [] - for player in self.suitors + self.reviewers: - if player not in players_in_matching: - issues.append(f"{player} does not appear in matching.") + for suitor, ranks in enumerate(self.suitor_ranks): + self._check_player_ranks(suitor, ranks, "suitor") - return issues + for reviewer, ranks in enumerate(self.reviewer_ranks): + self._check_player_ranks(reviewer, ranks, "reviewer") - def _check_for_inconsistent_matches(self): - """Check the matching is consistent with the players'.""" + def _invert_player_sets(self): + """ + Invert the attributes associated with each set of players. - issues = [] - for suitor, reviewer in self.matching.items(): - if suitor.matching != reviewer: - issues.append( - f"{suitor} is matched to {suitor.matching} but the " - f"matching says they should be matched to {reviewer}." - ) + That is, `suitor_ranks` and `reviewer_ranks` switch. As do + `num_suitors` and `num_reviewers`. + """ - return issues + self.suitor_ranks, self.reviewer_ranks = ( + self.reviewer_ranks, + self.suitor_ranks, + ) + self.num_suitors, self.num_reviewers = ( + self.num_reviewers, + self.num_suitors, + ) - def check_inputs(self): - """Raise an error if any of the game's rules do not hold.""" + def _stable_marriage(self): + """ + Execute the algorithm for SM given some rankings. - self._check_num_players() - for suitor in self.suitors: - self._check_player_ranks(suitor) - for reviewer in self.reviewers: - self._check_player_ranks(reviewer) + Returns + ------- + matching : dict + Solution to the game instance. + """ - def _check_num_players(self): - """Check that the number of suitors and reviewers are equal.""" + matching = {} + suitor_ranks, reviewer_ranks = self.suitor_ranks, self.reviewer_ranks + free_suitors = list(range(self.num_suitors)) - if len(self.suitors) != len(self.reviewers): - raise ValueError( - "There must be an equal number of suitors and reviewers." - ) + while free_suitors: + suitor = free_suitors.pop() + reviewer = suitor_ranks[suitor].argmin() + reviewer_rank = reviewer_ranks[reviewer] - return True + current = matching.get(reviewer) + if ( + current is not None + and (suitor_ranks[current] < self.num_reviewers).any() + ): + free_suitors.append(current) - def _check_player_ranks(self, player): - """Check that a player has ranked all of the other group.""" + matching[reviewer] = suitor - others = self.reviewers if player in self.suitors else self.suitors - if set(player.prefs) != set(others): - raise ValueError( - "Every player must rank each name from the other group. " - f"{player}: {player.prefs} != {others}" - ) + successors = np.where(reviewer_rank > reviewer_rank[suitor]) + suitor_ranks[successors, reviewer] = self.num_reviewers + reviewer_rank[successors] = self.num_reviewers - return True + return matching + def _convert_matching_to_preferences(self): + """ + Replace the rank indices with preference terms in a matching. -def _make_players(suitor_prefs, reviewer_prefs): - """Make a set of suitors and reviewers from two dictionaries.""" + This internal function is included for users who wish to create + a matching from a set of preference list dictionaries. - suitor_dict, reviewer_dict = _make_instances(suitor_prefs, reviewer_prefs) + Attributes + ---------- + matching : SingleMatching + The converted matching instance. + """ - for suitor_name, suitor in suitor_dict.items(): - prefs = [reviewer_dict[name] for name in suitor_prefs[suitor_name]] - suitor.set_prefs(prefs) + converted = {} + suitors, reviewers = self._preference_lookup.values() + for reviewer, suitor in self.matching.items(): + converted[reviewers[reviewer]] = suitors[suitor] - for reviewer_name, reviewer in reviewer_dict.items(): - prefs = [suitor_dict[name] for name in reviewer_prefs[reviewer_name]] - reviewer.set_prefs(prefs) + self.matching = SingleMatching( + converted, valid=self.matching.valid, stable=self.matching.stable + ) - suitors = list(suitor_dict.values()) - reviewers = list(reviewer_dict.values()) + def solve(self, optimal="suitor"): + """ + Solve the instance of SM. + + This method uses an extended version of the Gale-Shapley + algorithm that makes use of the inherent structures of SM + instances. The algorithm finds a unique, stable and optimal + matching for any valid set of suitors and reviewers. + + The optimality of the matching is with respect to one party and + is subsequently the worst stable matching for the other party. + + Parameters + ---------- + optimal : {"suitor", "reviewer"}, default "suitor" + Party for whom to optimise the matching. Must be one of + `"suitor"` or `"reviewer"`. Default is `"suitor"`. + + Raises + ------ + ValueError + If `optimal` is anything other than the permitted values. + + Returns + ------- + matching : SingleMatching + A dictionary-like object containing the matching. The keys + correspond to the reviewers in the instance, while the + values are the suitors. + """ - return suitors, reviewers + if optimal not in ("suitor", "reviewer"): + raise ValueError( + "Invalid choice for `optimal`. " + f'Must be "suitor" or "reviewer", not "{optimal}".' + ) + + keys, values = "reviewers", "suitors" + if optimal == "reviewer": + self._invert_player_sets() + keys, values = values, keys -def _make_instances(suitor_prefs, reviewer_prefs): - """Create ``Player`` instances for the names in each dictionary.""" + matching = SingleMatching( + self._stable_marriage(), keys=keys, values=values + ) - suitor_dict, reviewer_dict = {}, {} - for suitor_name in suitor_prefs: - suitor = Player(name=suitor_name) - suitor_dict[suitor_name] = suitor - for reviewer_name in reviewer_prefs: - reviewer = Player(name=reviewer_name) - reviewer_dict[reviewer_name] = reviewer + if optimal == "reviewer": + matching = matching.invert() + self._invert_player_sets() - return suitor_dict, reviewer_dict + self.matching = matching + if self._preference_lookup: + self._convert_matching_to_preferences() + + return self.matching diff --git a/src/matching/matchings/__init__.py b/src/matching/matchings/__init__.py new file mode 100644 index 00000000..c7b049ed --- /dev/null +++ b/src/matching/matchings/__init__.py @@ -0,0 +1,6 @@ +"""Classes for different types of matchings.""" + +from .multiple import MultipleMatching +from .single import SingleMatching + +__all__ = ["MultipleMatching", "SingleMatching"] diff --git a/src/matching/matchings.py b/src/matching/matchings/multiple.py similarity index 51% rename from src/matching/matchings.py rename to src/matching/matchings/multiple.py index 8afc6343..da253c3e 100644 --- a/src/matching/matchings.py +++ b/src/matching/matchings/multiple.py @@ -1,37 +1,9 @@ -"""A collection of dictionary-like objects for storing matchings.""" +"""Classes for handling multiple match matchings.""" -from matching import BaseMatching +from matching.base import BaseMatching from matching.players import Player -class SingleMatching(BaseMatching): - """Matching class for games with singular matches like SM or SR. - - Parameters - ---------- - dictionary - A dictionary comprised of ``Player, Optional[Player]`` pairs. - """ - - def __init__(self, dictionary): - super().__init__(dictionary) - - def __setitem__(self, player, new): - """Set a player's new match and match them to the player, too. - - First check if the player and match are valid and present. - """ - - self._check_player_in_keys(player) - self._check_new_valid_type(new, (type(None), Player)) - - player.matching = new - if isinstance(new, Player): - new.matching = player - - self._data[player] = new - - class MultipleMatching(BaseMatching): """Matching class for games with multiple matches like HR or SA. diff --git a/src/matching/matchings/single.py b/src/matching/matchings/single.py new file mode 100644 index 00000000..73f56486 --- /dev/null +++ b/src/matching/matchings/single.py @@ -0,0 +1,65 @@ +"""Classes for handling single match matchings.""" + + +class SingleMatching(dict): + """ + Dictionary-like object for solutions to games with singular matches. + + Parameters + ---------- + dictionary : dict + Dictionary of matched up pairs. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + valid : bool or None + Validity of the matching. Initialises as `None`. + stable : bool or None + Stability of the matching. Initialises as `None`. + """ + + def __init__( + self, + dictionary=None, + *, + keys="reviewers", + values="suitors", + valid=None, + stable=None, + ): + super().__init__(dictionary or {}) + + self.keys_ = keys + self.values_ = values + self.valid = valid + self.stable = stable + + def __repr__(self): + return ( + f"SingleMatching({super().__repr__()}, " + f'keys="{self.keys_}", values="{self.values_}")' + ) + + def __eq__(self, other): + return super().__eq__(other) and vars(self) == vars(other) + + def invert(self): + """ + Invert the keys and values in the dictionary. + + Creates a new matching instance with keys and values reversed, + and passes over the validity and stability attributes. + + Returns + ------- + inverted : SingleMatching + An inverted matching. + """ + return SingleMatching( + {val: key for key, val in self.items()}, + keys=self.values_, + values=self.keys_, + valid=self.valid, + stable=self.stable, + ) diff --git a/tests/hospital_resident/data/issue_159.json b/tests/hospital_resident/data/issue_159.json index 837041c8..94f9d4b7 100644 --- a/tests/hospital_resident/data/issue_159.json +++ b/tests/hospital_resident/data/issue_159.json @@ -153,4 +153,4 @@ "98": [1, 28, 48, 21], "99": [] } -} \ No newline at end of file +} diff --git a/tests/hospital_resident/test_algorithm.py b/tests/hospital_resident/test_algorithm.py index b1c6426a..204ef6c6 100644 --- a/tests/hospital_resident/test_algorithm.py +++ b/tests/hospital_resident/test_algorithm.py @@ -62,7 +62,7 @@ def test_hospital_optimal(players_): assert set(hospitals) == set(matching.keys()) for hospital, matches in matching.items(): - old_idx = -np.infty + old_idx = -np.inf for resident in matches: idx = hospital.prefs.index(resident) assert idx >= old_idx diff --git a/tests/matchings/test_single.py b/tests/matchings/test_single.py new file mode 100644 index 00000000..a9085e2c --- /dev/null +++ b/tests/matchings/test_single.py @@ -0,0 +1,106 @@ +"""Unit tests for the SingleMatching class.""" + +from hypothesis import given +from hypothesis import strategies as st + +from matching.matchings import SingleMatching + + +@st.composite +def st_single_params(draw, min_size=2, max_size=5): + """Create a parameter set for a SingleMatching instance.""" + + size = draw(st.integers(min_size, max_size)) + midpoint = size // 2 + players = list(range(size)) + keys, values = players[:midpoint], players[midpoint:] + dictionary = draw(st.sampled_from((None, dict(zip(keys, values))))) + + keys = draw(st.text()) + values = draw(st.text()) + valid = draw(st.sampled_from((None, False, True))) + stable = draw(st.sampled_from((None, False, True))) + + params = dict( + dictionary=dictionary, + keys=keys, + values=values, + valid=valid, + stable=stable, + ) + + return params + + +@st.composite +def st_singles(draw, min_size=2, max_size=5): + """Create a SingleMatching instance.""" + + params = draw(st_single_params(min_size, max_size)) + + return SingleMatching(**params) + + +@given(st_single_params()) +def test_init(params): + """Check that a SingleMatching can be created correctly.""" + + matching = SingleMatching(**params) + + assert isinstance(matching, SingleMatching) + assert isinstance(matching, dict) + + dictionary = params["dictionary"] or {} + assert matching.items() == dictionary.items() + assert vars(matching) == { + "keys_": params["keys"], + "values_": params["values"], + "valid": params["valid"], + "stable": params["stable"], + } + + +@given(st_singles()) +def test_repr(matching): + """Check that the string representation of a matching is correct.""" + + repr_ = repr(matching) + + assert isinstance(repr_, str) + assert repr_.startswith("SingleMatching") + assert str(dict(matching)) in repr_ + assert matching.keys_ in repr_ + assert matching.values_ in repr_ + + +@given(st_single_params()) +def test_eq(params): + """Check the equivalence dunder works as expected.""" + + matching1 = SingleMatching(**params) + matching2 = SingleMatching(**params) + + assert matching1 == matching2 + + if params["dictionary"] is not None: + key = next(iter(params["dictionary"].keys())) + matching2[key] = None + + assert matching1 != matching2 + assert vars(matching1) == vars(matching2) + + +@given(st_singles()) +def test_invert(matching): + """Check the matching inverter works as it should.""" + + inverted = matching.invert() + + assert isinstance(inverted, SingleMatching) + assert set(inverted.items()) == set( + (val, key) for key, val in matching.items() + ) + assert inverted.keys_ == matching.values_ + assert inverted.values_ == matching.keys_ + assert inverted.valid == matching.valid + assert inverted.stable == matching.stable diff --git a/tests/stable_marriage/strategies.py b/tests/stable_marriage/strategies.py new file mode 100644 index 00000000..97616e04 --- /dev/null +++ b/tests/stable_marriage/strategies.py @@ -0,0 +1,113 @@ +"""Composite strategies for SM unit tests.""" + +from unittest import mock + +import numpy as np +from hypothesis import strategies as st +from hypothesis.extra import numpy as st_numpy + +from matching.games import StableMarriage + + +def mocked_game(suitor_ranks, reviewer_ranks): + """Create an instance of SM that mocks the input validator.""" + + with mock.patch( + "matching.games.StableMarriage.check_input_validity" + ) as validator: + game = StableMarriage(suitor_ranks, reviewer_ranks) + + validator.assert_called_once_with() + + return game + + +@st.composite +def st_single_ranks(draw, size): + """Create a single rank matrix.""" + + rank = draw( + st.lists(st.permutations(range(size)), min_size=size, max_size=size) + ) + + return np.array(rank) + + +@st.composite +def st_ranks(draw, pmin=1, pmax=5): + """Create a set of rankings for a test.""" + + size = draw(st.integers(pmin, pmax)) + suitor_ranks = draw(st_single_ranks(size)) + reviewer_ranks = draw(st_single_ranks(size)) + + return suitor_ranks, reviewer_ranks + + +@st.composite +def st_player_ranks(draw, pmin=1, pmax=5): + """Create a set of ranks, and choose a player from it.""" + + suitor_ranks, reviewer_ranks = draw(st_ranks(pmin, pmax)) + side = draw(st.sampled_from(("suitor", "reviewer"))) + side_ranks = suitor_ranks if side == "suitor" else reviewer_ranks + player, ranks = draw(st.sampled_from(list(enumerate(side_ranks)))) + + return suitor_ranks, reviewer_ranks, player, ranks, side + + +@st.composite +def st_single_utilities(draw, size): + """Create a single utility matrix.""" + + utility = draw( + st_numpy.arrays( + dtype=float, + elements=st.floats(0, 1, allow_nan=False), + shape=(size, size), + ) + ) + + return utility + + +@st.composite +def st_utilities(draw, pmin=1, pmax=5): + """Create a set of utility matrices.""" + + size = draw(st.integers(pmin, pmax)) + suitor_utility = draw(st_single_utilities(size)) + reviewer_utility = draw(st_single_utilities(size)) + + return suitor_utility, reviewer_utility + + +@st.composite +def st_preferences(draw, pmin=1, pmax=5): + """Create a set of preferences for a test.""" + + size = draw(st.integers(pmin, pmax)) + suitors, reviewers = ( + draw(st.lists(elements, min_size=size, max_size=size, unique=True)) + for elements in (st.integers(), st.text()) + ) + + suitor_prefs = {s: draw(st.permutations(reviewers)) for s in suitors} + reviewer_prefs = {r: draw(st.permutations(suitors)) for r in reviewers} + + return suitor_prefs, reviewer_prefs + + +@st.composite +def st_preference_matchings(draw, pmin=1, pmax=5): + """Create a set of preferences and a matching to go with them.""" + + suitor_prefs, reviewer_prefs = draw(st_preferences(pmin, pmax)) + matching = dict( + zip( + range(len(reviewer_prefs)), + draw(st.permutations(list(range(len(suitor_prefs))))), + ) + ) + + return suitor_prefs, reviewer_prefs, matching diff --git a/tests/stable_marriage/test_algorithm.py b/tests/stable_marriage/test_algorithm.py index 6057ec94..8c4a4782 100644 --- a/tests/stable_marriage/test_algorithm.py +++ b/tests/stable_marriage/test_algorithm.py @@ -1,41 +1,60 @@ """Integration tests for the Stable Marriage Problem algorithm.""" -from matching.algorithms import stable_marriage +import numpy as np +from hypothesis import given -from .util import STABLE_MARRIAGE, make_players +from .strategies import mocked_game, st_ranks -@STABLE_MARRIAGE -def test_suitor_optimal(player_names, seed): - """Test that the suitor-optimal algorithm is suitor-optimal.""" +def _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks): + """Assert that the matching has the right shape and elements.""" - suitors, reviewers = make_players(player_names, seed) - matching = stable_marriage(suitors, reviewers, optimal="suitor") + assert isinstance(matching, dict) - assert set(suitors) == set(matching.keys()) - assert set(reviewers) == set(matching.values()) + assert (np.sort(list(matching.keys())) == np.unique(suitor_ranks)).all() + assert ( + np.sort(list(matching.values())) == np.unique(reviewer_ranks) + ).all() - for suitor, reviewer in matching.items(): - idx = suitor.prefs.index(reviewer) - preferred = suitor.prefs[:idx] - for rev in preferred: - partner = rev.matching - assert rev.prefs.index(suitor) > rev.prefs.index(partner) +@given(st_ranks()) +def test_stable_marriage_suitor_optimal(ranks): + """Test that the SM algorithm is valid and suitor-optimal.""" -@STABLE_MARRIAGE -def test_reviewer_optimal(player_names, seed): - """Test that the reviewer-optimal algorithm is reviewer-optimal.""" + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) - suitors, reviewers = make_players(player_names, seed) - matching = stable_marriage(suitors, reviewers, optimal="reviewer") + matching = game._stable_marriage() - assert set(suitors) == set(matching.keys()) - assert set(reviewers) == set(matching.values()) + _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks) - for suitor, reviewer in matching.items(): - idx = reviewer.prefs.index(suitor) - preferred = reviewer.prefs[:idx] - for suit in preferred: - partner = suit.matching - assert suit.prefs.index(reviewer) > suit.prefs.index(partner) + for reviewer, suitor in matching.items(): + suitor_rank = game.suitor_ranks[suitor] + preferred_reviewers, *_ = np.where(suitor_rank < suitor_rank[reviewer]) + for preferred in preferred_reviewers: + preferred_rank = game.reviewer_ranks[preferred] + partner = matching[preferred] + assert preferred_rank[suitor] > preferred_rank[partner] + + +@given(st_ranks()) +def test_stable_marriage_reviewer_pessimal(ranks): + """Test that the SM algorithm is valid and reviewer-pessimal.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) + + matching = game._stable_marriage() + + _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks) + + for reviewer, suitor in matching.items(): + reviewer_rank = game.reviewer_ranks[reviewer] + lesser_suitors, *_ = np.where(reviewer_rank > reviewer_rank[suitor]) + + for lesser in lesser_suitors: + lesser_rank = game.suitor_ranks[lesser] + partner = next( + rev for rev, sui in matching.items() if sui == lesser + ) + assert lesser_rank[partner] < lesser_rank[reviewer] diff --git a/tests/stable_marriage/test_examples.py b/tests/stable_marriage/test_examples.py index 496d8a59..18c1cd2d 100644 --- a/tests/stable_marriage/test_examples.py +++ b/tests/stable_marriage/test_examples.py @@ -1,7 +1,9 @@ """A collection of example tests for SM.""" -from matching import Player -from matching.algorithms import stable_marriage +import numpy as np +import pytest + +from matching.games import StableMarriage def test_pride_and_prejudice(): @@ -10,56 +12,58 @@ def test_pride_and_prejudice(): This example appears in the SM Discussion documentation. """ - suitors = [ - Player(name="Bingley"), - Player(name="Collins"), - Player(name="Darcy"), - Player(name="Wickham"), - ] - - reviewers = [ - Player(name="Charlotte"), - Player(name="Elizabeth"), - Player(name="Jane"), - Player(name="Lydia"), - ] - - bingley, collins, darcy, wickham = suitors - charlotte, elizabeth, jane, lydia = reviewers - - bingley.set_prefs([jane, elizabeth, lydia, charlotte]) - collins.set_prefs([jane, elizabeth, lydia, charlotte]) - darcy.set_prefs([elizabeth, jane, charlotte, lydia]) - wickham.set_prefs([lydia, jane, elizabeth, charlotte]) - - charlotte.set_prefs([bingley, darcy, collins, wickham]) - elizabeth.set_prefs([wickham, darcy, bingley, collins]) - jane.set_prefs([bingley, wickham, darcy, collins]) - lydia.set_prefs([bingley, wickham, darcy, collins]) - - matching = stable_marriage(suitors, reviewers) - assert matching == { - bingley: jane, - collins: charlotte, - darcy: elizabeth, - wickham: lydia, + suitor_preferences = { + "B": ("J", "E", "L", "C"), + "C": ("J", "E", "L", "C"), + "D": ("E", "J", "C", "L"), + "W": ("L", "J", "E", "C"), + } + reviewer_preferences = { + "C": ("B", "D", "C", "W"), + "E": ("W", "D", "B", "C"), + "J": ("B", "W", "D", "C"), + "L": ("B", "W", "D", "C"), } + game = StableMarriage.from_preferences( + suitor_preferences, reviewer_preferences + ) + matching = game.solve() + + assert dict(matching) == {"J": "B", "C": "C", "E": "D", "L": "W"} + def test_readme_example(): """Verify the example used in the README.""" - suitors = [Player(name="A"), Player(name="B"), Player(name="C")] - reviewers = [Player(name="D"), Player(name="E"), Player(name="F")] - (A, B, C), (D, E, F) = suitors, reviewers + suitor_preferences = { + "A": ["D", "E", "F"], + "B": ["D", "F", "E"], + "C": ["F", "D", "E"], + } + reviewer_preferences = { + "D": ["B", "C", "A"], + "E": ["A", "C", "B"], + "F": ["C", "B", "A"], + } + + game = StableMarriage.from_preferences( + suitor_preferences, reviewer_preferences + ) + matching = game.solve() + + assert dict(matching) == {"E": "A", "D": "B", "F": "C"} + + +def test_matchingr_example(): + """Test the example from the MatchingR vignette.""" + + uM = np.array([[1.0, 0.5, 0.0], [0.5, 0.0, 0.5]]) + uW = np.array([[0.0, 1.0], [0.5, 0.0], [1.0, 0.5]]) - A.set_prefs([D, E, F]) - B.set_prefs([D, F, E]) - C.set_prefs([F, D, E]) + with pytest.warns(UserWarning, match="do not match"): + game = StableMarriage.from_utilities(uM, uW) - D.set_prefs([B, C, A]) - E.set_prefs([A, C, B]) - F.set_prefs([C, B, A]) + matching = game.solve() - matching = stable_marriage(suitors, reviewers) - assert matching == {A: E, B: D, C: F} + assert dict(matching) == {0: 1, 1: 0} diff --git a/tests/stable_marriage/test_game.py b/tests/stable_marriage/test_game.py new file mode 100644 index 00000000..7881353b --- /dev/null +++ b/tests/stable_marriage/test_game.py @@ -0,0 +1,316 @@ +"""Unit tests for the StableMarriage class.""" + +import warnings +from unittest import mock + +import numpy as np +import pytest +from hypothesis import given +from hypothesis import strategies as st + +from matching.games import StableMarriage +from matching.matchings import SingleMatching + +from .strategies import ( + mocked_game, + st_player_ranks, + st_preference_matchings, + st_preferences, + st_ranks, + st_utilities, +) + + +@given(st_ranks()) +def test_init(ranks): + """Test for correct instantiation given some rankings.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(suitor_ranks, reviewer_ranks) + + assert (game.suitor_ranks == suitor_ranks).all() + assert (game.reviewer_ranks == reviewer_ranks).all() + + assert game.num_suitors == len(suitor_ranks) + assert game.num_reviewers == len(reviewer_ranks) + assert game.matching is None + assert game._preference_lookup is None + + +@given(st_utilities()) +def test_from_utilities(utilities): + """Test the utility matrix builder.""" + + suitor_utility, reviewer_utility = utilities + + with ( + mock.patch( + "matching.games.StableMarriage.check_input_validity" + ) as validator, + mock.patch("matching.convert.utility_to_rank") as ranker, + ): + effects = (suitor_utility.argsort(), reviewer_utility.argsort()) + ranker.side_effect = list(effects) + game = StableMarriage.from_utilities(suitor_utility, reviewer_utility) + + assert isinstance(game, StableMarriage) + assert (game.suitor_ranks == effects[0]).all() + assert (game.reviewer_ranks == effects[1]).all() + + assert game.num_suitors == len(suitor_utility) + assert game.num_reviewers == len(reviewer_utility) + assert game.matching is None + assert game._preference_lookup is None + + assert ranker.call_count == 2 + for call, utility in zip(ranker.call_args_list, utilities): + arg, *_ = call.args + assert np.array_equal(arg, utility) + + validator.assert_called_once_with() + + +@given(st_preferences()) +def test_from_preferences(preferences): + """Test the preference list builder.""" + + suitor_prefs, reviewer_prefs = preferences + + with ( + mock.patch( + "matching.games.StableMarriage.check_input_validity" + ) as validator, + mock.patch("matching.convert.preference_to_rank") as ranker, + ): + effects = ( + np.array(list(suitor_prefs.values())), + np.array(list(reviewer_prefs.values())), + ) + ranker.side_effect = list(effects) + game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs) + + assert isinstance(game, StableMarriage) + assert (game.suitor_ranks == effects[0]).all() + assert (game.reviewer_ranks == effects[1]).all() + + assert game.num_suitors == len(suitor_prefs) + assert game.num_reviewers == len(reviewer_prefs) + assert game.matching is None + + assert isinstance(game._preference_lookup, dict) + assert game._preference_lookup == { + "suitors": sorted(suitor_prefs), + "reviewers": sorted(reviewer_prefs), + } + + assert ranker.call_count == 2 + for call, preference, others in zip( + ranker.call_args_list, + preferences, + (reviewer_prefs, suitor_prefs), + ): + assert call.args == (preference, sorted(others)) + + validator.assert_called_once_with() + + +@given(st_ranks()) +def test_check_number_of_players_no_warning(ranks): + """Test the number of players can be checked without warning.""" + + game = mocked_game(*ranks) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_number_of_players() + + +@given(st_ranks()) +def test_check_number_of_players_warning(ranks): + """Test for a warning when the player sets are not the same size.""" + + suitor_ranks, reviewer_ranks = ranks + suitor_ranks = np.vstack((suitor_ranks, suitor_ranks[-1][::-1])) + + game = mocked_game(suitor_ranks, reviewer_ranks) + + match = ( + r"^Number of suitors \(\d{1,2}\) " + r"and reviewers \(\d{1,2}\) do not match." + ) + with pytest.warns(UserWarning, match=match): + game._check_number_of_players() + + +@given(st_player_ranks()) +def test_check_player_ranks_no_warning(player_ranks): + """Test the rank checker runs without warning for a valid set.""" + + suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks + game = mocked_game(suitor_ranks, reviewer_ranks) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_player_ranks(player, ranks, side) + + +@given(st_player_ranks()) +def test_check_player_ranks_warning(player_ranks): + """Test the rank checker gives a warning for an invalid set.""" + + suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks + ranks[-1] = 1000 + + game = mocked_game(suitor_ranks, reviewer_ranks) + + match = f"{side.title()} {player} has not strictly ranked" + with pytest.warns(UserWarning, match=match): + game._check_player_ranks(player, ranks, side) + + +def _zip_enumerated_ranks_with_side(ranks, side): + """Attach the side to a list of enumerated rankings.""" + + return ((i, rank, side) for i, rank in enumerate(ranks)) + + +@given(st_ranks()) +def test_check_input_validity(ranks): + """Test the logic of the input validator.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) + + with ( + mock.patch( + "matching.games.StableMarriage._check_number_of_players" + ) as check_num_players, + mock.patch( + "matching.games.StableMarriage._check_player_ranks" + ) as check_player_ranks, + ): + game.check_input_validity() + + check_num_players.assert_called_once_with() + + assert check_player_ranks.call_count == ( + len(suitor_ranks) + len(reviewer_ranks) + ) + + suitor_args = _zip_enumerated_ranks_with_side(suitor_ranks, "suitor") + reviewer_args = _zip_enumerated_ranks_with_side(reviewer_ranks, "reviewer") + for call, (player, rank, side) in zip( + check_player_ranks.call_args_list, [*suitor_args, *reviewer_args] + ): + call_player, call_rank, call_side = call.args + assert call_player == player + assert (call_rank == rank).all() + + assert call_side == side + + +@given(st_ranks()) +def test_invert_player_sets(ranks): + """Test that the player set attributes can be swapped.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) + + game._invert_player_sets() + + assert (game.suitor_ranks == reviewer_ranks).all() + assert (game.reviewer_ranks == suitor_ranks).all() + assert game.num_suitors == len(reviewer_ranks) + assert game.num_reviewers == len(suitor_ranks) + + +@given( + st_ranks(), + st.sampled_from(("suitor", "reviewer")), + st.dictionaries(st.integers(), st.integers()), +) +def test_solve_valid_optimal(ranks, optimal, solution): + """Test the solver runs as it should with valid inputs.""" + + game = mocked_game(*ranks) + + with ( + mock.patch( + "matching.games.StableMarriage._invert_player_sets" + ) as player_set_inverter, + mock.patch( + "matching.games.StableMarriage._stable_marriage" + ) as stable_marriage, + mock.patch( + "matching.matchings.SingleMatching.invert" + ) as matching_inverter, + ): + stable_marriage.return_value = solution + matching_inverter.return_value = "inverted_matching" + matching = game.solve(optimal) + + assert matching == game.matching + stable_marriage.assert_called_once_with() + + if optimal == "reviewer": + assert player_set_inverter.call_count == 2 + assert [call.args for call in player_set_inverter.call_args_list] == [ + (), + (), + ] + assert matching == "inverted_matching" + else: + assert isinstance(matching, SingleMatching) + assert dict(matching) == solution + + +@given(st_ranks(), st.text()) +def test_solve_invalid_optimal_raises(ranks, optimal): + """Test the solver raises an error with invalid optimal.""" + + game = mocked_game(*ranks) + + match = "^Invalid choice for `optimal`." + with ( + mock.patch( + "matching.games.StableMarriage._invert_player_sets" + ) as player_set_inverter, + mock.patch( + "matching.games.StableMarriage._stable_marriage" + ) as stable_marriage, + mock.patch( + "matching.matchings.SingleMatching.invert" + ) as matching_inverter, + pytest.raises(ValueError, match=match), + ): + game.solve(optimal) + + player_set_inverter.assert_not_called() + stable_marriage.assert_not_called() + matching_inverter.assert_not_called() + + +@given(st_preference_matchings()) +def test_convert_matching_to_preferences(preference_matchings): + """Test that a matching can use the terms from some preferences.""" + + suitor_prefs, reviewer_prefs, matching = preference_matchings + + # the arrays here aren't used anywhere internally, just placeholders + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs) + + game.matching = SingleMatching(matching) + + game._convert_matching_to_preferences() + converted = game.matching + + assert isinstance(converted, SingleMatching) + assert converted.keys_ == "reviewers" + assert converted.values_ == "suitors" + assert converted.valid is None + assert converted.stable is None + + assert set(converted.keys()) == set(reviewer_prefs) + assert set(converted.values()) == set(suitor_prefs) diff --git a/tests/stable_marriage/test_solver.py b/tests/stable_marriage/test_solver.py deleted file mode 100644 index 358bb906..00000000 --- a/tests/stable_marriage/test_solver.py +++ /dev/null @@ -1,192 +0,0 @@ -"""Unit tests for the SM solver.""" - -import pytest - -from matching import Player, SingleMatching -from matching.exceptions import MatchingError -from matching.games import StableMarriage - -from .util import STABLE_MARRIAGE, make_players, make_prefs - - -@STABLE_MARRIAGE -def test_init(player_names, seed): - """Test for correct instantiation given a set of players.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - for player, game_player in zip( - suitors + reviewers, game.suitors + game.reviewers - ): - assert player.name == game_player.name - assert player._pref_names == game_player._pref_names - - assert all( - [player.matching is None for player in game.suitors + game.reviewers] - ) - assert game.matching is None - - -@STABLE_MARRIAGE -def test_create_from_dictionaries(player_names, seed): - """Test for correct instantiation given a set of dictionaries.""" - - suitor_prefs, reviewer_prefs = make_prefs(player_names, seed) - game = StableMarriage.create_from_dictionaries( - suitor_prefs, reviewer_prefs - ) - - for suitor in game.suitors: - assert suitor_prefs[suitor.name] == suitor._pref_names - assert suitor.matching is None - - for reviewer in game.reviewers: - assert reviewer_prefs[reviewer.name] == reviewer._pref_names - assert reviewer.matching is None - - assert game.matching is None - - -@STABLE_MARRIAGE -def test_inputs_num_players(player_names, seed): - """Test for error when the player sets are not the same size.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - assert game._check_num_players() - - suitors = suitors[:-1] - - with pytest.raises(ValueError): - StableMarriage(suitors, reviewers) - - -@STABLE_MARRIAGE -def test_inputs_player_ranks(player_names, seed): - """Test for error when a player has incomplete preferences.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - for player in game.suitors + game.reviewers: - assert game._check_player_ranks(player) - - suitors[0].prefs = suitors[0].prefs[:-1] - - with pytest.raises(ValueError): - StableMarriage(suitors, reviewers) - - -@STABLE_MARRIAGE -def test_solve(player_names, seed): - """Test that the class solves games correctly.""" - - for optimal in ["suitor", "reviewer"]: - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - matching = game.solve(optimal) - assert isinstance(matching, SingleMatching) - - suitors = sorted(suitors, key=lambda s: s.name) - reviewers = sorted(reviewers, key=lambda r: r.name) - - matching_keys = sorted(matching.keys(), key=lambda k: k.name) - matching_values = sorted(matching.values(), key=lambda v: v.name) - - for game_suitor, suitor in zip(matching_keys, suitors): - assert game_suitor.name == suitor.name - assert game_suitor._pref_names == suitor._pref_names - - for game_reviewer, reviewer in zip(matching_values, reviewers): - assert game_reviewer.name == reviewer.name - assert game_reviewer._pref_names == reviewer._pref_names - - -@STABLE_MARRIAGE -def test_check_validity(player_names, seed): - """Test for a valid matching when the game is solved.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - game.solve() - assert game.check_validity() - - -@STABLE_MARRIAGE -def test_check_for_unmatched_players(player_names, seed): - """Test that all players must be matched to another player.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - game.solve() - - player = game.suitors[0] - player.matching = None - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.unmatched_players[0] - assert error.startswith(player.name) - - -@STABLE_MARRIAGE -def test_check_for_players_not_in_matching(player_names, seed): - """Test that all players must be matched in the matching.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - matching = game.solve() - - player = game.suitors[0] - matching[player] = None - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.players[0] - assert error.startswith(player.name) - - -@STABLE_MARRIAGE -def test_matching_consistent(player_names, seed): - """Test that the game's matching must match the players' matches.""" - - suitors, reviewers = make_players(player_names, seed) - - game = StableMarriage(suitors, reviewers) - game.solve() - - game.suitors[0].matching = None - game.reviewers[0].matching = None - - with pytest.raises(Exception): - game._check_matching_consistent() - - -def test_check_stability(): - """Test checker for whether a matching is stable.""" - - suitors = [Player("A"), Player("B")] - reviewers = [Player("X"), Player("Y")] - - (a, b), (x, y) = suitors, reviewers - - a.set_prefs(reviewers) - b.set_prefs(reviewers[::-1]) - - x.set_prefs(suitors) - y.set_prefs(suitors[::-1]) - - game = StableMarriage(suitors, reviewers) - - matching = game.solve() - assert game.check_stability() - - (a, b), (x, y) = game.suitors, game.reviewers - matching[a] = y - matching[b] = x - - assert not game.check_stability() diff --git a/tests/stable_roommates/test_solver.py b/tests/stable_roommates/test_solver.py index 8d52268c..fc2ccefe 100644 --- a/tests/stable_roommates/test_solver.py +++ b/tests/stable_roommates/test_solver.py @@ -113,8 +113,17 @@ def test_stability(): matching[c] = a matching[d] = b + a.matching = c + b.matching = d + c.matching = a + d.matching = b + assert not game.check_stability() matching[a] = None matching[c] = None + + a.matching = None + c.matching = None + assert not game.check_stability() diff --git a/tests/student_allocation/test_algorithm.py b/tests/student_allocation/test_algorithm.py index d2a85143..f2ef7f0b 100644 --- a/tests/student_allocation/test_algorithm.py +++ b/tests/student_allocation/test_algorithm.py @@ -83,7 +83,7 @@ def test_supervisor_optimal( ) for supervisor in supervisors: - old_idx = -np.infty + old_idx = -np.inf for student in supervisor.matching: idx = supervisor.prefs.index(student) assert idx >= old_idx diff --git a/tests/test_convert.py b/tests/test_convert.py index 295ea9da..caa9be02 100644 --- a/tests/test_convert.py +++ b/tests/test_convert.py @@ -1,9 +1,7 @@ """Tests for the `matching.convert` module.""" -import itertools - import numpy as np -from hypothesis import given, settings +from hypothesis import assume, given, settings from hypothesis import strategies as st from hypothesis.extra.numpy import arrays @@ -52,20 +50,33 @@ def test_utility_to_rank(utility): assert isinstance(rank, np.ndarray) assert rank.shape == utility.shape assert (np.sort(rank) == np.arange(utility.shape[1])).all() + assert (rank == (-utility).argsort().argsort()).all() @given(preferences()) def test_preference_to_rank(preference): """Check that a preference dictionary can be converted to ranks.""" - others = list(itertools.chain(*preference.values())) - rank = convert.preference_to_rank(preference, others) + others = sorted(set(o for prefs in preference.values() for o in prefs)) + ranks = convert.preference_to_rank(preference, others) - assert isinstance(rank, np.ndarray) - assert rank.shape == ( - len(preference.keys()), - len(list(preference.values())[0]), - ) + assert isinstance(ranks, np.ndarray) + assert ranks.shape == (len(preference), len(others)) + + sorted_preference = sorted(preference.items(), key=lambda x: x[0]) + for rank, (_, pref) in zip(ranks, sorted_preference): + assert [pref[idx] for idx in rank] == others + + +@given(preferences()) +def test_preference_to_rank_incomplete(preference): + """Check the preference list converter assigns incomplete lists.""" + + others = sorted(set(o for prefs in preference.values() for o in prefs)) + preference[1000] = others[:-1] + assume(len(others) > 1) + + ranks = convert.preference_to_rank(preference, others) + idx = sorted(preference.keys()).index(1000) - for row, pref in zip(rank, preference.values()): - assert [others[r] for r in row] == pref + assert ranks[idx, -1] == len(others) diff --git a/tests/test_matchings.py b/tests/test_matchings.py index e93f3526..85bb654d 100644 --- a/tests/test_matchings.py +++ b/tests/test_matchings.py @@ -9,24 +9,10 @@ text, ) -from matching import MultipleMatching, SingleMatching +from matching import MultipleMatching from matching.players import Hospital, Player -@composite -def singles(draw, names_from=text(), min_size=2, max_size=5): - """A strategy for generating single-match matchings from players.""" - - size = draw(integers(min_value=min_size, max_value=max_size)) - players = [Player(draw(names_from)) for _ in range(size)] - - midpoint = size // 2 - keys, values = players[:midpoint], players[midpoint:] - dictionary = dict(zip(keys, values)) - - return dictionary - - @composite def multiples( draw, @@ -55,32 +41,6 @@ def multiples( return dictionary -@given(dictionary=singles()) -def test_single_setitem_none(dictionary): - """Test that a player in a matching can have ``None`` as a match.""" - - matching = SingleMatching(dictionary) - key = list(dictionary.keys())[0] - - matching[key] = None - assert matching[key] is None - assert key.matching is None - - -@given(dictionary=singles()) -def test_single_setitem_player(dictionary): - """Test that a player in a matching instance can match a player.""" - - matching = SingleMatching(dictionary) - key = list(dictionary.keys())[0] - val = list(dictionary.values())[-1] - - matching[key] = val - assert matching[key] == val - assert key.matching == val - assert val.matching == key - - @given(dictionary=multiples()) def test_multiple_setitem(dictionary): """Test that a host player in a matching can have a list match.""" diff --git a/tex/stable_marriage.tex b/tex/stable_marriage.tex index 371c5e6b..69603deb 100644 --- a/tex/stable_marriage.tex +++ b/tex/stable_marriage.tex @@ -9,22 +9,22 @@ % Suitors \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=left: {\(A: (D, E, F)\)}] (A) at (0, 0) {}; - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, - label=left: {\(B: (D, F, E)\)}] (B) at (0, -3) {}; - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + label=left: {\(B: (D, F, E)\)}] (B) at (0, -3) {}; + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=left: {\(C: (F, D, E)\)}] (C) at (0, -6) {}; % Reviewers - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=right: {\(D: (B, C, A)\)}] (D) at (6, 0) {}; - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=right: {\(E: (A, C, B)\)}] (E) at (6, -3) {}; \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=right: {\(F: (C, B, A)\)}] (F) at (6, -6) {}; % Question mark node \node[draw, shape=circle] (q) at (3, -3) {?}; - + % Lines into (?) \foreach \x in {A, B, C, D, E, F} \draw (\x) -- (q); From 42b3da7d1b662a6c37cd59cf618d68f082fe4b01 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 15 May 2025 14:21:53 +0100 Subject: [PATCH 4/4] Implement rank internals for the hospital-resident assignment problem (#177) * Move common test strategies out to top-level * Write tests for HR init * Move existing code around to avoid mass failure * Write tests for alt HR instantiations * Implement instantiation * Point HR example at the old version in README * Move to `uv` (#178) * Set up `uv` files and update workflows * Fix typo in test runner step * Format everything; replace `np.infty` w/ `np.inf` --------- Co-authored-by: Henry Wilde * Clean up README * Close out example tests (temporarily) * Make a stab at the HR algorithm; break matchings! * Write algorithm tests * Write tests for HR solver * Shuffle method order in game classes * Write preference matching converter test; clean up * Ensure we catch warnings in existing tests * Write tests for input validator * Implement input validator * Update HR tutorial * Clean up from preferences method * Fix README examples * Update all tutorials and the docs dependencies * Update how-tos and CI workflow * Reach 100% coverage on HR components * Write tests for the matching classes * Get to 100% coverage on SM tests * Enable branch coverage --------- Co-authored-by: Henry Wilde --- .github/workflows/ci.yml | 36 +- .github/workflows/docs.yml | 24 +- README.md | 26 +- docs/how-to/check_matching_status.ipynb | 10 +- docs/how-to/choose_optimality.ipynb | 16 +- docs/how-to/create_from_dictionaries.ipynb | 4 +- docs/tutorials/hospital_resident.ipynb | 36 +- docs/tutorials/stable_marriage.ipynb | 6 +- docs/tutorials/stable_roommates.ipynb | 4 +- docs/tutorials/student_allocation.ipynb | 98 +- pyproject.toml | 49 +- src/matching/__init__.py | 6 +- src/matching/algorithms/hospital_resident.py | 6 +- src/matching/algorithms/student_allocation.py | 8 +- src/matching/base.py | 13 +- src/matching/games/_old_hospital_resident.py | 268 ++ src/matching/games/hospital_resident.py | 522 ++-- src/matching/games/stable_marriage.py | 160 +- src/matching/games/stable_roommates.py | 6 +- src/matching/games/student_allocation.py | 51 +- src/matching/matchings.py | 110 + src/matching/matchings/__init__.py | 6 - src/matching/matchings/multiple.py | 35 - src/matching/matchings/single.py | 65 - src/matching/players/supervisor.py | 4 +- tests/__init__.py | 1 + tests/base/test_matching.py | 4 +- tests/common.py | 58 + tests/hospital_resident/strategies.py | 103 + tests/hospital_resident/test_algorithm.py | 173 +- tests/hospital_resident/test_examples.py | 78 +- tests/hospital_resident/test_game.py | 277 ++ tests/hospital_resident/test_solver.py | 371 --- tests/hospital_resident/util.py | 4 +- tests/matchings/__init__.py | 1 + tests/matchings/test_hospital_resident.py | 109 + tests/matchings/test_single.py | 106 - tests/matchings/test_stable_marriage.py | 92 + tests/stable_marriage/strategies.py | 45 +- tests/stable_marriage/test_algorithm.py | 24 +- tests/stable_marriage/test_examples.py | 14 +- tests/stable_marriage/test_game.py | 81 +- tests/stable_marriage/util.py | 12 +- tests/stable_roommates/test_algorithm.py | 4 +- tests/stable_roommates/test_examples.py | 5 +- tests/student_allocation/test_algorithm.py | 18 +- tests/student_allocation/test_examples.py | 4 +- tests/student_allocation/test_solver.py | 104 +- tests/student_allocation/util.py | 38 +- tests/test_convert.py | 12 +- tests/test_matchings.py | 58 - uv.lock | 2408 +++++++++++++++++ 52 files changed, 4225 insertions(+), 1548 deletions(-) create mode 100644 src/matching/games/_old_hospital_resident.py create mode 100644 src/matching/matchings.py delete mode 100644 src/matching/matchings/__init__.py delete mode 100644 src/matching/matchings/multiple.py delete mode 100644 src/matching/matchings/single.py create mode 100644 tests/__init__.py create mode 100644 tests/common.py create mode 100644 tests/hospital_resident/strategies.py create mode 100644 tests/hospital_resident/test_game.py delete mode 100644 tests/hospital_resident/test_solver.py create mode 100644 tests/matchings/__init__.py create mode 100644 tests/matchings/test_hospital_resident.py delete mode 100644 tests/matchings/test_single.py create mode 100644 tests/matchings/test_stable_marriage.py delete mode 100644 tests/test_matchings.py create mode 100644 uv.lock diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 59935c25..955fc7d9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -16,35 +16,33 @@ jobs: strategy: matrix: os: [ubuntu-latest, windows-latest] - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.10", "3.11", "3.12", "3.13"] steps: - name: Check out repository uses: actions/checkout@v4 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v5 + - name: Install uv and set the python version + uses: astral-sh/setup-uv@v5 with: python-version: ${{ matrix.python-version }} - cache: "pip" - - name: Update pip and install dependencies + - name: Install the project + run: uv sync --all-extras + + - name: Run linters (3.13-ubuntu only) + if: | + matrix.python-version == '3.13' && + matrix.os == 'ubuntu-latest' run: | - python -m pip install --upgrade pip - python -m pip install ".[docs,test]" + uv run ruff format --check . + uv run ruff check . - - name: Run tests + - name: Run documentation tests run: | - python -m doctest README.md - python -m pytest docs --nbval --nbval-current-env -p no:randomly - python -m pytest tests \ - --cov=matching --cov-fail-under=100 --hypothesis-profile=ci + uv run python -m doctest README.md + uv run pytest docs --nbval --nbval-current-env -p no:randomly - - name: Install and run linters (3.12-ubuntu only) - if: | - matrix.python-version == '3.12' && - matrix.os == 'ubuntu-latest' + - name: Run unit tests run: | - python -m pip install ".[lint]" - python -m ruff check . - python -m ruff format --check . + uv run pytest tests --cov --cov-fail-under=100 --hypothesis-profile=ci diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 69039680..8d19341a 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -12,17 +12,23 @@ jobs: contents: write steps: - name: Check out repository - uses: actions/checkout@v4 + uses: actions/checkout@v3 + - name: Set up Quarto uses: quarto-dev/quarto-actions/setup@v2 - - name: Install Python and dependencies - uses: actions/setup-python@v5 - with: - python-version: "3.12" - cache: "pip" - - run: | - python -m pip install ".[dev]" - quartodoc build + + - name: Install uv + uses: astral-sh/setup-uv@v5 + + - name: Set up Python + run: | + uv python install + + - name: Install package and build docs + run: | + uv sync --all-extras + uv run quartodoc build + - name: Render and publish uses: quarto-dev/quarto-actions/publish@v2 with: diff --git a/README.md b/README.md index 6cb4767a..b9e8b6c9 100644 --- a/README.md +++ b/README.md @@ -21,22 +21,22 @@ In `matching`, we deal with four types of matching game: ## Installation -Matching requires Python 3.5 or above, and relies only on -[NumPy](http://www.numpy.org/) for general use. +Matching requires Python 3.10 or above, and relies only on the scientific stack ([NumPy](http://www.numpy.org/) and +[SciPy](https://scipy.org/)) for general use. The library is most easily installed using `pip`: ```bash - $ python -m pip install matching +$ python -m pip install matching ``` However, if you would like to install it from source then go ahead and clone the GitHub repository: ```bash - $ git clone https://github.com/daffidwilde/matching.git - $ cd matching - $ python -m pip install . +$ git clone https://github.com/daffidwilde/matching.git +$ cd matching +$ python -m pip install . ``` ## Documentation @@ -95,11 +95,11 @@ largely look and behave like one. It is in fact an instance of the ```python >>> type(matching) - + >>> isinstance(matching, dict) True >>> matching -SingleMatching({'F': 'C', 'D': 'B', 'E': 'A'}, keys="reviewers", values="suitors") +SMMatching({'F': 'C', 'D': 'B', 'E': 'A'}, keys="reviewers", values="suitors") ``` @@ -118,7 +118,7 @@ One of the limitations of this library is the time complexities of the algorithm implementations. In practical terms, the running time of any of the algorithms in Matching is negligible but the theoretic complexity of each has not yet been attained. For example, an instance of HR with -400 applicants and 20 hospitals is solved in less than one tenth of a +400 applicants and 20 hospitals is solved in around one tenth of a second: ```python @@ -127,18 +127,18 @@ second: >>> prng = np.random.default_rng(0) >>> num_residents, num_hospitals = 400, 20 >>> resident_prefs = { -... r: np.argsort(prng.random(size=num_hospitals)) +... r: list(np.argsort(prng.random(size=num_hospitals))) ... for r in range(num_residents) ... } >>> hospital_prefs = { -... h: np.argsort(prng.random(size=num_residents)) +... h: list(np.argsort(prng.random(size=num_residents))) ... for h in range(num_hospitals) ... } >>> capacities = {h: num_hospitals for h in hospital_prefs} ->>> game = HospitalResident.create_from_dictionaries( +>>> game = HospitalResident.from_preferences( ... resident_prefs, hospital_prefs, capacities ... ) ->>> _ = game.solve() # 48.6 ms ± 963 µs per loop +>>> _ = game.solve() # 118 ms ± 847 µs per loop ``` diff --git a/docs/how-to/check_matching_status.ipynb b/docs/how-to/check_matching_status.ipynb index 682182b3..779a7b8f 100644 --- a/docs/how-to/check_matching_status.ipynb +++ b/docs/how-to/check_matching_status.ipynb @@ -39,9 +39,7 @@ "\n", "project_supervisors = {\"X1\": \"X\", \"X2\": \"X\", \"Y1\": \"Y\", \"Y2\": \"Y\"}\n", "project_capacities = {project: 1 for project in project_supervisors}\n", - "supervisor_capacities = {\n", - " supervisor: 2 for supervisor in supervisor_preferences\n", - "}\n", + "supervisor_capacities = {supervisor: 2 for supervisor in supervisor_preferences}\n", "\n", "\n", "game = StudentAllocation.create_from_dictionaries(\n", @@ -85,9 +83,9 @@ ], "metadata": { "kernelspec": { - "display_name": "matching-docs", + "display_name": ".venv", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -99,7 +97,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/how-to/choose_optimality.ipynb b/docs/how-to/choose_optimality.ipynb index 9d78354a..5747d0bc 100644 --- a/docs/how-to/choose_optimality.ipynb +++ b/docs/how-to/choose_optimality.ipynb @@ -47,7 +47,7 @@ { "data": { "text/plain": [ - "SingleMatching({'Y': 'C', 'Z': 'B', 'X': 'A'}, keys=\"reviewers\", values=\"suitors\")" + "SMMatching({'Y': 'C', 'Z': 'B', 'X': 'A'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 2, @@ -56,9 +56,7 @@ } ], "source": [ - "game = StableMarriage.from_preferences(\n", - " suitor_preferences, reviewer_preferences\n", - ")\n", + "game = StableMarriage.from_preferences(suitor_preferences, reviewer_preferences)\n", "\n", "game.solve(optimal=\"suitor\")" ] @@ -71,7 +69,7 @@ { "data": { "text/plain": [ - "SingleMatching({'Y': 'A', 'Z': 'B', 'X': 'C'}, keys=\"reviewers\", values=\"suitors\")" + "SMMatching({'Y': 'A', 'Z': 'B', 'X': 'C'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 3, @@ -80,9 +78,7 @@ } ], "source": [ - "game = StableMarriage.from_preferences(\n", - " suitor_preferences, reviewer_preferences\n", - ")\n", + "game = StableMarriage.from_preferences(suitor_preferences, reviewer_preferences)\n", "\n", "game.solve(optimal=\"reviewer\")" ] @@ -90,7 +86,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -104,7 +100,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/how-to/create_from_dictionaries.ipynb b/docs/how-to/create_from_dictionaries.ipynb index 98dc6eb6..35132ba8 100644 --- a/docs/how-to/create_from_dictionaries.ipynb +++ b/docs/how-to/create_from_dictionaries.ipynb @@ -28,9 +28,7 @@ "\n", "project_supervisors = {\"X1\": \"X\", \"X2\": \"X\", \"Y1\": \"Y\", \"Y2\": \"Y\"}\n", "project_capacities = {project: 1 for project in project_supervisors}\n", - "supervisor_capacities = {\n", - " supervisor: 2 for supervisor in supervisor_preferences\n", - "}" + "supervisor_capacities = {supervisor: 2 for supervisor in supervisor_preferences}" ] }, { diff --git a/docs/tutorials/hospital_resident.ipynb b/docs/tutorials/hospital_resident.ipynb index d136dbaf..25af594e 100644 --- a/docs/tutorials/hospital_resident.ipynb +++ b/docs/tutorials/hospital_resident.ipynb @@ -46,6 +46,7 @@ "outputs": [], "source": [ "import urllib\n", + "import warnings\n", "\n", "import yaml\n", "\n", @@ -126,9 +127,11 @@ "source": [ "from matching.games import HospitalResident\n", "\n", - "game = HospitalResident.create_from_dictionaries(\n", - " resident_preferences, hospital_preferences, hospital_capacities\n", - ")" + "with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\")\n", + " game = HospitalResident.from_preferences(\n", + " resident_preferences, hospital_preferences, hospital_capacities\n", + " )" ] }, { @@ -171,19 +174,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dewi Sant (30 / 30): [067, 022, 023, 158, 139, 065, 160, 131, 011, 137, 039, 045, 013, 046, 072, 037, 086, 152, 144, 154, 130, 040, 010, 159, 083, 019, 169, 193, 168, 079]\n", - "Prince Charles (29 / 30): [027, 133, 106, 081, 051, 044, 069, 157, 110, 119, 129, 107, 135, 034, 007, 194, 198, 061, 087, 041, 183, 136, 059, 178, 009, 008, 031, 070, 026]\n", - "Prince of Wales (30 / 30): [143, 128, 048, 175, 078, 132, 151, 030, 124, 138, 088, 004, 199, 173, 017, 097, 064, 025, 112, 181, 171, 196, 111, 035, 185, 156, 140, 001, 197, 177]\n", - "Royal Glamorgan (30 / 30): [073, 118, 096, 089, 014, 126, 142, 053, 021, 018, 104, 015, 147, 153, 033, 113, 146, 076, 123, 042, 117, 024, 029, 000, 016, 134, 058, 166, 075, 174]\n", - "Royal Gwent (27 / 30): [028, 105, 115, 095, 054, 006, 120, 161, 187, 164, 091, 141, 036, 184, 071, 155, 066, 182, 189, 002, 191, 068, 090, 145, 163, 121, 180]\n", - "St. David (30 / 30): [149, 101, 150, 172, 165, 020, 049, 094, 060, 116, 056, 005, 093, 188, 043, 108, 192, 092, 167, 114, 012, 063, 077, 162, 085, 195, 032, 099, 084, 127]\n", - "University (24 / 30): [109, 003, 057, 170, 176, 100, 122, 080, 038, 082, 102, 052, 062, 055, 047, 074, 050, 179, 125, 186, 148, 103, 098, 190]\n" + "Dewi Sant (30 / 30): ['010', '011', '013', '019', '022', '023', '037', '039', '040', '045', '046', '065', '067', '072', '079', '083', '086', '130', '131', '137', '139', '144', '152', '154', '158', '159', '160', '168', '169', '193']\n", + "Prince Charles (29 / 30): ['007', '008', '009', '026', '027', '031', '034', '041', '044', '051', '059', '061', '069', '070', '087', '107', '110', '119', '129', '133', '135', '136', '157', '178', '183', '194', '198', '106', '081']\n", + "Prince of Wales (30 / 30): ['001', '004', '017', '030', '035', '048', '064', '078', '088', '097', '111', '112', '124', '128', '132', '138', '140', '143', '151', '156', '171', '173', '175', '177', '181', '185', '196', '197', '199', '025']\n", + "Royal Glamorgan (30 / 30): ['000', '014', '015', '016', '018', '021', '024', '029', '033', '042', '053', '058', '073', '075', '076', '089', '096', '104', '113', '117', '118', '123', '126', '134', '142', '146', '147', '153', '166', '174']\n", + "Royal Gwent (27 / 30): ['002', '006', '028', '036', '054', '068', '071', '090', '091', '105', '120', '121', '141', '145', '155', '161', '163', '164', '180', '182', '184', '187', '189', '191', '066', '115', '095']\n", + "St. David (30 / 30): ['005', '012', '020', '032', '043', '049', '056', '060', '063', '077', '084', '085', '092', '093', '094', '099', '101', '108', '114', '116', '127', '149', '150', '162', '165', '167', '172', '188', '192', '195']\n", + "University (24 / 30): ['038', '047', '050', '052', '055', '057', '062', '074', '080', '082', '098', '100', '102', '103', '109', '122', '148', '170', '176', '179', '186', '190', '125', '003']\n" ] } ], "source": [ "for hospital, residents in solution.items():\n", - " print(f\"{hospital} ({len(residents)} / {hospital.capacity}): {residents}\")" + " capacity = hospital_capacities[hospital]\n", + " print(f\"{hospital} ({len(residents)} / {capacity}): {residents}\")" ] }, { @@ -217,11 +221,9 @@ "matched_residents = []\n", "for _, residents in solution.items():\n", " for resident in residents:\n", - " matched_residents.append(resident.name)\n", + " matched_residents.append(resident)\n", "\n", - "unmatched_residents = set(resident_preferences.keys()).difference(\n", - " matched_residents\n", - ")\n", + "unmatched_residents = set(resident_preferences.keys()).difference(matched_residents)\n", "unmatched_residents" ] }, @@ -238,7 +240,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -252,7 +254,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/tutorials/stable_marriage.ipynb b/docs/tutorials/stable_marriage.ipynb index b4aa2ef7..94d73366 100644 --- a/docs/tutorials/stable_marriage.ipynb +++ b/docs/tutorials/stable_marriage.ipynb @@ -99,7 +99,7 @@ { "data": { "text/plain": [ - "SingleMatching({'Lydia': 'Wickham', 'Elizabeth': 'Darcy', 'Jane': 'Bingley', 'Charlotte': 'Collins'}, keys=\"reviewers\", values=\"suitors\")" + "SMMatching({'Lydia': 'Wickham', 'Elizabeth': 'Darcy', 'Jane': 'Bingley', 'Charlotte': 'Collins'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 3, @@ -123,7 +123,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -137,7 +137,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/tutorials/stable_roommates.ipynb b/docs/tutorials/stable_roommates.ipynb index e1f3154d..e4704038 100644 --- a/docs/tutorials/stable_roommates.ipynb +++ b/docs/tutorials/stable_roommates.ipynb @@ -130,7 +130,7 @@ ], "metadata": { "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -144,7 +144,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/docs/tutorials/student_allocation.ipynb b/docs/tutorials/student_allocation.ipynb index 303114aa..25c0c5a5 100644 --- a/docs/tutorials/student_allocation.ipynb +++ b/docs/tutorials/student_allocation.ipynb @@ -53,15 +53,9 @@ "metadata": {}, "outputs": [], "source": [ - "raw_students = pd.read_csv(\n", - " \"https://zenodo.org/record/3514287/files/students.csv\"\n", - ")\n", - "raw_projects = pd.read_csv(\n", - " \"https://zenodo.org/record/3514287/files/projects.csv\"\n", - ")\n", - "raw_supervisors = pd.read_csv(\n", - " \"https://zenodo.org/record/3514287/files/supervisors.csv\"\n", - ")" + "raw_students = pd.read_csv(\"https://zenodo.org/record/3514287/files/students.csv\")\n", + "raw_projects = pd.read_csv(\"https://zenodo.org/record/3514287/files/projects.csv\")\n", + "raw_supervisors = pd.read_csv(\"https://zenodo.org/record/3514287/files/supervisors.csv\")" ] }, { @@ -360,11 +354,7 @@ } ], "source": [ - "students = (\n", - " raw_students.copy()\n", - " .dropna(subset=choices, how=\"all\")\n", - " .reset_index(drop=True)\n", - ")\n", + "students = raw_students.copy().dropna(subset=choices, how=\"all\").reset_index(drop=True)\n", "\n", "students.head()" ] @@ -778,9 +768,7 @@ "supervisor_to_preferences = {}\n", "for supervisor in supervisor_names:\n", " supervisor_preferences = []\n", - " supervisor_projects = [\n", - " p for p, s in project_to_supervisor.items() if s == supervisor\n", - " ]\n", + " supervisor_projects = [p for p, s in project_to_supervisor.items() if s == supervisor]\n", "\n", " for student in sorted_students:\n", " student_preferences = student_to_preferences[student]\n", @@ -823,9 +811,7 @@ } ], "source": [ - "unranked_supervisors = set(supervisor_names).difference(\n", - " supervisor_to_preferences.keys()\n", - ")\n", + "unranked_supervisors = set(supervisor_names).difference(supervisor_to_preferences.keys())\n", "\n", "\n", "unranked_projects = set(project_codes).difference(\n", @@ -934,9 +920,7 @@ ], "source": [ "for supervisor, supervisor_capacity in supervisor_to_capacity.items():\n", - " supervisor_projects = [\n", - " p for p, s in project_to_supervisor.items() if s == supervisor\n", - " ]\n", + " supervisor_projects = [p for p, s in project_to_supervisor.items() if s == supervisor]\n", " supervisor_project_capacities = [\n", " project_to_capacity[project] for project in supervisor_projects\n", " ]\n", @@ -997,7 +981,7 @@ { "data": { "text/plain": [ - "{A0: [], A1: [190019, 190034], A2: [190017], B0: [], B1: [190091], B2: [], C0: [190003, 190068], C1: [190070], C2: [190079, 190062], D0: [190015, 190039, 190009], D1: [190008, 190056], D2: [], E0: [], E1: [190063, 190022], E2: [], F0: [190011], F1: [190094], G0: [190096], G1: [], G2: [190000, 190045, 190077], H0: [], H1: [190078], H2: [190023, 190098], I0: [190004], I1: [], I2: [], J0: [190021], J1: [190097, 190089, 190061, 190014], J2: [190085, 190090], K0: [190074, 190095], K1: [190024, 190013], K2: [190052, 190006], L0: [190072], M0: [190086, 190053], M1: [190054, 190081, 190075], N0: [190049, 190032], N1: [190046, 190044, 190037, 190057], N2: [190031, 190060], O0: [190016], O1: [], P0: [190047], P1: [190076, 190027], P2: [190093], P3: [190071], Q0: [190001], R0: [190048], R1: [], R2: [], S0: [190069], S1: [190092, 190042, 190084, 190066, 190067], T0: [], T1: [], T2: [190036], U0: [190010, 190002, 190059, 190030], U1: [], U2: [190055], V0: [190073], V1: [], V2: [190018], W0: [190026], W1: [190058], X0: [190088, 190080, 190012], X1: [190028], X2: [190043, 190064, 190020], Y0: [190083, 190007, 190099], Y1: [190065, 190050], Y2: [190033], Z0: [190051], Z1: [190005, 190038]}" + "_MultipleMatching({A0: [], A1: [190019, 190034], A2: [190017], B0: [], B1: [190091], B2: [], C0: [190003, 190068], C1: [190070], C2: [190079, 190062], D0: [190015, 190039, 190009], D1: [190008, 190056], D2: [], E0: [], E1: [190063, 190022], E2: [], F0: [190011], F1: [190094], G0: [190096], G1: [], G2: [190000, 190045, 190077], H0: [], H1: [190078], H2: [190023, 190098], I0: [190004], I1: [], I2: [], J0: [190021], J1: [190097, 190089, 190061, 190014], J2: [190085, 190090], K0: [190074, 190095], K1: [190024, 190013], K2: [190052, 190006], L0: [190072], M0: [190086, 190053], M1: [190054, 190081, 190075], N0: [190049, 190032], N1: [190046, 190044, 190037, 190057], N2: [190031, 190060], O0: [190016], O1: [], P0: [190047], P1: [190076, 190027], P2: [190093], P3: [190071], Q0: [190001], R0: [190048], R1: [], R2: [], S0: [190069], S1: [190092, 190042, 190084, 190066, 190067], T0: [], T1: [], T2: [190036], U0: [190010, 190002, 190059, 190030], U1: [], U2: [190055], V0: [190073], V1: [], V2: [190018], W0: [190026], W1: [190058], X0: [190088, 190080, 190012], X1: [190028], X2: [190043, 190064, 190020], Y0: [190083, 190007, 190099], Y1: [190065, 190050], Y2: [190033], Z0: [190051], Z1: [190005, 190038]}, keys=\"keys\", values=\"values\")" ] }, "execution_count": 23, @@ -1052,13 +1036,11 @@ "outputs": [], "source": [ "supervisor_free_spaces = {\n", - " supervisor: supervisor.capacity - len(supervisor.matching)\n", - " for supervisor in game.supervisors\n", + " supervisor: supervisor.capacity - len(supervisor.matching) for supervisor in game.supervisors\n", "}\n", "\n", "supervisor_utilisation = {\n", - " supervisor: len(supervisor.matching) / supervisor.capacity\n", - " for supervisor in game.supervisors\n", + " supervisor: len(supervisor.matching) / supervisor.capacity for supervisor in game.supervisors\n", "}" ] }, @@ -1083,7 +1065,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1117,7 +1099,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -1126,7 +1108,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1142,9 +1124,7 @@ "ax.hist(values)\n", "\n", "ylims = ax.get_ylim()\n", - "ax.vlines(\n", - " np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3\n", - ")\n", + "ax.vlines(np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3)\n", "ax.set_ylim(*ylims)\n", "\n", "ax.set_xlabel(\"Utilisation\")\n", @@ -1171,13 +1151,11 @@ "outputs": [], "source": [ "project_free_spaces = {\n", - " project.name: project.capacity - len(project.matching)\n", - " for project in game.projects\n", + " project.name: project.capacity - len(project.matching) for project in game.projects\n", "}\n", "\n", "project_utilisation = {\n", - " project.name: len(project.matching) / project.capacity\n", - " for project in game.projects\n", + " project.name: len(project.matching) / project.capacity for project in game.projects\n", "}" ] }, @@ -1202,7 +1180,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACAwAAASYCAYAAACeDs3kAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAC4jAAAuIwF4pT92AADIsklEQVR4nOzdeZhWZf0/8M8Dw74vgwoCsqmooKSIS8iiqEVuKJlbrolppV8XykzLX2VquZSGqaiZ+4pp7gooliKugCKIMiAIMuwMO8z5/eHF1MMMMDMMPIzn9bquuZrzec59359n5jBddd7PfTJJkiQBAAAAAAAAAKRKjVw3AAAAAAAAAABsewIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAABUS7vssktkMpmSrzPOOCPXLVEBixcvjltvvTUGDx4cXbp0iebNm0fNmjWzfqf77LNPrtsEAACAb7S8XDcAAAAApMvf/va3GDp0aCxdujTXrQAAAECqCQwAAADkSEFBQXTo0KHc59etWzeaNGkSTZo0iV133TX23Xff6N27d/Tr1y9q1LCBHNXDb3/727jqqqty3QYAAAAQAgMAAADVxsqVK2PlypXx1VdfxZQpU+Jf//pXRHy9Nf9PfvKTuPDCCyMvz//M42t9+/aN1157reS4T58+MXr06Nw1FBHvvvtu/OY3vylVz2Qy0bZt22jatGlkMpmS+m677bYNuwMAAID08f8kAQAAVHMFBQVx6aWXxkMPPRQPPfRQdOnSJdctQZluvPHGKC4uzqpdfvnlcemll0bz5s1z1BUAAACkl8AAAADAdqRBgwbRuXPnMl9bvnx5zJs3LxYuXFjm6++++24cdthh8e9//zt23nnnrdkmVFhxcXE888wzWbXBgwfHNddck6OOAAAAAIEBAACA7ch+++232W3jP/vss3j44Yfj5ptvjnnz5mW9NmPGjBg8eHC8+eabW7HL7UNBQUGuW6ACJk2aFEuXLs2qnXjiiTnqBgAAAIiIqJHrBgAAAKiYTp06xRVXXBETJkyI/fffv9Trb731Vjz22GM56Aw2bsaMGaVqu+22Ww46AQAAANYTGAAAAKimdtxxx/jXv/4VO+64Y6nXbr/99hx0BBu3ePHiUrUGDRrkoBMAAABgPYEBAACAaiw/Pz+GDh1aqv7GG2/E8uXLc9ARlG3lypWlaplMJgedAAAAAOvl5boBAAAAtsygQYPi4osvzqqtWrUqPvroo+jZs2el5ly3bl188MEH8fHHH8dXX30VK1eujAYNGkT37t3j0EMPLdccixYtirfffjvmzJkThYWFsW7dumjVqlW0atUqevbsGfn5+ZXqbWtat25dvPfeezF9+vQoLCyMhQsXRuPGjSM/Pz+6dOkSPXr02Go3uVevXh3vvPNOzJw5M+bPnx8LFy6MOnXqROPGjaNTp06xxx57lLmbBKUtWrQoxo0bF5999lksWrQoiouLo3nz5vGd73wn2rdvX645cnktLF++PMaOHVvyb2fZsmXRokWLyM/Pj3322Sc6dOiwVdatjCRJ4vPPP4/x48fHnDlzYsmSJbF27dqoV69eNGzYMHbeeefYZZddYtddd428vKr/v6G+/PLLGDduXEybNi2WLVsWzZs3j9atW0fPnj2jdevWVbrWihUrYsqUKfHJJ5/EvHnzYsmSJZGXlxfNmjWLli1bxj777BO77LJLla65ofV/mwsKCmLevHmxYMGCyMvLi8aNG8cuu+wSXbt2jXbt2lXZejNmzIjx48dHYWFhFBYWRs2aNaNly5bRunXrOPDAA6Nhw4ZVttaaNWti0qRJMXHixFiwYEEsWbIkMplM1KtXL5o2bRrt2rWLjh07bvWfMQAApE4CAABATkybNi2JiKyvPn36VGquBg0alJrr2WefLXXeqFGjSp03atSoktenT5+eXHDBBUmzZs1KnVee/tasWZPccccdybe//e2kZs2aZc4REUkmk0n222+/5IYbbkhWrlxZqffcvn37rDlPP/30Ss2TJEny8ssvJyeccELStGnTjfYcEUmLFi2SH/7wh8mkSZMqvdb/Wrt2bfKPf/wjOeKII5L69etvcu2ISHbbbbfkwgsvTN57770y59vc+PJ8TZs2rUre2+mnn75FfZT1+9xwzvbt22e9/txzzyWHHXbYRq+9e+65Z7N95+paWLNmTXLnnXcm/fv3T2rXrr3JtTt16pRcfvnlyfz586tk7cqYPHly8rOf/SzZYYcdyvX7rF+/ftK7d+/k97//fTJ58uTNzr+53/WIESOSAw88cKPr1ahRI+ndu3fy5JNPVvo9FhcXJ2+88UYydOjQZP/990/y8vI2+z533nnn5MILL0ymT59e6XXL8s9//jM55phjkiZNmmy2h3bt2iXnnHNO8vrrr1dqrZkzZyaXXHJJsvvuu29ynVq1aiW9e/dOHn744aS4uLjS723kyJHJiSeemNSrV69c11LLli2T733ve8kdd9yRFBYWVnpdAADgawIDAAAAOVKVgYHWrVuXmuuBBx4odd6mAgPDhw/f7E3rTfX3yiuvJLvttluFbwy3a9euUjf1qiIwMH78+KR///4V7rlmzZrJkCFDKh12SJIkefzxx5POnTtXeO31XzfccEOpOSs71/9+VcfAwNKlS5Pjjz9+s3NuKjCQy2thxIgRlboWGjdunNx6662VXrcyiouLk1/96lebDTVs6muHHXbY7Dob+10vW7YsGTRoUIXWO+aYYyp8Y3n06NFJ27ZtK/0e8/Lykl/96lfJunXrKvNjLjFq1KikR48ele7jpz/9abnXWr58eXLppZcmdevWrfA63bt3TyZMmFCh97ZgwYLkuOOO26K/EyeeeGJFf6QAAMAGagQAAADV3uLFi0vVmjZtWu7xf/zjH+Occ86J5cuXV2r9e+65J4488siYPHlyhcfOmDEjjj/++PjjH/9YqbUr65lnnokDDzwwRo4cWeGx69ati9tvvz369u0bc+fOrdDY4uLiuOyyy+KEE06IqVOnVnjt9ZYsWVLpsd8ky5Yti0MPPTSeeOKJSs+Rq2shSZL49a9/Hccdd1ylroUlS5bET37ykxgyZEisW7euwuMr4/TTT4/f/e53sXr16m2y3v9atWpVHHnkkfHkk09WaNw///nPOPTQQ2P+/PnlHjNt2rT44osvKtpiibVr18bvfve7OOaYY2Lt2rWVmuPmm2+Oww47LN5///1K91HevxNz5syJvn37xp/+9KdYuXJlhdcZP358HHTQQfHcc8+V6/yFCxdG3759Y8SIERVeCwAAqFpV//A4AAAAtqnp06fHsmXLStXz8/PLNf6ll16Ka6+9tuS4Tp060a9fv+jbt2/suOOOkZeXFzNnzoyxY8dGUVFRqfH33XdfnHXWWaXqmUwmDjzwwPjOd74Tbdu2jby8vJg1a1a8/PLLMWrUqKwbnEmSxNChQyOTycSll15arr63xIMPPhinnXZaFBcXZ9Vr164d/fv3j169ekXbtm2jSZMmUVRUFAUFBfHqq6/GG2+8kXX+W2+9FYMGDYpRo0ZFrVq1yrX2aaedFg8++GCZr+21114xYMCA6NSpU7Rs2TLWrFkTCxYsiI8//jjGjRsX77//fiRJstG5995775Lvp06dmnVdNGjQIDp37rzZ/mrXrl2u97E57dq1y+pnwYIFpW7Adu3adaPrlfc57Oeee268/fbbJcetW7eOgQMHRrdu3aJVq1axZMmSmD59ejz99NNljs/ltfDjH/84br/99lL15s2bx4ABA2LfffeNVq1aRf369WPRokXx0UcfxQsvvFAqmHPHHXdE06ZN47rrrivXupV17733xn333Veqnp+fH0cccUR069YtWrduHfXq1YsVK1bE0qVLY9q0afHRRx/Fm2++GQsXLtyi9S+55JIYM2ZMyXHLli1j0KBB0b1792jZsmXMmzcvJkyYEE8++WQUFhZmjR0/fnwcccQR8eabb5b79/O/dtxxx9h3332ja9euscsuu0Tjxo2jfv36sWzZspg7d25MmDAhXnjhhVKhkX/961/xy1/+Mq6//voKrffLX/4y/vCHP5T5WufOnePwww+P3XbbLfLz8yNJkli4cGFMmTIl3nnnnXj77bcrFFL46quv4oADDojp06eXem2vvfaKPn36xJ577lkSQps7d268+eab8dxzz8XSpUtLzl26dGkcf/zx8Z///Cd69OixyTUvvvjiGD9+fKn6rrvuGocddljsvvvu0aJFi6hTp04UFRXFokWLYsqUKTFx4sQYO3ZsrFq1qtzvDwAA2IzcbnAAAACQXlX1SIIbb7yx1Dy1a9dOioqKSp1b1iMJ/vd578cff3wyY8aMja61YsWKrONPP/00adiwYak599prr2Ts2LEbnefjjz9ODjjggFLjatWqlYwbN65c77uyjySYOHFiqUcv5OXlJZdddlkyd+7cTY59//33k3333bdU35deemm51v7jH/9Y5rbaffv2Td5+++3Njp85c2Zy0003JR07dkx+/etfb/LcPn36bPG1VZXuueeeUu+7oo8/2HCb+v+9duvVq5fcfPPNyerVqzc6fsPrN5fXwt13311qbPPmzZPbb7+9VJ//q7i4OHnyySeTVq1alRr/zDPPlGvtytrwsQk1a9ZMrr/++nI9jmHt2rXJG2+8kZx77rlJp06dNnv+hr/rOnXqJJlMJomIpEaNGsnPf/7zjf6cVqxYkfziF79IatSoUepn9Jvf/KZc7/Wee+5JOnbsmPzud79LPvzww3KNWbt2bXL//fcnO+64Y9aamUymXP++13vsscfK/Duxzz77JC+++OJmx8+bNy+58847k+7du2/27+K6devKfBTHQQcdlLz11lubHLtw4cLk4osvLvm9rP/q0KFDsmTJko2OmzFjRqkx+fn5ydNPP73Z95YkSVJUVJSMGDEiGThwYHLyySeXawwAALBxAgMAAAA5UhWBgcLCwlI3pyIi6d+/f5nnlxUYWP/1s5/9rMLvYcCAAaXm2W+//ZJFixZtduyKFSvKvFHVrVu3cq1dmcDAunXrkr322itrXIMGDZKRI0eWa80kSZJVq1aVet+1a9dOvvjii02OmzBhQtYN7vVfF110UYWfc7527dpNBjuSJB2Bgf/9Hb722msVmiuX18K0adNKBRV23XXXzY77XzNmzEh23nnnrDn23HPPpLi4uNxzVMTEiRMrffN9Q8uWLdvsORv7XUdEctttt5Vrndtuu63U2Fq1aiVTp07d7NglS5ZU+mc5ffr0pF27dlnrnnTSSeUaO3fu3KRRo0al+v7+979frmDGhgoKCjb5+nXXXVdqrQsuuKBC772s8Mt111230fNvvfXWUuePHj263Ov9r/JcSwAAwKbVCAAAAKqlr776Ko4++uiYM2dOqdd+9KMfVWiu/fffP2688cYKjZk4cWK8/PLLWbXGjRvHU089FU2aNNns+Lp168aTTz4ZO+64Y1Z9woQJ8dJLL1Wol/J64oknYuLEiVm1e+65J/r161fuOWrXrh2PPfZYtGzZsqS2evXqzf78rrnmmlLPmT/55JPjpptuiho1KvY/z2vWrBlt27at0JhvsmuvvTYOOeSQCo3J5bXwxz/+MZYvX15y3KBBg3jhhRdi5513Lvfabdu2jYcffjir9tFHH8UzzzxT7jkq4vPPPy9Vq+jfmfXq169f6T7OOOOMOO+888p17nnnnRdnnHFGVm3NmjVx2223bXZso0aNIpPJVKbFaNeuXQwbNiyr9thjj8XixYs3O/amm27K2uY/IqJ3797x0EMPRZ06dSrcS/v27Tf62vLly+OPf/xjVm3gwIFx6623Vui9n3nmmXHOOedk1W666aZYvXp1medveC116dIl+vTpU+71/teWXEsAAMDXBAYAAACqmc8//zyuvfba6N69e7z55pulXu/Zs2eceOKJFZrzj3/8Y9SsWbNCY2699dZStV/96lfRpk2bcs/RpEmTuPbaa8s1d1XY8Bnvffv2jcGDB1d4niZNmsSFF16YVRsxYsRGzy8oKIhHH300q5afn1+uG5dsWqdOneKCCy6o8LhcXQuFhYVxzz33ZNUuu+yy6NChQ4XXPvjgg+PQQw8t99pbYsOb2BERLVq02CprbUy9evVK/d4257rrrot69epl1e65555YtWpVVbZWyne+852sIMnatWtj7NixmxxTVFQUf/3rX7NqtWvXjvvuu6/CoaLyuPvuu2PevHklxzVq1IhbbrmlUnNdddVVWSGDOXPmlPnfTxGlr6VtfR0BAADZBAYAAAC2I++8807ss88+ZX7ttttu0aJFi+jUqVNcfvnlMXfu3FLj27RpE4899liFPh3apUuXCn86OyJK7S5Qp06dOPvssys8zw9+8INo3rx5Vm3UqFGlPo2/pQoKCuLdd9/Nqm34qdiKGDhwYKn5p0+fXua5zz77bKn3c95550Xjxo0rvT5fO/PMMyv8SfBcXwsrVqzYamuPHj260nNtSlk3dd94442tstbGHHPMMdGqVasKjWnVqlUce+yxWbUFCxbE22+/XYWdlVajRo3o1KlTVu2tt97a5JjXXnstlixZklU78cQTN7lLwJZ4/PHHs4779+9fqeBKxNc7XnTr1i2rtrFrccNracKECeXafQEAANg68nLdAAAAAP+1bNmy+PDDDys1dp999omHH364wjeX+vbtW+G15syZU2pb6X79+pW68V8ederUiaOPPjr+/ve/l9SKioriww8/jG9961sVnm9jXnvttVK1gw8+uNLzlXVj7f333y/z51/WjbPTTjut0mvzXxV5hMB6ubwWNly7ffv2FdqVY3NrFxQUxKJFi6Jp06aVnrMsPXv2jBo1akRxcXFJ7Uc/+lE888wzseeee1bpWhuz4Y3/8ho0aFA89NBDWbW33norevfuXaF5Jk6cGOPGjYvx48fH9OnTY8mSJbF06dKN7lYwderUrOMZM2Zscv5t+Xdi1apVpXY82JJ/AxFfX4vjx48vOX7//ffLPK9Xr15Zx8uWLYsf/OAH8cADD1Tqv0MAAIAtIzAAAABQzbVr1y4uuOCC+L//+7+oVatWhcdX5qb8e++9V6q23377VXie9Xr27JkVGFi/RlUGBv7973+XqlX2BuTG/O/23v9rw6258/Pzo0uXLlW6dhplMpnYZ599Kjwul9fChmvPmzevUu9hvaKiojLXrurAQPPmzePoo4+Op556qqQ2bdq02HvvveOYY46Jk046KQ4//PCtumvGvvvuW6lxZf0d2XCHiY1ZtWpV3HLLLXHPPffExx9/XKn111u0aNEmX9/w70SNGjXigAMO2KI1N+bdd9+NlStXZtXuvvvurN9vRW0YiNjYv4Ejjjgidtppp5g9e3ZJ7YUXXoiOHTvGKaecEieccEJ8+9vfrtR/nwEAABUnMAAAAFBN1KlTJxo3bhxNmzaNXXfdNfbdd9845JBDol+/flv0fOuKbvEdUfaNoK5du1a6hz322KNca2yJmTNnlqpVdjeHjZk/f36Z9Q0fH7Hh1t1UTsOGDaN+/foVHpfLa2HDtbdkV5FNrd25c+cqnTMi4k9/+lO8/vrrsWDBgpLaunXr4sknn4wnn3wyatasGT169IgDDzwwevbsGYccckiVbaefl5dXaov/8urYsWPUrl07Vq9eXVIr65EuG/r3v/8dp59+enz22WeVWndDm9t2/6uvvso63mWXXaJRo0ZVsvaGyvo38MUXX8QXX3xRZWts7N9AvXr14tZbb40TTjghkiQpqS9evDiGDRsWw4YNi/r168eBBx4YvXr1il69ekXv3r2jWbNmVdYbAADwXwIDAAAA25E+ffpstWeQb0xlPhG8cOHCUrUt+URzWTeC/vemZFXY2M2rqrThs+kjIpYuXRpr1qzJqrnxVTUq+2n2XF0LK1asKLO+LdauCp06dYpXXnkljj/++Jg2bVqp19etWxfvvPNOvPPOOyW1XXbZJQYNGhSnnHLKFu0Y0qhRo8hkMpUe37hx46wQ0uY+7T9q1Kj43ve+F8uXL6/0mhva8O/Ahjb8m7c1/07k6t/AeoMGDYr7778/zj333Fi2bFmp15cvXx6vvvpqvPrqqxHx9W4LPXr0iMGDB8fJJ58cbdu23Wp9AwBA2lT+IygAAAB8I+TlVTxLvnTp0lK1Bg0aVLqHssaWtcaWKCvksC0sWbKkVK1hw4Y56OSbpzLXbkTuroVcrVuVevToERMnTozrrruuXDdtCwoK4sYbb4x99903DjvssPjggw8qte6W/H0pa/ym/r4sXLgwTjzxxFJhgRo1asThhx8ef/jDH+KFF16Ijz76KObNmxdFRUWxbt26SJIk66tPnz4V6nHDvxVb8+/E9nAtnnzyyTF58uQ4//zzN7uTQnFxcbz77rvxi1/8Ijp16hTnnHNOFBYWbqNOAQDgm80OAwAAAFRYWTd3yvqUaHmVNbaqt+KuV69eqdqKFSuibt26VbrOhsr6FHxZz51n28nVtVDWur169Yq33nprq65b1erXrx9Dhw6Nyy67LMaMGRMvv/xyvP766zFu3LhNfqr81VdfjV69esUdd9wRp59+eoXW3JK/L2WN39Tfl2uuuabUzej99tsvHnzwwejSpUu516zoTg+NGzfO2mVga/6dKOtavO222+K8887bamuWpU2bNvHXv/41/vSnP8ULL7wQI0eOjDFjxsTEiRNj3bp1ZY5Zs2ZN3HXXXfHss8/Gs88+u0U7VwAAAAIDAAAAVEJZW2VvbovvTSlrbPPmzSs9X1latmxZqrZgwYJo3bp1la6zoUaNGkWtWrWytiPfHj7dm2a5uhaaNm0aeXl5sXbt2qx1q6tMJhOHHHJIHHLIIRERsXbt2vjggw9izJgx8corr8SoUaNK3TRfvXp1nH322dGhQ4eSceWxdOnSSJKk0o8l2PDT+5t6hMrDDz+cddy2bdt45ZVXokmTJhVas6K/2xYtWmSN2Zp/Jzb2byBX6tWrF8cdd1wcd9xxEfF1WOKtt96KN954I1544YUYN25cFBcXZ42ZM2dODBw4MCZOnBgtWrTIRdsAAPCN4JEEAAAAVFh+fn6p2qRJkyo938cff1yqVtYNrS2xww47lKpNnz69StfYmB133DHreMKECdtkXcqWq2shk8mU+rcza9asrABBdZaXlxf77bdf/N///V88++yzMXfu3Pjb3/5WKoixbt26uOyyyyo099q1a+Pzzz+vVF/Tpk2L1atXZ9VatWpV5rmTJk2KmTNnZtV+9rOfVTgssGbNmlLzbM6GfycKCgqq/NEs6+Xy72F5NGzYMA477LD4zW9+E2+99VZMnz49Lr/88lK7gMyZMyeuv/76HHUJAADfDAIDAAAAVFhZW0C/8847lZ5v3LhxpWr77rtvpecrS69evUrVXn/99SpdY2MOPPDArOPCwsKYMmXKNlmb0nJ5LWy49vLly+Pdd9/dJmtvaw0bNowhQ4bEe++9F23bts167e23344vvviiQvNV9udU1riN/X0pq6fevXtXeM33338/Vq5cWaExG/6dKC4ujjfffLPCa5fHfvvtFzVqZP/fgtvq30Bl7LzzznHNNdfESy+9FDVr1sx67YknnshRVwAA8M0gMAAAAECF7bDDDtGxY8es2qhRoyq1pfXq1avj6aefzqo1bNgwunfvvkU9bmjAgAGlak8++WSVrrExffv2LVW77777tuqaeXnZTyHc2PPA0yiX10Iu186VHXbYIS655JJS9YrutPHUU09Vav2yfr4HHHBAmefOmzevVK0yj0d55JFHKjxmW/6daN68eanQxCeffFLmbi/bk969e8dRRx2VVfvss89i+fLlOeoIAACqP4EBAAAAKuWII47IOl61alXcc889FZ7nkUceifnz52fV+vfvX+pTpFtqjz32iC5dumTV3n777Rg5cmSVrlOW733ve6Vu4N9+++2lnqtelRo1apR1XFRUtNXWqm5yeS0MHDiw1LX9t7/9LRYtWrTV186l3XffvVRt8eLFFZrjqaeeisLCwgqNKSwsjH/+859ZtebNm8f+++9f5vkNGjQoVSsrRLApixYtirvvvrtCYyIi+vTpE82aNcuqPfroo1vtUQHHHHNMqdq11167VdaqSlVxLQEAAP8lMAAAAEClnH/++aVqv/3tb2P27NnlnmPJkiXx85//vFT9pz/96Rb1tjFXXHFFqdo555xTqZ0RKqJt27Zx8sknZ9UKCwvjxz/+8VZbc8Mbj9OmTYskSbbaetVNrq6F9u3bx2mnnZZVW7JkSZx55pnf6N9PWX8X8vPzKzTHihUr4he/+EWFxvziF78o9enzM888M+rUqVPm+TvttFOp2ksvvVShNX/yk59UKgBSv379Un/7Vq9eHaeddloUFxdXeL7N+clPfhJNmzbNqt1///0xYsSIKl+rKm14LWUymWjZsmWOugEAgOpPYAAAAIBK2WuvveLwww/Pqi1evDiOO+64cn2afdWqVXHCCSeUuvnTvXv3OOyww6q01/VOPfXUUp9OnTZtWnz3u9+NL7/8slJzLlmyJK6//vq4//77N3ne5ZdfHrVq1cqqPfjgg3HxxRdX+EbxunXrNvv8927dumUdL168OP7zn/9UaJ1vslxeC1dddVWpG9ZPPfVUnHvuubFq1apKrV1QUBA//elPY+LEiZUavzl///vf44knnqjUoy3WrFkTw4YNy6rVqFEj9tprrwrPdffdd8fw4cPLde6dd95Z6pP+tWrV2mRQp0ePHtGwYcOs2p///OeYOXNmudb8f//v/8UDDzxQrnPLcuGFF5a6iT9mzJg46aSTKnVtbGp3giZNmsRll12WVUuSJH74wx+W2pWhIp5//vlN/ox/85vfxNixYys19xdffFEq0NC1a9dSf1sBAIDyExgAAACg0oYNG1bq5trYsWOjd+/e8d5772103CeffBL9+/ePl19+Oateq1atuOuuu7ZKrxERNWvWjMcee6zUdv1jx46NHj16xLBhw2LlypWbnWft2rXxyiuvxLnnnhvt2rWLn//85zFnzpxNjtl9993jhhtuKFW/6aab4tBDD4133nlns+vOnj07/vznP8euu+662Z/TQQcdVKp21llnxahRo7bKp5Wrm1xeCx06dIjbb7+9VH348OFxwAEHxL/+9a9yhUiWLl0aDz74YBx77LHRuXPnuPXWW8vVc2V88MEHccIJJ0Tnzp3jV7/61Sb/ff+v6dOnx9FHHx3jxo3Lqh922GGx4447lnv9OnXqRCaTiYiIIUOGxBVXXLHRG+irVq2KK664Is4777xSr11xxRXRqVOnja5Tq1atOPbYY7NqCxcujEMPPTTGjx+/0XFffvllnHzyyfHrX/+6pNa4ceNNvaUyNW/ePO69996S97reo48+GgceeGC88sorm51j4cKFcdddd8Xee++d1U9Zhg4dWiqgVVRUFMcdd1yce+658fnnn5er708//TSuueaa2GuvveK73/1ujBkzZqPnPvXUU3HAAQfEAQccEH/+859jxowZ5VrjP//5T/Tv37/Uo1xOPfXUco0HAADKlrf5UwAAAKBsnTp1imHDhsUPf/jDrPoHH3wQPXv2jIMPPjiOPPLIaNu2bdSsWTNmzZoVr7zySowcOTLWrl1bar5rrrkm9ttvv63a81577RUPPPBADBo0KKuHuXPnxgUXXBBXXHFF9OnTJ3r16hWtWrWKJk2axLJly2LRokUxY8aMePfdd+P9998vddOqPH7605/G22+/XeoT6KNGjYqePXtG9+7dY8CAAdGxY8do2bJlrFmzJhYuXBiTJk2Kd955J955551y3+zv1atX7LHHHvHxxx+X1KZMmRL9+/ePevXqxc477xz169cvNe65556L1q1bV/i9VUe5vBZOP/30mDRpUlx33XVZ9Q8++CCOOuqoaNeuXfTr1y/23nvvaNGiRdSvXz8WL14cixYtiilTpsS7774bEyZMiNWrV2/xz6EiCgoK4ve//338/ve/j5122im+9a1vxT777BOtW7eOpk2bRu3ataOoqCgKCgriP//5T4wePTrWrFmTNUedOnXKDM9syo477hgDBw6MYcOGRXFxcVxzzTVx5513xvHHHx/du3ePFi1axPz582P8+PHx5JNPxty5c0vNse+++8Yvf/nLza515ZVXxiOPPJLV95QpU6JHjx5x5JFHRv/+/WPnnXeOtWvXxuzZs2P06NHxyiuvZAUYzjrrrPjss8/itddeq9D7jIg4+uij44orrojf/e53WfX3338/BgwYEF26dInDDz88dtttt8jPz48kSUqui/feey/efPPNkt579OixybXy8vLi0UcfjYMOOig++eSTknqSJCU7NOy3335xyCGHRIcOHaJ58+ZRXFwcixYtisLCwhg/fny8++67UVBQUOH3OXbs2Bg7dmxcdNFFsdtuu8U+++wT3bp1i/z8/JJdFta/r1GjRpUZUunSpUtceOGFFV4bAAD4L4EBAAAAtshpp50Wa9asiSFDhmTddC0uLo4xY8Zs8pOm62Uymbj22mvj0ksv3ZqtljjqqKPi1VdfjRNPPLHUp8EXLVoU//znP7doS+5Nuffee2OHHXYo84bp+PHjN/kp5oq65ZZb4vDDDy+1jfyKFSvi008/LXPMtr4BnWu5vBauvfbaaNu2bVx88cWlfu4zZsyIe++9d6usW1Vmz54dzz77bDz77LPlHlOnTp247777KvU4ghtvvDHGjx8fb7zxRkREFBYWxt/+9rdyje3evXu8+OKL5dq6ftddd41bbrml1A4FxcXF8dxzz8Vzzz23yfH9+/ePYcOGxRFHHFGu3sry29/+Npo3bx6XXnppqZDQp59+utF/v5XRrFmz+M9//hOnnXZaqd/lunXrSm7sb02TJ0+OyZMnxyOPPFLuMTvvvHOMGDGizOATAABQfh5JAAAAwBY766yz4vnnn49dd921wmPbtm0bjz/+eAwdOnQrdLZxhxxySLz33ntx6qmnRs2aNSs9TyaTiX79+kXv3r3LdX6NGjXiT3/6Uzz88MOxyy67VHrN/Pz8zZ7Xv3//GDFiROywww6VWictcnUtRERccMEFMWbMmPj2t79d6XUjIurVqxc/+MEPol27dls0z8a0atWq1Db5FbXXXnvFyJEjY/DgwZUaX6dOnXjhhRfimGOOqdC4o48+Ol599dVo0aJFuccMGTIkhg0bFrVr167QWmeddVY899xzUadOnQqNK8v//d//xYsvvhjdunWr9Bzl/bffrFmzeOaZZ+Lmm2/e4r8X7du3jzPPPHOjr1fkURQbc9RRR8Vbb70Ve+655xbPBQAAaScwAAAAQJU47LDD4qOPPorbb789Dj744E3eeM1kMrHvvvvGDTfcEFOmTIlBgwZtw07/a6eddor77rsvPv3007jooouia9eu5RrXqFGj+N73vhc333xzTJs2LUaOHBm9evWq0NonnnhiTJkyJW6//fbo06dPuW5Mdu/ePS6//PKYPHlyXHDBBeVa56ijjoqCgoJ49NFH4+yzz479998/dtxxx2jQoMEW3wD+JsnltbD//vuX7MZxyimnlPuREK1bt47TTjst/vGPf8Ts2bPjoYceilatWlVo7fL65S9/GbNnz4677rorTjnllOjQoUO5xtWqVSu+853vxAMPPBAffPBBHHTQQVvUR4MGDeKpp56Kxx57LHr27LnR8zKZTHz729+OJ554Iv75z39Gy5YtK7zWj3/843jvvffixBNP3OTOBLVr146jjjoqXn/99bjrrruqJCyw3mGHHRYffvhhPPzww3HkkUeW69P0u+66a/zsZz+L9957r9QjLzYlk8nEhRdeGAUFBTFs2LDo169f1K1bd7PjatSoEd/61rdi6NChMXr06Jg2bVpccsklGz3/hRdeiI8//jj+9Kc/xfe+971y/26aNGkSp59+erz22mvx9NNPR5s2bcr93gAAgI3LJEmS5LoJAAAAvnkWLVoUb731Vnz11VdRWFgY69ati/z8/Nhhhx2iZ8+eW3xjs23btjFz5syS47PPPjuGDx++pW3HV199Fe+9917Mmzcv5s+fH0VFRdGgQYNo3LhxtGnTJnbfffdo3759ld9sX7ZsWYwdOzZmz54d8+bNi6VLl0aDBg2iadOm0blz59hjjz0q9AlptlyuroWIiClTpsSkSZNi/vz5MX/+/FizZk00atQoGjduHB06dIjdd999q4UDymv+/Pnx6aefxueffx7z5s2LoqKiiPg6RNG8efPo2rVr7LnnnpW6gX7GGWdkPZKhffv2UVBQUOq8mTNnxrhx46KgoCCWLVsWzZs3j5122in233//Kr2hvGzZsvjPf/4Tn3/+eSxYsCAymUw0b948unTpEj179oyGDRtW2VqbsmrVqhg3blzMnDkzCgsLY/HixVGvXr1o0qRJdOzYMfbYY48q+QT//673zjvvxKxZs2L+/PmxcOHCyMvLi0aNGkXLli1j1113jd12261cwYJNmTFjRnz22WdRUFAQixYtimXLlkWtWrWicePG0apVq+jWrVt07tw5atTw2ScAAKhqAgMAAABUSy1btoz58+eXHF900UVx00035bAjoKqUNzAAAADAlhHLBQAAoNpZvXp1LFy4MKvWpEmTHHUDAAAAUD0JDAAAAFDtTJo0KYqLi7Nqu+++e466AQAAAKieBAYAAACodh5++OFStR49euSgEwAAAIDqKy/XDQAAAEB5LV++PO6888644YYbsup77bVX7LbbbjnqCgAAAKB6EhgAAABgu/a3v/0t/va3v0VRUVFMnz491q5dW+qcn/3sZznoDAAAAKB6ExgAAABguzZnzpz48MMPN/r6YYcdFuecc8427AgAAADgm6FGrhsAAACAyjrppJPi6aefjkwmk+tWAAAAAKodOwwAAABQLdSqVSuaNm0a7dq1i969e8dpp50W3/rWt3LdFgAAAEC1lUmSJMl1EwAAAAAAAADAtuWRBAAAAAAAAACQQgIDAAAAAAAAAJBCAgMAAAAAAAAAkEICAwAAAAAAAACQQgIDAAAAAAAAAJBCebluIO2SJImCgoKYMGFCzJw5MxYtWhR16tSJZs2aRZcuXaJnz55Rt27dXLcJAAAAAAAAwDeMwEAOLFy4MJ566ql44YUXYuTIkTFv3ryNnlurVq0YOHBgXHTRRdGnT58KrVNQUBAdOnTYol6TJNmi8QAAAAAAAABsnzKJO8Lb1AUXXBDDhw+P1atXV3jsD3/4w7jllluicePG5TpfYAAAAAAAAACAjbHDwDY2duzYMsMCNWvWjJ122il22GGHWLNmTUyfPj0WL16cdc4//vGP+OSTT+LVV1+Nhg0bbquWAQAAAAAAAPgGEhjIoaZNm8bJJ58cAwcOjN69e0ejRo1KXlu3bl2MGTMmrrrqqhgzZkxJ/e23344zzjgjHn/88Qqvd/jhh8dll11WJb0DAAAAAAAAUL15JME2tt9++8X8+fPjV7/6VZx88slRr169TZ6/bt26OP/88+OOO+7Iqo8cOTL69eu3ybEbPpLg9NNPj7///e+V7h0AAAAAAACAbw47DGxjV199dQwYMCBq165drvNr1qwZw4YNi/feey/eeeedkvrw4cM3Gxj4pli0aFG89tprJcdt27aNOnXq5LAjAAAAAAAAgKqxatWq+OKLL0qO+/TpE02bNt0mawsMbGMDBw6s8JiaNWvG0KFD4/vf/35J7cUXX6zKtrZrr732Whx77LG5bgMAAAAAAABgq3vqqafimGOO2SZr1dgmq7DFevfunXU8f/78WL58eY66AQAAAAAAAKC6ExioJpo1a1aqtnjx4hx0AgAAAAAAAMA3gUcSVBOzZs0qVWvRokUOOtn22rZtm3X81FNPRefOnXPUDQAAAAAAAEDVmTp1atYj2je8P7o1CQxUE2PGjMk6bt++fdSuXbtSc33xxRcxZ86cWLlyZTRv3jxatWoV+fn5VdHmVlGnTp2s486dO8eee+6Zo24AAAAAAAAAtp4N749uTQID1cTdd9+ddfzd7363wnO89NJL0bp165g9e3ap13bZZZfo27dvnHvuuXHggQdWuk8AAAAAAAAAqgeBgWrgueeei9dffz2rdsYZZ1R4nrKCAusVFBTE3//+9/j73/8e/fv3j3vuuSfatWtX4TU2Z+7cuVFYWFihMVOnTq3yPgAAAAAAAADSTmBgO7dgwYIYMmRIVu3YY4+N/ffff6utOXLkyOjRo0eMGDEiDjnkkCqde9iwYXH11VdX6ZwAAAAAAAAAVFyNXDfAxhUXF8epp54aM2fOLKk1adIk/vKXv1Ronp133jl+/OMfx2OPPRaTJk2KRYsWxZo1a2LevHkxbty4uP7666Njx45ZYxYsWBDHHHNMfPLJJ1XyXgAAAAAAAADYvthhYDt22WWXxfPPP59Vu/3226Nt27blGt+kSZN4+umnY+DAgVGjRulsSIsWLaJFixax3377xcUXXxy//e1v47e//W0UFxdHRMSiRYvi1FNPjXHjxkUmk9nyNwQAAAAAAADAdiOTJEmS6yYo7S9/+UtceOGFWbWhQ4fGddddt1XX/fOf/xwXXXRRVu3xxx+P448/vkrmnzt3bhQWFlZozNSpU+PYY48tOZ44cWLsueeeVdIPAAAAAAAAQC599NFHsddee5Ucb8v7oXYY2A49+OCDpW7an3HGGXHttddu9bUvvPDCGDFiRLz22msltfvuu6/KAgOtWrWKVq1aVclcAAAAAAAAAFRe6X3qyal//etfcfrpp8f/bvwwaNCgGD58+DZ7LMAll1ySdTxy5MhYu3btNlkbAAAAAAAAgG1DYGA7MmrUqBg8eHDWzfkBAwbEQw89FDVr1txmffTv3z8rnLB06dKYPXv2NlsfAAAAAAAAgK1PYGA7MXbs2Dj66KNj5cqVJbWDDjooRowYEbVr196mvTRo0CCaNWuWVSssLNymPQAAAAAAAACwdQkMbAfGjx8f3/nOd6KoqKik1qNHj3juueeiQYMGOempVq1aWcdr1qzJSR8AAAAAAAAAbB0CAzk2efLkGDBgQCxcuLCk1rVr13jxxRejSZMmOelp7dq1MX/+/Kxafn5+TnoBAAAAAAAAYOsQGMih6dOnx2GHHRZz584tqXXo0CFefvnlnN6gf+utt2Lt2rUlx3l5ebHjjjvmrB8AAAAAAAAAqp7AQI7Mnj07Dj300Jg5c2ZJrU2bNvHqq69GmzZtcthZxF133ZV1fOCBB0b9+vVz1A0AAAAAAAAAW4PAQA4sWLAgBgwYEJ999llJLT8/P15++eXo0KFDDjuLGD16dNx3331ZtWOPPTY3zQAAAAAAAACw1QgMbGNLly6NI488Mj766KOSWtOmTeOll16Krl27Vtk6L7/8ctxzzz1ZjxbYnJEjR8agQYNi3bp1JbWddtopzjvvvCrrCwAAAAAAAIDtQ16uG0ibo48+OsaNG5dVu/jii2PevHnxyiuvVGiufffdN5o1a1bma7NmzYqzzjorrrzyyhg8eHAcffTR8a1vfSuaNGmSdd66devinXfeiWHDhsX9998fxcXFJa/VqFEj/vrXv3ocAQAAAAAAAMA3kMDANjZ69OhStauuuqpSc40aNSr69u27yXNmzZoVN998c9x8880REdGmTZto3rx5NGjQIJYsWRIzZsyIoqKiUuMymUzcfPPNcdxxx1WqNwAAAAAAAAC2bwIDKTNr1qyYNWvWJs/Zaaed4t57740BAwZso64AAAAAAAAA2NZq5LoBto7+/fvH1VdfHX379o1GjRpt9vwaNWrEt771rfjb3/4WU6dOFRYAAAAAAAAA+Iazw8A2liTJNlmnXbt2cdVVV8VVV10VSZLEZ599FlOnTo0vvvgiFi1aFCtXrowGDRpEs2bNom3btrH//vtH48aNt0lvAAAAAAAAAOSewEAKZDKZ6Ny5c3Tu3DnXrQAAAAAAAACwnfBIAgAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASKG8XDcA5EbmJw/kugXYLiW3npLrFgAAAAAAALYJOwwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAKCQwAAAAAAAAAQAoJDAAAAAAAAABACgkMAAAAAAAAAEAK5eW6AQCg6mV+8kCuW4DtUnLrKbluAQAAAABgu2GHAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIIYEBAAAAAAAAAEghgQEAAAAAAAAASCGBAQAAAAAAAABIobxcN5B2SZJEQUFBTJgwIWbOnBmLFi2KOnXqRLNmzaJLly7Rs2fPqFu3bpWuuXTp0vj3v/8dU6ZMiSVLlkS9evWiffv2cdBBB0Xr1q2rdC0AAAAAAAAAtk8CAzmwcOHCeOqpp+KFF16IkSNHxrx58zZ6bq1atWLgwIFx0UUXRZ8+fbZo3WnTpsVVV10Vjz76aKxevbrU65lMJvr06RNXX311HHLIIVu0FgAAAAAAAADbN48k2MYuuOCC2HHHHeOss86KRx99dJNhgYiINWvWxFNPPRV9+/aN008/PZYsWVKpdR999NHYa6+94v777y8zLBDx9W4Ho0ePjr59+8YvfvGLSJKkUmsBAAAAAAAAsP2zw8A2Nnbs2DJv2NesWTN22mmn2GGHHWLNmjUxffr0WLx4cdY5//jHP+KTTz6JV199NRo2bFjuNR977LE46aSTori4OKuen58fbdu2jblz58asWbNKAgJJksR1110Xq1atiptuuqkS7xIAAAAAAACA7Z0dBnKoadOmcf7558ezzz4bCxcujC+++CLeeeed+PDDD2P+/PkxatSo6N27d9aYt99+O84444xyr/HZZ5/FmWeemRUW2HvvvWPkyJExd+7cePfdd+OLL76ISZMmxaBBg7LG3nzzzfHkk09u0XsEAAAAAAAAYPskMJADu+yySwwfPjy+/PLL+Otf/xrf/e53o1GjRlnn1KxZM/r27RujRo2Kc889N+u1J554IkaNGlWuta688spYtmxZyXHPnj3j9ddfj379+mWdt9tuu8Xjjz9eaq2hQ4fG2rVrK/L2AAAAAAAAAKgGBAa2sauvvjomT54cZ599dtSrV2+z59esWTOGDRsW++23X1Z9+PDhmx370UcfxSOPPFJyXLt27bj33nujcePGZZ6fyWTiz3/+c3Tp0qWk9tlnn8U999yz2bUAAAAAAAAAqF4EBraxgQMHRu3atSs0pmbNmjF06NCs2osvvrjZcXfffXfWowh+8IMfRNeuXTc5pm7duvGLX/wiq1aecAIAAAAAAAAA1YvAQDXRu3fvrOP58+fH8uXLNznm6aefzjo+++yzy7XWiSeeGA0aNCg5HjduXHz55Zfl7BQAAAAAAACA6kBgoJpo1qxZqdrixYs3ev7kyZNj6tSpJccNGjSIgw46qFxrbXhukiTx7LPPVqBbAAAAAAAAALZ3AgPVxKxZs0rVWrRosdHzP/jgg6zj/fffP/Ly8sq93sEHH7zJ+QAAAAAAAACo3gQGqokxY8ZkHbdv3z5q16690fMnTZqUdbzHHntUaL0Nz99wPgAAAAAAAACqN4GBauLuu+/OOv7ud7+7yfMnT56cddy2bdsKrbfh+RvOBwAAAAAAAED1Vv496smZ5557Ll5//fWs2hlnnLHJMXPnzs063nnnnSu0Zps2bbKOCwsLKzR+Y+bOnVvhuaZOnVolawMAAAAAAADwXwID27kFCxbEkCFDsmrHHnts7L///pscV1RUlHXcoEGDCq274flr1qyJVatWRZ06dSo0z4aGDRsWV1999RbNAQAAAAAAAMCW80iC7VhxcXGceuqpMXPmzJJakyZN4i9/+ctmx24YGKhbt26F1q5Xr95m5wQAAAAAAACg+hIY2I5ddtll8fzzz2fVbr/99mjbtu1mx65cuTLruHbt2hVau6ydBFasWFGhOQAAAAAAAADYfnkkwXbqL3/5S9x4441ZtaFDh8aJJ55YrvEb7iiwevXqCq2/atWqzc5ZGeeff34MHjy4QmOmTp0axx577BavDQAAAAAAAMB/CQxshx588MG46KKLsmpnnHFGXHvtteWeo2HDhlnHG+44sDll7Saw4ZyV0apVq2jVqtUWzwMAAAAAAADAlvFIgu3Mv/71rzj99NMjSZKS2qBBg2L48OGRyWTKPc+GN/eXLVtWoT42PD8vL69KdhgAAAAAAAAAYPsgMLAdGTVqVAwePDjWrl1bUhswYEA89NBDUbNmzQrNteGn+GfOnFmh8bNmzco6zs/Pr9B4AAAAAAAAALZvAgPbibFjx8bRRx+d9eiAgw46KEaMGBG1a9eu8Hy77bZb1vGMGTMqNH7D83ffffcK9wAAAAAAAADA9ktgYDswfvz4+M53vhNFRUUltR49esRzzz0XDRo0qNScG97g//jjjys0ftKkSZucDwAAAAAAAIDqTWAgxyZPnhwDBgyIhQsXltS6du0aL774YjRp0qTS8+6zzz5Zx+PGjct61MHm/Pvf/97kfAAAAAAAAABUbwIDOTR9+vQ47LDDYu7cuSW1Dh06xMsvvxz5+flbNPfuu+8enTp1KjletmxZ/Oc//ynX2GXLlsWbb75ZcpzJZOJ73/veFvUDAAAAAAAAwPZFYCBHZs+eHYceemjMnDmzpNamTZt49dVXo02bNlWyxtFHH511fNddd5Vr3COPPJL1eIT99tsvWrduXSU9AQAAAAAAALB9EBjIgQULFsSAAQPis88+K6nl5+fHyy+/HB06dKiydc4666zIZDIlxw8//HBMmjRpk2NWrlwZ1157bVbt7LPPrrKeAAAAAAAAANg+CAxsY0uXLo0jjzwyPvroo5Ja06ZN46WXXoquXbtW6Vp77bVXfP/73y85Xr16dZx++umxZMmSMs9PkiQuuuii+PTTT0tqHTt2jLPOOqtK+wIAAAAAAAAg9/Jy3UDaHH300TFu3Lis2sUXXxzz5s2LV155pUJz7bvvvtGsWbNNnvO73/0unnnmmVi+fHlERIwbNy4OOeSQuPnmm6Nv374l502ZMiUuv/zyePLJJ7PGX3vttVGrVq0K9QUAAAAAAADA9k9gYBsbPXp0qdpVV11VqblGjRqVddO/LJ07d4677rorTj755EiSJCIiPvzww+jXr1/k5+dHu3btYu7cuTFz5syS19f76U9/GoMHD65UbwAAAAAAAABs3wQGUuAHP/hBJEkSZ599dqxYsaKkXlhYGIWFhWWOufTSS+P666/fVi0CAAAAAAAAsI3VyHUDbBsnnXRSTJw4MU4++eRNPmLgkEMOidGjR8cf//jHyGQy27BDAAAAAAAAALYlOwxsYxtu+78tdezYMR544IG47bbb4o033ohPP/00li5dGnXr1o127drFwQcfHG3atMlZfwAAAAAAAABsOwIDKdS4ceP47ne/m+s2AAAAAAAAAMghjyQAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBTKy3UDaTdr1qx4++23Y+zYsfH222/HO++8E0uXLi15vX379lFQUFCpuTOZzBb1Nm3atNhll122aA4AAAAAAAAAtk8CAznw73//O2644YYYO3ZsfPnll7luBwAAAAAAAIAUqlaPJDjppJNi9OjRuW5ji40bNy5GjBghLAAAAAAAAABAzlSrHQYeeeSRePTRR6Njx47xox/9KM4444xo1apVrtuqUg0bNoyioqIqn7d79+5xww03VGjMjjvuWOV9AAAAAAAAALB9qFaBgfU+++yzuPzyy+PKK6+Mo446Ks4555w48sgjc91WhTVq1Cj23Xff6NmzZ+y///7Rs2fPmDZtWvTr16/K12rWrFkcdthhVT4vAAAAAAAAANVTtQwMZDKZSJIk1qxZEyNGjIgRI0ZE27Zt4+yzz44zzzwzdt5551y3uElHHXVUHH744bH77rtHjRrZT4WYNm1ajroCAAAAAAAAIE1qbP6U7cdTTz0VAwcOLLnJnslkIiIiSZKYMWNG/OY3v4kOHTrE9773vXj66aejuLg4l+1uVKdOnWKPPfYoFRYAAAAAAAAAgG2lWt2xPvroo+Ppp5+O6dOnx9VXXx3t27ePJEki4r+7Dqxbty6ef/75OO6446Jt27bxq1/9KgoKCnLbOAAAAAAAAABsZ6pVYGC91q1bx5VXXhmff/55vPjii3H88cdHrVq1IiJ714HZs2fHH/7wh+jcuXMcfvjh8fjjj8fatWtz2ToAAAAAAAAAbBeqZWDgfw0YMCAee+yxmDlzZlx//fWx6667Zu06EBFRXFwcr776apx44onRpk2bGDp0aEyePDmXbQMAAAAAAABATlX7wMB6LVu2jEsvvTQmTZoUr7/+epx66qlRt27dSJIka9eBwsLCuOGGG2KPPfaIPn36xAMPPBCrVq3KcffbzuzZs+Pdd9+N119/PSZMmBCzZ8/OdUsAAAAAAAAA5EBerhvYGr797W/Ht7/97bjlllvi/vvvj+HDh8eHH34YEV/vOrB+B4I33ngj3njjjfjZz34Wp556apxzzjnRrVu3XLa+1UyYMCE6duwY06ZNK/XajjvuGH369IkzzjgjjjzyyK3ax9y5c6OwsLBCY6ZOnbqVugEAAAAAAABIr29kYGC9Jk2axAUXXBAXXHBBjBs3LoYPHx4PP/xwFBUVRUSUBAcWLlwYt956a9x6663Rq1ev+MlPfhKDBw+OWrVq5bL9KrVgwYJYsGBBma/NmTMnHnnkkXjkkUeiR48ece+992614MSwYcPi6quv3ipzAwAAAAAAAFB+35hHEmxOz5494+KLL46TTjqpJCiQyWRKviK+DhCMHTs2TjvttOjUqVPccccduWw5J95///3o1atXPPbYY7luBQAAAAAAAICt6BsfGFi1alXcf//90adPn9hjjz3izjvvLAkIRHwdElj/9b+1mTNnxo9//OM4+OCDY/bs2blovUq0bNkyzjjjjLj//vtj/PjxsWDBglizZk0sXLgwPvzww7j11ltj7733zhqzYsWKOPXUU+P111/PUdcAAAAAAAAAbG3f2EcSTJgwIe6888544IEHYtGiRRHxdRAgk8mUhAMaNmwYJ510Upx11lnx8ccfx/Dhw+PNN9+MiCg5780334x+/frFe++9F/Xr18/V26mU+++/PwYPHhy1a9cu9VrTpk2jadOm0b1797jgggvi9ttvjwsvvDBWrVoVERGrV6+Ok08+OaZOnRp169atsp7OP//8GDx4cIXGTJ06NY499tgq6wEAAAAAAACAb1hgYNmyZfHQQw/F8OHDY9y4cRERWY8fWH+89957x5AhQ+LUU0+Nhg0bRkREr1694swzz4wJEybEddddFw899FBJaODTTz+NW265JX7+85/n5o1V0imnnFLuc4cMGRL5+fkxePDgKC4ujoiIWbNmxV//+te45JJLqqynVq1aRatWrapsPgAAAAAAAAAq5xvxSIJx48bFueeeGzvttFMMGTIkxo0bVyooULdu3Tj99NPjzTffjPfffz/OO++8krDA/+rWrVvcf//98corr0SdOnVKQgNPPPHENn1PuTBo0KA47bTTsmr33XdfjroBAAAAAAAAYGuqtoGBxYsXx1//+tfYZ5994oADDoi77rorioqKSoICEV/vJrD77rvHzTffHF9++WXcc8890atXr3LN369fv/jRj35UMt/kyZO3yvvY3my4m8D48ePjq6++ylE3AAAAAAAAAGwt1e6RBG+88Ubceeed8fjjj8fKlSuzdhJYvxtA7dq14/jjj48hQ4ZE7969K73Wt7/97bjlllsiIqKoqKhK+t/edevWLVq1ahVz586NiK9DF1OmTIkddtghx50BAAAAAAAAUJWqVWCga9euMWXKlIiIrKBAkiSRJEl06dIlzj333DjjjDOiRYsWW7xe8+bNS9ZIk5133rkkMBARUVhYmMNuAAAAAAAAANgaqlVgYPLkySU379cHBfLy8uKYY46JIUOGxKGHHrpV1k2SJFWhgVq1amUdr1mzJkedAAAAAAAAALC1VKvAwHpJksQuu+wSP/rRj+Kss87aatvl77vvvjFq1KitMvf2bM6cOVnH+fn5OeoEAAAAAAAAgK2lWgUGatasGQMHDozzzjsvjjjiiK3+qf+mTZtGnz59tuoa25uZM2fG9OnTs2pt27bNUTcAAAAAAAAAbC3VKjBQUFAQbdq0yXUb32h33XVX1nHbtm2jS5cuOeoGAAAAAAAAgK2lRq4bqAhhga1r0qRJccMNN2TVjj322Nw0AwAAAAAAAMBWVa0CA5TPBx98EDfddFMsX768QmOOPPLIWLp0aUmtXr168Ytf/GJrtAgAAAAAAABAjlWrRxJ8k/z73/+OFStWlKp/+OGHWccrV66MV155pcw5WrduHXvssUep+qJFi+Liiy+O3//+9zFo0KA47rjjomfPntGyZcus85IkiYkTJ8add94Zd9xxR6xatSrr9T/84Q/RunXrir41AAAAAAAAAKqBahUYGD9+fNYW+ffcc0/06dOnwvOMHj06zjrrrIiIyGQy8fzzz8euu+5aVW2WyymnnBLTp0/f7HlfffVVDBgwoMzXTj/99Pj73/++0bHz58+PO++8M+68886IiNhhhx2iZcuW0ahRoygqKopZs2bFwoULyxx7ySWXxIUXXrj5NwIAAAAAAABAtVStAgO33XZbFBQURETEHnvsUamwQERE3759o06dOjF58uTIZDJx++23xw033FCFnW6fvvrqq/jqq682eU7jxo1j2LBhccopp2yjrgAAAAAAAADIhRq5bqAi/vnPf0bE17sCnHrqqVs01w9/+MOI+Hpb/hEjRmxxb9uTbt26xXXXXRdHHnlkNG/evFxjdt9997j++uujoKBAWAAAAAAAAAAgBarNDgOTJk2KOXPmlBwfc8wxWzTfMcccE1dccUVEREyfPj2mTZsWHTp02KI5K2L9TglbQ4sWLWLo0KExdOjQiPj6/X366acxY8aMWLhwYaxYsSLq1q0bzZo1i5122il69eoVLVq02Gr9AAAAAAAAALD9qTaBgY8//rjk+4YNG0bXrl23aL6uXbtGw4YNo6ioKCIiJk6cuE0DA9tS+/bto3379rluAwAAAAAAAIDtSLV5JMGsWbMi4uvHEbRt23aL58tkMtGuXbuS4xkzZmzxnAAAAAAAAABQXVSbwMD6nQAiIho3blwlczZq1Kjk+6VLl1bJnAAAAAAAAABQHVSbwMD/3txfuHBhlcy5aNGiku9r165dJXMCAAAAAAAAQHVQbQIDLVu2jIiIJEniiy++iDVr1mzRfKtXr44vvvii5Dg/P3+L5gMAAAAAAACA6qTaBAY6depU8v2KFSvitdde26L5XnvttVi+fHnJcfv27bdoPgAAAAAAAACoTqpNYGC//faLJk2aRCaTiYiIP/zhD1s037XXXlvyfYMGDeLAAw/covkAAAAAAAAAoDqpNoGBGjVqxHe/+91IkiSSJInRo0fHTTfdVKm5brzxxhg1alRkMpnIZDJxxBFHRK1ataq4YwAAAAAAAADYflWbwEBExBVXXBE1atSITCYTSZLEZZddFldddVWsW7euXOPXrVsXV155ZQwdOrRkjkwmE1deeeVW7hwAAAAAAAAAti/VKjCwxx57xLnnnltyo7+4uDh+//vfx+677x433XRTfPLJJ2WO++STT+LGG2+M3XffPa655pooLi6OiIhMJhNnn312dO/efVu+DQAAAAAAAADIubxcN1BRf/nLX+Kjjz6KMWPGlOwS8Nlnn8Wll14al156aTRo0CBatmwZDRs2jKKiopg3b14sW7YsIiKSJImIKBnXt2/f+Otf/5rLtwMAAAAAAAAAOVGtdhiIiMjLy4tnnnkmjj322JKdBtYHAJIkiaKioigoKIiJEydGQUFBFBUVlbz2v+eecMIJ8c9//jPy8qpdZgIAAAAAAAAAtli1CwxERDRu3DiefPLJuO2226Jt27ZZOwds7Cvi6x0G2rdvH8OHD49HH300GjVqlMu3AQAAAAAAAAA5U60/Xj9kyJA455xz4sknn4yXXnopxowZE59//nmsXbu25Jy8vLzo3Llz9O7dO4488sg45phjokaNapmTAAAAAAAAAIAqU60DAxERNWvWjMGDB8fgwYNLakuXLo2lS5dGo0aN7CIAAAAAAAAAAGWo9oGBsggKAAAAAAAAAMCm2ZsfAAAAAAAAAFJIYAAAAAAAAAAAUkhgAAAAAAAAAABSKC/XDVSVNWvWxOLFi2PFihWRJEmFx7dr124rdAUAAAAAAAAA26dqGxhYuHBh3H///fH888/He++9F4WFhZWeK5PJxNq1a6uwOwAAAAAAAADYvlXLwMDNN98cV155ZSxfvjwiolI7CgAAAAAAAABAmlW7wMB5550Xd955Z0lIIJPJRCaTERoAAAAAAAAAgAqoVoGBe++9N+64446IiJKQQJIk0axZs+jWrVu0atUqGjRokOMuAQAAAAAAAGD7V60CA1dddVVE/DcssPfee8e1114bAwYMiBo1auS4OwAAAAAAAACoPqpNYOD999+PL774IjKZTEREHHTQQfHyyy9HvXr1ctwZAAAAAAAAAFQ/1eZj+R988EFERCRJEhERt956q7AAAAAAAAAAAFRStQkMFBYWlnzfunXr2GeffXLXDAAAAAAAAABUc9UmMLD+UQSZTCbatGmT424AAAAAAAAAoHqrNoGBdu3alXxfVFSUw04AAAAAAAAAoPqrNoGBgw46KCIikiSJgoKCWL16dY47AgAAAAAAAIDqq9oEBtq2bRv9+vWLiIgVK1bE888/n+OOAAAAAAAAAKD6qjaBgYiIa6+9NmrWrBkREVdccUWsXLkyxx0BAAAAAAAAQPVUrQIDPXv2jBtuuCGSJIlJkybF8ccfH0uXLs11WwAAAAAAAABQ7VSrwEBExM9+9rO47bbbolatWvHCCy9E9+7d44477oiFCxfmujUAAAAAAAAAqDbyct1ARfTv37/k+/z8/Jg1a1ZMnz49fvzjH8f5558fu+yyS7Rq1Srq1q1boXkzmUy8+uqrVd0uAAAAAAAAAGy3qlVgYPTo0ZHJZEqO13+fJEkkSRKff/55TJs2rUJzJkmSNScAAAAAAAAApEG1CgxsjBv+AAAAAAAAAFAx1S4wkCRJrlsAAAAAAAAAgGqvWgUGiouLc90CAAAAAAAAAHwj1Mh1AwAAAAAAAADAticwAAAAAAAAAAApJDAAAAAAAAAAACkkMAAAAAAAAAAAKSQwAAAAAAAAAAAplJfrBrbU1KlTY8SIETFmzJiYNGlSLFiwIBYvXhwRES+99FL079+/1JjZs2fHmjVrIiKiXr16kZ+fv017BgAAAAAAAIBcq7aBgc8//zwuueSSeOaZZyJJkoiIkv+MiMhkMhsd+5vf/CaGDx8eERH5+fkxa9asqFmz5tZtGAAAAAAAAAC2I9XykQRPPPFEfOtb34qnn346iouLs17bVFBgvUsuuSQivg4YFBYWxr/+9a+t0icAAAAAAAAAbK+qXWDgueeeix/84AexZMmSklqSJLHDDjtEz549s3YZ2Jhdd901Dj744JLjJ598cqv0CgAAAAAAAADbq2oVGCgsLIyTTjop1q1bF5lMJpIkicGDB8eHH34YX375ZYwdOzYiyrfLwPHHHx8RX4cNXnnlla3aNwAAAAAAAABsb6pVYOC3v/1tLF26tOT4+uuvj0ceeSS6detW4bn69etX8v2cOXNixowZVdIjAAAAAAAAAFQH1SYwUFxcHPfff39kMpnIZDJxwgknxKWXXlrp+fbYY4+oXbt2yfGkSZOqok0AAAAAAAAAqBaqTWDgrbfeikWLFkWSJBER8atf/WqL5svLy4s2bdqUHNthAAAAAAAAAIA0qTaBgU8//bTk+1atWlXqMQQbatq0acn3ixcv3uL5AAAAAAAAAKC6qDaBgcLCwoiIyGQysfPOO1fJnHl5eSXfr127tkrmBAAAAAAAAIDqoNoEBmrU+G+rxcXFVTLnggULSr5v1qxZlcwJAAAAAAAAANVBtQkM5OfnR0REkiQxZ86cLZ5v+fLlMX369MhkMlnzAwAAAAAAAEAaVJvAwC677FLy/Zw5c2L69OlbNN+oUaNi7dq1kSRJRETss88+WzQfAAAAAAAAAFQn1SYwcMABB0TDhg1LdgT4+9//vkXz3XTTTSXft2vXLjp27LhF8wEAAAAAAABAdVJtAgO1atWKI488MpIkiSRJ4sYbb4yCgoJKzTV8+PAYOXJkZDKZyGQy8f3vf79qmwUAAAAAAACA7Vy1CQxERPz617+OGjVqRCaTiaVLl8YRRxxR4dDA7bffHj/5yU8ik8lEkiRRr169uPTSS7dOwwAAAAAAAACwnapWgYE999wzfvzjH0eSJJHJZOLTTz+Nbt26xZVXXhlTpkwpdf76xxfMmTMnHnzwwTjooIPi/PPPj9WrV5fM8Zvf/Cby8/O39VsBAAAAAAAAgJzKy3UDFXXzzTfHp59+Gi+99FJkMplYtmxZXHPNNXHNNddEgwYNIiJKwgDf//73Y8WKFbFixYqS8etfS5Ikvv/979tdAAAAAAAAAIBUqlY7DERE1KxZM0aMGBGnnXZayc3/iK+DAEVFRVnH8+fPj+XLl0eSJJEkSckcSZLEkCFD4r777svJewAAAAAAAACAXKt2gYGIiHr16sW9994bDz30UOy2224lYYD1YYFMJlPqK+LroEDnzp3joYceittuuy3y8qrdBgsAAAAAAAAAUCWq9R3zE088MU488cR48cUX47nnnosxY8bEpEmTYtWqVSXn5OXlRfv27aNfv35x5JFHxrHHHhs1alTLnAQAAAAAAAAAVJlqHRhY74gjjogjjjii5Hj58uWxaNGiqF+/fjRt2jR3jQEAAAAAAADAduobERjYUP369aN+/fq5bgMAAAAAAAAAtlv25gcAAAAAAACAFBIYAAAAAAAAAIAUEhgAAAAAAAAAgBQSGAAAAAAAAACAFMrLdQMV0bFjx60ybyaTic8++2yrzA0AwP9n776jpKzu/4F/ZulIFQSliCBGSsSCosJXASk2BFNsiVESSTRoNMZeImKJvcQkJrG3RBOsUWygoggKVlBBFKTICtKR3nZ+f3icn7O0Xdjd2d3n9Tpnz5l75977fHZ3JsF93nMvAAAAAADlUYUKDMyYMSNSqVSk0+kSXTeVSpXoegAAAAAAAABQ3lWowMB3SuIGfzqdLpXwAQAAAAAAAABUBBUqMLDrrrsWOyywcuXKWLx4caxfvz4i/n/YoGHDhlGvXr0SrxEAAAAAAAAAKoIKFRiYMWPGNs3bsGFDfPjhh/HYY4/FXXfdFcuWLYu8vLz4+9//HkcccUTJFgkAAAAAAAAAFUBergsoC1WqVInOnTvHTTfdFBMnTox99903Fi5cGP37948nn3wy1+UBAAAAAAAAQJlLRGDg+1q1ahUvvvhitGjRItavXx+/+MUv4rPPPst1WQAAAAAAAABQphIXGIiI2GmnnWLo0KEREbF69eq48MILc1wRAAAAAAAAAJStRAYGIiKOO+64qFatWqTT6Xjuuefi66+/znVJAAAAAAAAAFBmEhsYqFOnTrRp0yYiItLpdIwePTrHFQEAAAAAAABA2UlsYCAion79+pnHM2fOzGElAAAAAAAAAFC2Eh0YmD9/fubx+vXrc1gJAAAAAAAAAJStxAYGpk2bFtOnT49UKhUREY0bN85xRQAAAAAAAABQdhIZGEin03HuuedmHkdEdOzYMZclAQAAAAAAAECZSlxg4PPPP49+/frFc889l7W7wIEHHpjjygAAAAAAAACg7FTNdQHFcdVVV23TvFWrVsXXX38dH3zwQUycODHTn06nI5VKxSWXXJIJDwAAAAAAAABAElSowMCVV165XTf2vzt+IJVKRSqVinQ6HUcffXScffbZJVUiAAAAAAAAAFQIiTqS4PtBgVQqFWeddVYMGzYs8vIS9WMAAAAAAAAAgIq1w0DE/98lYFukUqn4wQ9+EEcddVScdtpp0aFDhxKsDAAAAAAAAAAqjgoVGHjttdeKPSeVSkXNmjWjXr160bJly9hhhx1KoTIAAAAAAAAAqFgqVGCge/fuuS4BAAAAAAAAACqFvFwXAAAAAAAAAACUPYEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEigqrkuoDiuuuqqnF7/iiuuyOn1AQAAAAAAAKCkVKjAwJVXXhmpVCpn1xcYAAAAAAAAAKCyqFCBge9Lp9Ob7N9UoKA4Yzd3rVwGFQAAAAAAAACgpFW4wMD3b/4XvomfTqeLHA7Y0lgAAAAAAAAAqOwqVGDgtddei4iIr7/+Oi6++OKYOXNm5qb/PvvsEz169Ii99torGjVqFDvssEOsWLEiFi5cGBMnTozXX389Pvzww4j4NjzQunXruP7666NJkya5+nYAAAAAAAAAIGcqVGCge/fu8fHHH8fJJ58cX331VaTT6ejTp0/cdNNN0alTp63OnzBhQlxwwQUxcuTImDFjRpx//vnx4osvRvv27cugegAAAAAAAAAoP/JyXUBxLFy4MI444ojIz8+PiIjLL788XnrppSKFBSIi9t5773j55Zfjsssui3Q6HV9++WUcfvjhsWjRotIsGwAAAAAAAADKnQoVGLj00kvjq6++ilQqFT/+8Y/jqquu2qZ1rr766vjxj38cERH5+flx2WWXlWSZAAAAAAAAAFDuVZjAwPLly+Ohhx7KtLc1LFB4fjqdjgcffDBWrFixXesBAAAAAAAAQEVSYQIDo0ePjjVr1kQqlYpmzZpF+/btt2u9Dh06RIsWLSIiYs2aNfHGG2+URJkAAAAAAAAAUCFUmMDA559/nnncrFmzEllzl1122eT6AAAAAAAAAFDZVZjAwPePDFiyZEmJrPn9dRxJAAAAAAAAAECSVJjAQOPGjSMiIp1Ox/Tp02PBggXbtd6CBQti+vTpkUqlstYHAAAAAAAAgCSoMIGBNm3aREREKpWKDRs2xD/+8Y/tWu/OO++M9evXRzqdzlofAAAAAAAAAJKgwgQGunfvHjvuuGNEfLvLwLXXXhuvv/76Nq01atSo+NOf/pTZXaBhw4bRvXv3EqsVAAAAAAAAAMq7ChMYqFq1avz617+OdDodqVQq1qxZE0ceeWTcfvvtsWHDhiKtsWHDhrjtttviqKOOinXr1mXW+s1vfhNVq1Yt5e8AAAAAAAAAAMqPChMYiIgYMmRItG3bNiK+PZpg9erVcd5550Xr1q3jwgsvjOeffz5mzZoVK1asiHQ6HStWrIiZM2fG8OHD48ILL4zWrVvH+eefH6tXr86sufvuu8cVV1yRq28JAAAAAAAAAHKiQn2svmbNmvHSSy/FYYcdFjNnzoxUKhXpdDpmz54dt9xyS9xyyy1bnJ9OpyMiMvNatWoVL774YtSsWbMsygcAAAAAAACAcqNC7TAQEdG6desYO3ZsHH744ZkjBVKpVER8GwjY3FdEZI3r3bt3vPnmm9GmTZucfS8AAAAAAAAAkCsVLjAQEbHLLrvECy+8EI899lgceOCBWaGAiMiECL4LCET8/zDBgQceGI8++mi8/PLL0bx581yUDwAAAAAAAAA5V6GOJCjs+OOPj+OPPz4+/fTTGDVqVIwfPz6mT58eS5YsieXLl8cOO+wQDRo0iDZt2sQBBxwQPXr0iPbt2+e6bAAAAAAAAADIuQodGPhOu3btol27dnHGGWfkuhQAAAAAAAAAqBAq5JEEAAAAAAAAAMD2ERgAAAAAAAAAgAQSGAAAAAAAAACABKqa6wJKwvz582P06NExefLkWLRoUSxdujQKCgriwgsvjHbt2uW6PAAAAAAAAAAodyp0YOCZZ56JW265JcaMGbPJ508++eRNBgYuvvjiGD9+fEREtGrVKu6///5SrRMAAAAAAAAAypsKGRhYuHBhDBw4MJ5//vmIiEin0xERkUqlsh5vzkEHHRQ33nhjZtz5558fHTt2LOWqAQAAAAAAAKD8yMt1AcW1YMGCOPjgg+P555/PhAO+k06ntxgU+M6AAQOiZcuWmfa///3vEq8TAAAAAAAAAMqzChUYSKfT0b9//5g6dWqmr06dOnHuuefGCy+8EB9//PFGIYJNSaVS8ZOf/CTTfumll0qlXgAAAAAAAAAoryrUkQQPPfRQvP3225ldBLp27RpPPPFENG3aNGtcUXYZOProo+P222+PdDodH374YSxbtizq1q1bKnUDAAAAAAAAQHlToXYYuPHGGyPi250Gdt9993j++ec3CgsUVefOnTOP0+l0TJo0qURqBAAAAAAAAICKoMIEBmbMmBGTJ0+OVCoVqVQq/vSnP0W9evW2eb0GDRrELrvskml/9tlnJVEmAAAAAAAAAFQIFSYwMH78+Ij4djeAmjVrRv/+/bd7zR133DHzePHixdu9HgAAAAAAAABUFBUmMDBv3ryIiEilUtGmTZuoXr36dq9Zp06dzOMVK1Zs93oAAAAAAAAAUFFUmMDA8uXLM4+/f6N/eyxbtizzeIcddiiRNQEAAAAAAACgIqgwgYFGjRplHi9atKhE1szPz888bty4cYmsCQAAAAAAAAAVQYUJDOy8884REZFOp2P69OmxcuXK7Vpv4sSJsXTp0ky7devW27UeAAAAAAAAAFQkFSYwcNBBB0UqlYpUKhUbNmyI4cOHb9d6999/f+bxDjvsEF26dNneEgEAAAAAAACgwqgwgYGddtopOnfuHOl0OiIi/vSnP8WGDRu2aa0pU6bE3XffnQkgHHbYYVGlSpWSLBcAAAAAAAAAyrUKExiIiDjrrLMyjydOnBi/+93vir3G7Nmz49hjj42VK1dmwgcXXHBBidUIAAAAAAAAABVBhQoM/OIXv4hOnTpFREQ6nY5//vOfccwxx8Tnn3++1blr166Nf/7zn7H//vvHZ599ltld4PDDD49u3bqVdukAAAAAAAAAUK5UzXUBxZFKpWLYsGHRrVu3WLhwYUREPP/88/H8889Hly5dYv/994+Ib8MEqVQq7rvvvnjyySdj6tSpMXbs2FixYkXmuXQ6Hbvuums8/PDDufyWAAAAAAAAACAnKlRgICJijz32iGeffTYGDBgQ8+bNy9z8Hz9+fIwfPz4zLp1Ox6OPPprVjojM+JYtW8Zzzz0XjRo1KvPvAQAAAAAAAAByrUIdSfCdAw88MCZMmBCHH354Jgjwne+OGkilUhv1R3wbHDj88MPj3XffjR/+8IdlVjMAAAAAAAAAlCcVMjAQEdG0adN44YUX4q233orjjz8+6tWrF+l0erNftWrVin79+sXrr78eL7zwQuy00065/hYAAAAAAAAAIGcq3JEEhR144IHx2GOPRTqdjo8++igmT54cCxcujCVLlkTt2rWjcePG0bp16+jSpUtUq1Yt1+UCAAAAAAAAQLlQYQIDGzZsiBUrVmTatWrVygoApFKp6NSpU3Tq1CkX5QEAAAAAAABAhVJhjiR48MEHo2HDhpmv0aNH57okAAAAAAAAAKiwKkxg4Ouvv450Oh3pdDrq168fhx12WK5LAgAAAAAAAIAKq8IEBurUqRMR3x490KpVqxxXAwAAAAAAAAAVW9VcF1BUu+yyS65LqBRWr14dY8eOjU8//TQWL14c1atXjxYtWsSBBx4Ybdq0yXV5AAAAAAAAAJSRChMYaN++fUREpNPp+PLLL3NcTcnJz8+P8ePHx7hx42L8+PHx7rvvxrJlyzLPt2rVKmbMmLHd15k/f34MHTo0HnjggVixYsUmx3Tu3Dn++Mc/xoABA7b7egAAAAAAAACUbxUmMNCxY8fo2LFjfPLJJ7F48eIYN25cHHjggbkua5uMGTMmbrnllhg3blx89dVXpX69UaNGxXHHHRcLFizY4rj33nsvjj322DjllFPi7rvvjurVq5d6bQAAAAAAAADkRl6uCyiO3/zmN5nHQ4YMyWEl2+edd96Jp556qkzCAm+++WYcddRRG4UFGjRoEPvuu2/stttuUaVKlaznHnrooTjppJMinU6Xen0AAAAAAAAA5EaFCgwMHjw4unXrFul0OkaMGBHnn39+rksqcXXq1CmxtRYvXhwnnHBCrFq1KtPXqlWrePrpp2PRokXx/vvvx/Tp02PGjBlx+umnZ8198skn47bbbiuxWgAAAAAAAAAoXypUYKBKlSrx7LPPxv/93/9FOp2O2267LQ499NAYNWpUrkvbJnXr1o0ePXrEBRdcEMOGDYsZM2bEs88+W2Lr33TTTVm7GLRu3TrGjh0bAwYMiFQqlelv0aJF/OMf/4hrr702a/5VV10VixcvLrF6AAAAAAAAACg/qua6gOK46qqrIiKie/fu8fnnn8fXX38dY8aMiV69ekXTpk1j//33j9atW0e9evWiWrVqxVr7iiuuKI2SN+mYY46Jvn37Rrt27SIvLzuzMX369BK5xvz58+Mvf/lLVt/dd98dzZo12+ycSy65JF566aV44403IiJi6dKlcfPNN28UJAAAAAAAAACg4qtQgYErr7wy65PxqVQq0ul0RETMnTs3hg8fvs1rl2VgYPfddy/1azz22GOxfPnyTPvQQw+NXr16bXFOKpWKIUOGZI2777774pprrsn6uQMAAAAAAABQ8VWoIwk2JZVKZb62xXeBg8rmmWeeyWqfdtppRZrXs2fPaN26daY9d+7cePvtt0u0NgAAAAAAAAByr8IFBtLpdIl+VUbLly/PHCvwnb59+xZpbiqVit69e2f1PffccyVWGwAAAAAAAADlQ4U6kuC1117LdQkVwieffBLr1q3LtFu3bh0777xzked369Yt7r777kz7ww8/LMnyAAAAAAAAACgHKlRgoHv37rkuoUKYPHlyVrtDhw7Fml94fOH1AAAAAAAAAKj4ylVg4A9/+EPm8eDBg6Nt27Y5rKbimjJlSla7ZcuWxZpfePzMmTNj9erVUbNmze2uDQAAAAAAAIDyoVwFBm6//fZIpVIREdGvX7+tBgaWLFkSEydOzLQPPfTQUq2vopg3b15Wu0WLFsWa37Rp06hatWqsX78+IiIKCgpi4cKF0bx58xKpbf78+cWaM3Xq1O2+LgAAAAAAAADZylVgICIinU5nQgNb895770Xfvn0jIiKVSmVucCfd8uXLs9o77LBDseanUqmoVatWLFu2bLNrbqs777wzhg4dWiJrAQAAAAAAALDtyl1goKhhge+k0+lSqqTiKnxzf1uOEiitwAAAANsvdda/cl0ClEvpv/481yUAAAAAVCh5uS6Akrd69eqsdvXq1Yu9Ro0aNbLaq1at2q6aAAAAAAAAAChfyt0OA2y/wjsKrF27tthrrFmzZotrbqvBgwfHcccdV6w5U6dOjWOPPbZErg8AAAAAAADAtwQGKqE6depktQvvOFAUhXcUKLzmtmrSpEk0adKkRNYCAAAAAAAAYNs5kqASKnxzf8WKFcWan06nSy0wAAAAAAAAAED5IDBQCRX+BP/s2bOLNf/rr7+O9evXZ9p5eXnRuHHjEqkNAAAAAAAAgPJBYKAS2nPPPbPas2bNKtb8wuNbtWoVNWvW3O66AAAAAAAAACg/BAYqoXbt2mW1J02aVKz5kydP3uJ6AAAAAAAAAFR8AgOVUMeOHaNatWqZ9owZM2LOnDlFnj9mzJis9j777FNSpQEAAAAAAABQTggMVEJ169aNQw89NKtvxIgRRZqbTqdj5MiRWX3HHHNMidUGAAAAAAAAQPlQNdcFbM6ECROiatUtlzdhwoSs9ujRoyOdTm/T9QrfYK/o+vfvH6+88kqmfe+998Ypp5yy1XmvvfZaTJ8+PdNu2rRpHHjggaVSIwAAAAAAAAC5Uy4DA+l0Os4///xiz+nRo8c2XS+VSsX69eu3aW55deKJJ8all14aK1asiIiIN954I1599dU47LDDNjsnnU7H0KFDs/p++ctfRl6ejSgAAAAAAAAAKptyeSc4lUpFOp0u0lcqlcp8FXXOpr4qmyZNmsRZZ52V1Tdo0KD46quvNjvnuuuuizfeeCPTrl+/flxwwQWlViMAAAAAAAAAuVMudxiI+DY0UBZzchUWGDNmTKxatWqj/sLHLKxevTpGjhy5yTWaNWsWHTp02Ow1LrzwwnjwwQdj7ty5ERExffr06Nq1a9xxxx1xzDHHZH5es2fPjmuuuSb++c9/Zs2/7LLLYscddyzW9wUAAAAAAABAxVCuAgO77rrrNt30r4h+/vOfx8yZM7c67uuvv44+ffps8rlTTz01Hnjggc3O3XHHHeM///lPHH744bF69eqIiJg5c2YMGDAgGjRoEK1bt44lS5bErFmzYsOGDVlzBwwYUOxjIQAAAAAAAACoOMpVYGDGjBm5LqHSOfTQQ2P48OFx3HHHxaJFizL9S5YsiQ8++GCTc372s5/Ffffdl5jwBgAAAAAAAEAS5eW6AErfYYcdFpMmTYrf/va3Ubt27c2O23fffeOJJ56If/3rX1GjRo0yrBAAAAAAAACAslaudhhIkrLeTaFp06Zx5513xi233BJjx46NyZMnx5IlS6J69erRvHnzOPDAA6Nt27ZlWhMAAAAAAAAAuSMwkDC1atWKXr16Ra9evXJdCgAAAAAAAAA55EgCAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASKCquS4AAAAAAJIgdda/cl0ClEvpv/481yUAACSWHQYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGKrErr7wyUqnUNn8NHDgw198CAAAAAAAAAKVEYAAAAAAAAAAAEkhgAAAAAAAAAAASqGquC6Ds3HzzzbH33nsXeXyzZs1KsRoAAAAAAAAAcklgIEE6d+4cPXr0yHUZAAAAAAAAAJQDjiQAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABKqa6wIoW2vWrIkvvvgiFi5cGNWqVYtGjRpFs2bNonbt2rkuDQAAAAAAAIAyJDCQIGeeeWZ88cUXsXr16qz+qlWrRufOnePII4+MwYMHx0477VRqNcybNy/mz59frDlTp04tpWoAAAAAAAAAkktgIEEmTZq0yf7169fHuHHjYty4cXHDDTfE+eefH0OGDIkqVaqUeA133nlnDB06tMTXBQAAAAAAAKB48nJdAOXLqlWr4uqrr47evXvH8uXLc10OAAAAAAAAAKVEYKCSS6VS0bVr17j22mtjxIgRMXv27Fi5cmWsXr068vPz49lnn43TTz89atasmTVv1KhRceKJJ8aGDRtyVDkAAAAAAAAApcmRBJVY375942c/+1n84Ac/2OTzzZo1i2bNmkW/fv3i8ssvjxNPPDHGjBmTeX748OFx5513xu9+97sSq2nw4MFx3HHHFWvO1KlT49hjjy2xGgAAAAAAAAAQGKjUunbtWuSxLVq0iJEjR8Zhhx0Wb731Vqb/mmuuidNOOy1q165dIjU1adIkmjRpUiJrAQAAAAAAALDtHElARs2aNeOhhx6KqlX/f45k3rx58fLLL+ewKgAAAAAAAABKg8AAWdq2bRv9+/fP6hMYAAAAAAAAAKh8BAbYSK9evbLaU6ZMyVElAAAAAAAAAJQWgQE20rJly6z2/Pnzc1QJAAAAAAAAAKVFYICNVKtWLau9bt26HFUCAAAAAAAAQGkRGGAjc+fOzWrvtNNOOaoEAAAAAAAAgNIiMMBG3nzzzax24SMKAAAAAAAAAKj4BAbIsmTJknjiiSey+nr16pWjagAAAAAAAAAoLQIDZDn//PNjyZIlmXb16tXjyCOPzF1BAAAAAAAAAJQKgYFK6vrrr4/33nuvyOPXr18f5513Xtx7771Z/WeccUbssssuJV0eAAAAAAAAADkmMFBJvfjii7H//vtHt27d4s9//nN8/PHHsX79+o3GLV26NB599NE44IAD4tZbb816bvfdd48rrriirEoGAAAAAAAAoAxVzXUBlK6xY8fG2LFjIyKiRo0a0aJFi6hfv35UqVIlFi5cGDNmzIiCgoKN5u28887xwgsvRKNGjcq6ZAAAAAAAAADKgMBAgqxZsyamTZu21XFHHXVU3H///dGkSZMyqAoAAAAAAACAXBAYqKQuu+yyaN++fYwePTo+/fTT2LBhwxbH16lTJ4488sg466yz4tBDDy2jKgEAAAAAAADIFYGBSqpPnz7Rp0+fiIhYuXJlTJo0KWbMmBFz5syJ5cuXR0FBQTRo0CAaNmwYHTp0iL322iuqVKmS46oBAAAAAAAAKCsCAwlQu3bt2H///WP//ffPdSkAAAAAAAAAlBN5uS4AAAAAAAAAACh7AgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEBVc10AAAAA8K3UWf/KdQlQLqX/+vNclwAAAFAp2WEAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASqGquCwAAAAAAgIoudda/cl0ClEvpv/481yUAsAV2GAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgASqmusCAAAAAAAAoLxKnfWvXJcA5VL6rz/PdQmUADsMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEACCQwAAAAAAAAAQAJVzXUB5Ma0adNi/PjxMXv27Fi7dm00bNgw2rVrF127do2aNWvmujwAAAAAAAAASpnAQMI8/fTTcfXVV8f777+/yefr1KkTAwcOjCFDhkTjxo3LuDoAAAAAAAAAyoojCRJizZo1cfLJJ8ePfvSjzYYFIiKWL18ef/3rX6NDhw7xxhtvlGGFAAAAAAAAAJQlgYEEKCgoiBNOOCH+9a9/ZfVXqVIlWrduHfvss0/Ur18/67n58+fHkUceGW+99VZZlgoAAAAAAABAGREYSICbbropnnnmmay+M844I2bNmhVffPFFfPDBB7Fo0aJ48sknY9ddd82MWblyZRx//PGxdOnSsi4ZAAAAAAAAgFImMFDJLVy4MK699tqsvuuuuy7+/ve/R7NmzTJ9eXl58aMf/SjGjh0bu+22W6Z/9uzZceutt5ZVuQAAAAAAAACUEYGBSu7GG2+MZcuWZdqHHnpoXHTRRZsd37x587jnnnuy+m677bZYuHBhqdUIAAAAAAAAQNkTGKjECgoK4v7778/qu/LKKyOVSm1xXq9eveKQQw7JtJctWxb//e9/S6VGAAAAAAAAAHJDYKASGzt2bMyfPz/TbtOmTfTo0aNIc0877bSs9tNPP12ClQEAAAAAAACQawIDldjw4cOz2n369Nnq7gLfH/t9o0aNihUrVpRYbQAAAAAAAADklsBAJfbhhx9mtbt27Vrkuc2aNYvddtst0167dm1MmjSphCoDAAAAAAAAINcEBiqxyZMnZ7U7dOhQrPmFxxdeDwAAAAAAAICKS2Cgklq1alXMmjUrq69ly5bFWqPw+ClTpmx3XQAAAAAAAACUD1VzXQClY8GCBZFOpzPtatWqRZMmTYq1RvPmzbPa8+bN2+665s2bF/Pnzy/WnMJHIUydOnW76yAiFs7OdQVQLn3yySe5LqFkeI/DJnmPQ+VWKd7j3t+wSZXi/R3hPQ6b4T0OlVuleI97f8MmVYr3dzlR+P7nmjVryuzaqfT37ypTaUyePDnrSIH69evHkiVLirXGrbfeGuedd16mfeKJJ8ajjz66XXVdeeWVMXTo0O1aAwAAAAAAAKCyevrpp2PAgAFlci1HElRSy5cvz2rXrFmz2GvUqlVri2sCAAAAAAAAUHEJDFRSq1evzmpXr1692GvUqFEjq71q1artqgkAAAAAAACA8qNqrgugdBTeUWDt2rXFXqPw2RjbsktBYYMHD47jjjuuWHO++eabePfdd6NevXrRoEGDaNmy5UZhBqiopk6dGscee2ym/fTTT0fbtm1zVxBQorzHofLy/obKzXscKi/vb6jcvMehcvMepzJbs2ZNfPnll5l29+7dy+zaAgOVVJ06dbLahXccKIrCOwoUXnNbNGnSJJo0aVLseQcffPB2XxsqgrZt20bHjh1zXQZQSrzHofLy/obKzXscKi/vb6jcvMehcvMep7LZb7/9cnJdRxJUUoVv7q9cuTLS6XSx1lixYsUW1wQAAAAAAACg4hIYqKQaN24cqVQq0163bl3MmzevWGvk5+dntbdlZwAAAAAAAAAAyieBgUqqVq1aseuuu2b1zZo1q1hrFB7frl277a4LAAAAAAAAgPJBYKASK3yDf9KkScWaP3ny5C2uBwAAAAAAAEDFJTBQie2zzz5Z7bFjxxZ57pw5c2LGjBmZdrVq1aJDhw4lVBkAAAAAAAAAuSYwUIn169cvqz1y5MhIp9NFmvvyyy9ntXv27Bl16tQpsdoAAAAAAAAAyC2BgUqsa9eu0bhx40z7iy++iFGjRhVp7r333pvVHjBgQEmWBgAAAAAAAECOCQxUYnl5eTFw4MCsvqFDh251l4FXXnklRo8enWnXrVs3jj/++NIoEQAAAAAAAIAcERio5C666KKsowRef/31uOGGGzY7Pj8/PwYNGpTVd84552TtVAAAAAAAAABAxScwUMk1btw4Lr300qy+Sy65JAYPHhxfffVVpq+goCCefvrp6Nq1a8yYMSPT36xZszjvvPPKqlwAAAAAAAAAyojAQAJcdNFF0a9fv6y+v//977HrrrvG7rvvHvvtt180atQofvSjH8WsWbMyY2rVqhX//e9/o0GDBmVcMQAAAAAAAAClrWquC6D05eXlxbBhw+KXv/xlPPbYY5n+DRs2xBdffLHJOY0aNYrHH388unXrVlZlQiLttNNOMWTIkKw2UHl4j0Pl5f0NlZv3OFRe3t9QuXmPQ+XmPQ6lI5VOp9O5LoKy88QTT8Q111wTH3744Saf32GHHeLUU0+NIUOGRJMmTcq2OAAAAAAAAADKjMBAQk2dOjXGjRsX+fn5sXbt2mjQoEG0b98+unXrFjVr1sx1eQAAAAAAAACUMoEBAAAAAAAAAEigvFwXAAAAAAAAAACUPYEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASKCquS4AIKmmTZsW48ePj9mzZ8fatWujYcOG0a5du+jatWvUrFkz1+UBAN+TTqdjxowZ8dFHH8Xs2bNjyZIlUaNGjWjYsGHsscceccABB/j/b6jA1q5dG59++mnMmDEj8vPzY9myZbFu3bqoV69eNGrUKDp16hTt27ePKlWq5LpUAABItClTpsSECRNi9uzZsXLlyqhVq1Y0bdo0fvCDH8Tee+8dNWrUyHWJUOEIDACUsaeffjquvvrqeP/99zf5fJ06dWLgwIExZMiQaNy4cRlXB2yP/Pz8GD9+fIwbNy7Gjx8f7777bixbtizzfKtWrWLGjBm5KxAolsWLF8fTTz8dL774Yrz66quxYMGCzY6tVq1aHH300fH73/8+unfvXoZVAtvq8ccfj5EjR8aYMWPi008/jfXr129xfP369eOkk06Kc845J9q1a1dGVQKl6aSTTorHHnssq8+/2QGg/Fm2bFn85S9/iXvuuSemT5++2XHVq1ePLl26xE9/+tM455xzyrBCqNhS6XQ6nesiAJJgzZo1cdppp8W//vWvIo3faaed4vHHH49DDz20lCsDtseYMWPilltuiXHjxsVXX321xbH++AgVx5lnnhn33HNPrF27tthzTznllPjLX/4S9erVK4XKgJLSokWLyM/PL/a8atWqxaWXXhpDhgyJVCpVCpUBZeHZZ5+N/v37b9Tv3+xQ/l155ZUxdOjQbZ5/6qmnxgMPPFByBQGl6rnnnotBgwbF119/XeQ5TZs2jblz55ZiVVC52GEAoAwUFBTECSecEM8880xWf5UqVWLXXXeN+vXrx/Tp02Pp0qWZ5+bPnx9HHnlkjBw5Mg4++OCyLhkoonfeeSeeeuqpXJcBlLBx48ZtMixQpUqV2GWXXaJp06axbt26mDlzZtb/f0dEPPTQQ/Hpp5/GK6+8EnXq1CmrkoESULNmzcy/zwsKCmLBggUxa9as+P5nLdatWxdDhw6NL7/8Mu69994cVgtsq6VLl8Zvf/vbXJcBAGzFbbfdFuedd14U/uxzzZo1o1mzZtG4ceNYtWpVzJkzZ4u7AgJblpfrAgCS4KabbtooLHDGGWfErFmz4osvvogPPvggFi1aFE8++WTsuuuumTErV66M448/fqMbEUDF4EYhVA4NGjSIwYMHx/Dhw2Px4sXx5ZdfxrvvvhsTJkyIhQsXxmuvvRaHHHJI1pzx48fHwIEDc1MwUGTNmjWLX//61/Hwww/H1KlTY8WKFTFlypTM0UIzZsyIhQsXxl133RUtWrTImnvffffF/fffn6PKge1xwQUXZHYY2WGHHXJcDQCwKffee2/84Q9/yAoLHHnkkfHCCy/EkiVLYtq0aTFu3LiYOHFizJ8/P/Lz8+Phhx+On/zkJ1G9evUcVg4VjyMJAErZwoULo3Xr1lnnmF933XVx8cUXb3J8fn5+/N///V/WFohXXHHFdm21BpSe22+/Pc4999yoW7dudO7cOQ444IDo0qVLHHDAATF9+vTo2bNnZqztTaHi2H///WPhwoVx+eWXx89+9rOoVavWFsdv2LAhBg8eHHfddVdW/6uvvpr1vwNA+TFx4sTYa6+9inyswOLFi6N3797x/vvvZ/p22WWXmD17duTl+TwGVBSjRo2Kww47LNLpdOTl5cX1118fF154YeZ5/2aH8q/wkQQ333xz7L333kWe36xZs+jQoUNplAaUkKlTp8Zee+0Vq1evjohvjwV78MEH46STTirS/MWLF0fDhg1Ls0SoVBxJAFDKbrzxxqywwKGHHhoXXXTRZsc3b9487rnnnujdu3em77bbbouzzz47GjVqVKq1AsV3zDHHRN++faNdu3Yb3SyYPn16jqoCttfQoUOjT58+Rf5UQpUqVeLOO++M999/P959991M/z333CMwAOVUp06dijW+YcOG8cgjj0THjh0zn3KaM2dOjBkzZqNdRoDyadWqVTFo0KDMe/h3v/tdHHDAATmuCthenTt3jh49euS6DKAE/eY3v8mEBSIi/vWvf8Vxxx1X5PnCAlA8IvAApaigoGCjbUqvvPLKrX6KqVevXll/dFy2bFn897//LZUage2z++67R4cOHXyyECqZo48+uthbGFapUiXrE4oRES+99FJJlgXkWPv27aNz585ZfZMnT85RNUBx/fGPf4xp06ZFRMSuu+4a11xzTY4rAgAKe+aZZ+K1117LtI877rhihQWA4vOXbYBSNHbs2Jg/f36m3aZNmyInnk877bSs9tNPP12ClQEApaHwp4wXLlwYK1euzFE1QGnYfffds9oLFizIUSVAcbzzzjtx++23Z9p/+9vfok6dOrkrCADYpMJH/Q0ZMiRHlUByCAwAlKLhw4dntfv06VPkM1L79OmT1R41alSsWLGixGoDAEreprY9XLp0aQ4qAUrL97dGjYho0KBBbgoBimzdunVx2mmnxYYNGyLi208q9uvXL8dVAQCF5efnZ+3Ut88++0THjh1zWBEkg8AAQCn68MMPs9pdu3Yt8txmzZrFbrvtlmmvXbs2Jk2aVEKVAQClIT8/f6O+Ro0a5aASoDSk0+l45513svoKH1EAlD/XXXddfPTRRxHxbcjnjjvuyHFFAMCmvPjii5mAX0REz549c1gNJIfAAEApKnyeaYcOHYo1v/B456MCQPk2evTorHarVq2ievXqOaoGKGn33XdffPXVV5l2u3btokuXLjmsCNiaSZMmxbXXXptp33DDDbHzzjvnsCIAYHMKh3P33nvvzOMPPvggzj777Nh7772jYcOGUbt27dhtt92iT58+cfPNN28ywA8UTdVcFwBQWa1atSpmzZqV1deyZctirVF4/JQpU7a7LgCg9Nx3331Z7aOOOipHlQAl7cEHH4zBgwdn2nl5efHXv/61yEeOAWWvoKAgTjvttFi7dm1ERBxyyCHx61//OsdVAaVhzZo18cUXX8TChQujWrVq0ahRo2jWrFnUrl0716UBxVA4MNCmTZtYvnx5nHPOORv993ZExMyZM2PmzJkxcuTIuOKKK+L3v/99DB06NKpVq1ZWJUOlIDAAUEoWLFgQ6XQ6065WrVo0adKkWGs0b948qz1v3rwSqQ0AKHnPP/98vPHGG1l9AwcOzE0xQLF99tlnWYHfdevWxeLFi+Pjjz+OZ555Jut4sOrVq8ddd90VvXr1ykWpQBHdcccd8fbbb0fE/3/fCvlA5XPmmWfGF198EatXr87qr1q1anTu3DmOPPLIGDx4cOy00045qhAoqqlTp2a18/Ly4tBDD40PPvhgq3NXrVoV1113Xbzzzjvx5JNPRt26dUurTKh0BAYASsny5cuz2rVr1y72HyZ22GGHLa4JAJQPixYtitNPPz2r79hjj7VVOVQgd955Z/z5z3/e4phUKhVHHHFEXHfddVnbowLlz/Tp0+Pyyy/PtC+55JJo165dDisCSsv3Q33ft379+hg3blyMGzcubrjhhjj//PNjyJAhUaVKlTKuECiKgoKCWLZsWVbf2WefnQkLpFKp6NevXxx11FHRokWLWLFiRXzwwQfx8MMPZx0bNnLkyBg4cGA88cQTZVo/VGR5uS4AoLIqfHO/Zs2axV6jVq1aW1wTAMi9goKCOPnkk2P27NmZvvr168cdd9yRw6qA0nDcccfFZZddJiwAFcBvfvObWLFiRUREtGvXLi699NIcVwTk0qpVq+Lqq6+O3r17+/salFNLly7N2rE3IuL999+PiIhGjRrF66+/Hv/73//ijDPOiH79+sUJJ5wQ119/fUyZMiV+9rOfZc178skn46GHHiqz2qGiExgAKCWFt0GrXr16sdeoUaNGVnvVqlXbVRMAUPIuuOCCeOGFF7L6/vnPf0bLli1zVBFQWv773//G//3f/8Whhx660XapQPlx7733xsiRIyPi208j3nXXXdv03+RA+ZVKpaJr165x7bXXxogRI2L27NmxcuXKWL16deTn58ezzz4bp59++kYf4Bk1alSceOKJsWHDhhxVDmzO5sI8VapUieHDh8chhxyyyefr1KkTDz/8cPTt2zer/09/+tNGAQRg0wQGAEpJ4f8gWbt2bbHXWLNmzRbXBABy64477ohbb701q+/CCy+ME044IUcVAdvq9ttvj3Q6nflauXJlfPnll/Hcc8/FaaedlrX71+jRo+OAAw6Id999N4cVA5syZ86cOP/88zPtQYMGbfYGA1Ax9e3bNz799NMYM2ZMXHrppdG7d+9o3rx51KpVK2rUqBHNmjWLfv36xT/+8Y/4/PPPo1u3blnzhw8fHnfeeWeOqgc2Z3N/+x40aFAceOCBW5ybl5cXf//73yMv7//f9pwyZUq8/vrrJVojVFYCAwClpE6dOlntwjsOFEXhHQUKrwkA5M6///3v+P3vf5/VN3DgwLj++utzUxBQomrVqhUtWrSIo48+Ou65556YOHFi7LPPPpnnlyxZEscee2wsWbIkZzUCGzvzzDMz78udd945brzxxtwWBJS4rl27xg9+8IMijW3RokWMHDkyDj744Kz+a665JlauXFka5QHbaHN/+/71r39dpPlt2rSJ3r17Z/UJDEDRCAwAlJLC/8BZuXJlsbdA+u68xc2tCQDkxnPPPRennnpq1v+3//jHP4577rknUqlUDisDSkvbtm1jxIgRWceN5Ofnx0033ZTDqoDvGzZsWDz11FOZ9p///Odo0KBB7goCyoWaNWvGQw89FFWrVs30zZs3L15++eUcVgUUVqtWrahSpUpWX926dWPfffct8hrdu3fPatsRDIpGYACglDRu3DjrhsG6deti3rx5xVojPz8/q92kSZMSqQ0A2HavvfZaHHfccbF+/fpMX58+feLRRx/d6I8bQOXSuHHjGDp0aFbfAw88kJtigI1ccMEFmcdHH310HH/88TmsBihP2rZtG/3798/qExiA8qfw37/btm2bdczA1uy5555Z7eL+PR6SSmAAoJTUqlUrdt1116y+WbNmFWuNwuPbtWu33XUBANtu3Lhx0b9//6yjhrp27RpPPfVUVK9ePYeVAWXlRz/6UVYw+KuvvoqZM2fmsCLgO98/ImT48OGRSqW2+tWzZ8+sNWbOnLnRmA8//LBsvxGgVPTq1SurPWXKlBxVAmxO+/bts9r16tUr1vzC4xcvXrzdNUESCAwAlKLCN/gnTZpUrPmTJ0/e4noAQNmZOHFiHHnkkbF8+fJM37777hvPP/987LDDDjmsDChLDRo0iB133DGrb+7cuTmqBgAoqu8fKxQRMX/+/BxVAmxOhw4dstpr1qwp1vzvh/sjImrXrr3dNUESCAwAlKJ99tknqz127Ngiz50zZ07MmDEj065WrdpG/2ACAMrGlClTok+fPlmfTmjfvn289NJLUb9+/RxWBpQH1apVy3UJAMBWFP7/63Xr1uWoEmBz9ttvv6z2119/Xaz5hY8gaNSo0XbXBElQNdcFAFRm/fr1ixtuuCHTHjlyZKTT6awtTDen8DlqPXv2jDp16pR4jQDAls2cOTN69+6d9YeH1q1bx4gRI2KnnXbKYWVALixbtiwWLVqU1de0adMcVQN83zPPPFPsG4ATJkyI888/P9Nu2rRpPPLII1lj2rZtWyL1AblVeEcg/5aH8ufoo4+OvLy8KCgoiIiI6dOnx6JFizba4Wtz3nvvvaz2nnvuWeI1QmUkMABQirp27RqNGzeOBQsWRETEF198EaNGjdrojMRNuffee7PaAwYMKJUaAYDNmzNnTvTq1Stmz56d6WvevHm88sor0bx58xxWBuTK8OHDI51OZ9o77bRT7LLLLjmsCPhO9+7diz2natXsP4/WrFkzevfuXVIlAeXIm2++mdUufEQBkHtNmjSJbt26xejRozN9Tz75ZAwaNGirc9evXx9PPfVUVl+PHj1KukSolBxJAFCK8vLyYuDAgVl9Q4cOzfoD46a88sorWf8oqlu3bhx//PGlUSIAsBmLFi2KPn36xLRp0zJ9O+20U4wYMSJat26dw8qAXFm1alUMGTIkq69fv36Rl+fPKwBQni1ZsiSeeOKJrL5evXrlqBpgS04//fSs9k033RRr1qzZ6ry77747ayeRevXqxeGHH17i9UFl5L9oAUrZRRddlHWUwOuvv551TEFh+fn5GyUmzznnnGjcuHGp1QgAZFu2bFkcccQR8cknn2T6GjRoEC+//HK0b98+h5UBJeHCCy+Md955p1hzFi1aFP3794/PPvss01elSpU499xzS7o8AKCEnX/++bFkyZJMu3r16nHkkUfmriBgs0466aTYa6+9Mu3PPvssTj/99MwxBZsybty4uPDCC7P6Bg8eHPXr1y+1OqEycSQBQClr3LhxXHrppXHppZdm+i655JKYNWtWXH755dGsWbOIiCgoKIj//e9/cc4558SsWbMyY5s1axbnnXdemdcNFN2YMWNi1apVG/VPmDAhq7169eoYOXLkJtdo1qxZdOjQoVTqA4qvf//+G91M/MMf/hALFizY7Pt4czp37hwNGzYsyfKA7fTyyy/HTTfdFF26dIkTTjghDjvssOjYsWNUq1Yta1w6nY4pU6bEsGHD4o477sgcNfadc889N+uPmQBA6br++uujT58+0blz5yKNX79+fVx00UUbHf15xhlnOFIIyqm8vLy47bbbok+fPpmdeh988MHIz8+P66+/Puv9v3Tp0rj33ntjyJAhsXz58kz/D37wg6y/xwNblkpvbV9sALZbQUFBDBgwIJ577rms/ipVqkSrVq2ifv36MX369Kykc0RErVq1YsSIEdGtW7cyrBYort122y1mzpy5XWuceuqp8cADD5RMQcB2S6VSJbbWa6+95txEKGf22WefjYJ91atXj+bNm0eDBg2ievXqsWzZsvjyyy9j2bJlm1zj1FNPjfvuu89xBFDBjRo1Knr27Jlpt2rVKmbMmJG7goAt6tGjR7z++uvRtWvXOP7446NXr17Rrl27qFo1+7ORS5cujeeffz5uvPHG+PDDD7Oe23333WPcuHHRqFGjMqwcKK4bbrghLr744o36d95552jRokWsWLEipk2bFmvXrs16vlGjRvHaa68J9kIx2GEAoAzk5eXFsGHD4pe//GU89thjmf4NGzbEF198sck5jRo1iscff1xYAAAAysDatWtj+vTpWx1Xr169uP766+OMM84o0XARAFB0Y8eOjbFjx0ZERI0aNaJFixZRv379qFKlSixcuDBmzJixye3Ld95553jhhReEBaACuOiii6J27dpx3nnnxbp16zL9c+fOjblz525yzp577hnPPvts7LHHHmVVJlQKYvAAZaRmzZrx6KOPxuOPPx777LPPZsftsMMOMXjw4Jg0aZJPIwIAQCl49NFH44YbbojevXtHvXr1tjo+lUpFp06d4qabboqpU6fGb3/7W2EBACgn1qxZE9OmTYv3338/3nnnnfjiiy82GRY46qijYsKECW4kQgXyu9/9LiZOnBgnnHDCRseHfV/r1q3jz3/+c0ycONF7HLaBIwkAcmTq1Kkxbty4yM/Pj7Vr10aDBg2iffv20a1bt6hZs2auywMAgEQoKCiIzz//PKZOnRqzZs2Kb775JtatWxd169aN+vXrx2677Rb77bdfkYIFAEDpGjFiRDz55JMxevTo+PTTT2PDhg1bHF+nTp048sgj46yzzopDDz20jKoESsM333wTY8eOjc8//zyWLl0aderUiaZNm8Z+++0Xe+65Z67LgwpNYAAAAAAAAKhQVq5cGZMmTYoZM2bEnDlzYvny5VFQUBANGjSIhg0bRocOHWKvvfaKKlWq5LpUACjXBAYAAAAAAAAAIIHycl0AAAAAAAAAAFD2BAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAACCh0ul0PPvss/Hzn/882rZtG3Xr1o1UKpX56tGjR65LBAAAAEpR1VwXAAAAAJS9JUuWxE9/+tN45ZVXcl0KAAAAkCN2GAAAAKBC2G233bI+/Z5KpWL33XePdevWbfdaS5YsKfmCy7kTTjhBWAAAAAASzg4DAAAAVFhffPFF3HfffXH66afnupQK5fnnn4+XX345065Tp06ceeaZceCBB0bdunUz/Q0bNsxFeQAAAEAZERgAAACgQrv66qvj1FNPjZo1a+a6lArjoYceymr/73//i549e+aoGgAAACBXHEkAAABAhZafnx9///vfc11GhfLWW29lHu+xxx7CAgAAAJBQAgMAAABUeNddd10sX74812VUCKtXr45Zs2Zl2h07dsxhNQAAAEAuCQwAAABQIXXt2jXzeP78+XH77bfnrpgKZOnSpVntevXq5agSAAAAINcEBgAAAKiQrrnmmkilUpn2zTffHIsXL85hRRXD6tWrs9rf/xkCAAAAyVI11wUAAADAtth3333jJz/5STz++OMR8e0n52+66ab405/+VCbXX7lyZbz55pvx5Zdfxvz586NmzZrRpEmT6NixY+y9995lUsO2SKfTpbb2xx9/HJMnT445c+bE8uXLo2nTpnHKKadEtWrVtjhv3rx58fbbb8fcuXNj4cKFUadOnWjSpEl06dIlWrduXSK1pdPpmDhxYkyePDnmzZsXK1asiMaNG0eLFi3ikEMOiTp16pTIdYpj7ty58f7778eMGTPim2++iYKCgqhdu3Y0adIk2rRpEz/84Q9LpK78/PwYO3ZszJw5M9avXx+77LJL/PCHP4zOnTtv17oFBQXx+eefxyeffBJfffVVfPPNN1GjRo3Ycccdo23bttGlS5eoUaPGdtf/nRUrVsRbb70V+fn5MX/+/Fi3bl3Uq1cvWrduHZ06dYoWLVps89ql+RpctGhRvP/++zF16tRYunRprF+/PmrXrh2NGzeO1q1bR8eOHaNhw4bbdQ0AAIBtlUqX5l8KAAAAoITstttuMXPmzEx78eLFMWfOnNhrr71iw4YNERGxww47xLRp06Jp06bFXqtBgwZFqmPChAkxZMiQeOmllzb6tP53mjdvHr/61a/iwgsvzMmN6MJ69OgRr7/+erHmdO/ePUaNGpVpjxo1Knr27JlpDxkyJK688spYv359/P3vf49//vOf8cknn2y0zuZ+tgUFBfHII4/EX/7yl3jvvfc2G2Ro3759XHjhhXHKKadEXl7xN0qcP39+XHfddfHYY4/FnDlzNjmmevXqccQRR8TVV18dnTp1KvY1imvYsGFx2223xVtvvbXFcVWqVIlOnTrFscceG2eddVbsuOOOmxxX+Pf73c9ywoQJceGFF8aIESM2+fPdfffd4/LLL4+BAwcWufZly5bFU089FU8//XSMGjVqi7t61KhRI4455pi45JJLYr/99ivyNQp74YUX4uabb44333wz1q5du9lx7du3jxNOOCF+85vfxC677LLVdUv7NfjKK6/EDTfcEK+88koUFBRsdlwqlYo999wzBgwYEGeeeWa0bNmyyNcAAADYXgIDAAAAVAibu8k/cODAePDBBzP9Z599dvz5z3/eprW2JJ1Ox8UXXxw333zzFm/+fd/OO+8cw4YNi//7v/8r0vjSUlqBgXPOOSf69+8fb7755mbX2dTP9vPPP4/jjjsuJkyYUOR6DjrooPjf//4XO+20U5Hn3HvvvXHuuefGsmXLijQ+Ly8vhgwZEldccUWRr1Eca9asiZNOOimeeuqpYs8dMWJE9O7de5PPbSow8Oijj8app54a69at2+raxxxzTAwbNqxIuwE0btw4Fi5cWPTC49sb4tdcc01ceumlxZo3Z86cOPHEE+ONN94o1rxTTz01HnjggS2OKc3XYDqdjrPPPjv++te/Fnnt79x9990xaNCgYs8DAADYVsWP5gMAAEA5MmTIkKwt7//5z3/Gl19+WaLXSKfTMXDgwLjxxhs3Cgs0btw49ttvv2jfvn3UrFkz67m5c+dG375946WXXirResqD9evXbxQWaNiwYXTq1Ck6deoU9evX3+S8cePGRdeuXTe6UVulSpXMNvYdOnTY6Gf59ttvx8EHHxzz588vUn1//OMfY9CgQRuFBerVqxcdO3aMLl26xG677Zb1XEFBQSYIURoGDRq0ybBAkyZNYt99942DDjooOnbsWKxQxKa89tprccopp2TCAt/9bPfff/9o1qzZRuOfffbZ+MlPfhLr16/f6tqFd9VIpVLRsmXL6NSpU6b+2rVrZ41Jp9Nx2WWXxVVXXVXk7+Gjjz6KLl26bDIs0LBhw+jYsWMccMABsccee2z1yIvCSvs1eMUVV2wyLLDjjjvG3nvvHQcddFDstddeRdoFAQAAoLQJDAAAAFChtW7dOn79619n2mvWrCnWjcmi+Otf/xoPPfRQVt8hhxwSY8aMiXnz5sV7770XkyZNivnz58fdd9+dtXX8qlWr4mc/+1l89dVXJVpTcdxyyy0xYsSIGDFiRDzyyCNZz/Xt2zfz3Pe/brnlli2uec8992TCAr17944xY8bEggULYsKECTFhwoRYvHhxjBgxImrVqpWZM3fu3Ojfv38sWLAg09epU6d49NFHY8mSJfH555/HuHHj4pNPPonFixfHf/7zn9h9990zY6dNmxYDBw7c7Nbx37n//vvjmmuuybRTqVSccsop8c4778TixYvj448/jnHjxsX06dMjPz8/LrnkkqybznfccUf897//3eI1iuudd97J+tlXrVo1LrnkkpgxY0Z8/fXX8f7778dbb70VH3/8ccybNy/mzp0bw4YNi1NOOSXrZ1gUv/zlL2P9+vVRvXr1uPLKK2POnDnx+eefxzvvvBP5+fkxYcKE6NevX9ac4cOHb/V3/p127drFH//4xxg7dmwsX748Zs2aFRMmTMjUv2zZsnjrrbfixBNPzJp31VVXxTvvvLPV9ZcsWRIDBgyI2bNnZ/ry8vLiV7/6Vbz77ruxcOHC+Pjjj2P8+PHx2WefxTfffBOjR4+O3//+99G4ceMtrl3ar8H8/Py44YYbsvpOP/30mDRpUixcuDA+/PDDeOutt2LixInx1VdfxaJFi+K5556LM844Y7MhGwAAgFKVBgAAgAqgVatW6YjIfC1evDjz3FdffZWuVatW5rmqVaumP/vss21aq7Avv/wya+2ISJ966qnpgoKCzc6ZPn16unnz5llzBgwYsA3fdcmbPn36Rt9LUbz22mtZ8777+v3vf1/kax9xxBFZc3/zm9+k165du8U5ixcvTnft2jVr3pNPPrnZ8dOmTUvXrl07M7ZWrVrp559/fqu1vf7661m/5yZNmqRXrVpV5O9tay644IKs7+G+++4r8twFCxak582bt9nnu3fvvtHvpUaNGulXXnlli+uee+65WXNq1aqVnjlz5hbnvPbaa0WuO51Opx988MGsaxx//PFbnXPiiSdmzalXr1761VdfLdL1VqxYkX7rrbc2+3xpvwb/9re/ZY274oorilR3Op1OL1u2LD1r1qwijwcAACgJdhgAAACgwttll13izDPPzLTXr18fQ4YMKZG177zzzli1alWmvffee8c999wTqVRqs3N22223GDZsWNaY//3vf/H555+XSE3lRdeuXePWW28t0ti33347XnzxxUz7yCOPjH/84x9b3U6+QYMG8cQTT0TdunUzfVv6JPyNN94YK1euzLTvu+++OPLII7da36GHHho333xzpj1v3ryNdmPYHp999lnmcZ06deKUU04p8txGjRoV+5iCa6+9Ng477LAtjrnlllvi4IMPzrRXrVoV//jHP7Y4p0ePHsWq45RTTomTTz45037yySdj6dKlmx3/6aefxn/+859MO5VKxX//+9/o2bNnka5Xu3btOOiggzb5XFm8Br//e46IGDx4cJHqjvj2ddGyZcsijwcAACgJAgMAAABUChdffHHWDb3//Oc/8dFHH23Xmul0Ou69996svptvvjmqVq261bkHH3xwnHDCCVlr3XPPPdtVT3lz1VVXbTE48X233357Vvu2224r8tydd945Bg0alGmPGTMmvv76643GLVq0KOvoiIMPPnijbfG35Ne//nU0adIk037iiSeKPHdrvh86ycvLi7y80vuTTPPmzePss8/e6rhUKrXR9vn333//Vo98KK7vBwbWr1+/xWMJ7rjjjqzrn3zyyXH44YeXSB1l8Rr8/u85IrYaRgAAAMg1gQEAAAAqhUaNGsUf/vCHTLugoCD++Mc/btean376acybNy/T3nXXXaNXr15Fnv+rX/0qq/3GG29sVz3lSdOmTbf6CfbvFBQUZH2yu0uXLrHnnnsW63p9+/bNao8ePXqjMaNGjcq6YfuLX/yiWNeoVq1a1ifZx44dGwUFBcVaY3OaNWuWefzNN9/Es88+WyLrbsqJJ55Y5BvVhxxySLRp0ybTnjt3bkyZMqVE62ndunVW+4MPPtjs2JdffjmrXZTgQ1GU1Wvw+7/niCjRXSoAAABKg8AAAAAAlcYf/vCHaNSoUab9zDPPxPjx47d5vXHjxmW1e/bsWeRPJEd8u83993cj+OCDD2Lt2rXbXE95sv/++xf5Z/HRRx9lbUO///77F/t6u+66a1Z78uTJG40pfAN3e6/zzTffRH5+frHX2JQ+ffpktX/+85/HLbfcEkuWLCmR9b+vuMcGdO/ePatdlPdMQUFBvPrqq3HeeedF7969o1WrVtGgQYOoUqVKpFKprK/CN+YXLFiwyTXnzJkT06ZNy7SbNGmyTb/DTSmr12Dh3/N5550Xl19+ecydO7fY1wMAACgLAgMAAABUGvXq1YuLLrooq++yyy7b5vVmzpyZ1e7UqVOx5teoUSPatWuXaa9Zs2aT25hXRIU/Nb4lhW+s3nnnnRvdVN7aV8eOHbPWWLRo0Vav06VLl2Jf56abbtrqdbbFcccdFx06dMi0ly9fHueff340bdo0+vbtG9dff328+eabsXr16u2+1g9/+MPtGj99+vQtjn/mmWeibdu20atXr7j11lvjlVdeiVmzZsXSpUuLtCPD5kIS3w8LRER07tx5q2sVVVm9Brt27ZoVGli/fn1ce+210bx58zjkkEPiyiuvjFdeeSWWLVtWYt8bAADA9hAYAAAAoFI566yzYpdddsm0R44cGaNGjdqmtRYvXpzVbty4cbHXKDyn8JoVVb169Yo8duHChSV+/e9/Wrysr7MtqlWrFs8+++xGn7Zfu3ZtjBgxIi655JI45JBDokGDBtGzZ8+4/fbbtzlc8v1dNrZl/JZ2Pbj00kvj2GOP3WqoYEvWrFmzyf7CN+CbNGmyzdcorCxfG//+97/joIMOyuorKCiIN998M4YOHRq9e/eOHXfcMQ4++OC49tprY8aMGSVeGwAAQFEJDAAAAFCp1KpVKy6//PKsvm3dZWD58uVZ7R122KHYaxSeU1k+WVytWrUijy2Nbfc39Un2srrOtmrTpk28//77mU+cb8qaNWti1KhRce6558auu+4aZ599drFfM7Vr1y7W+MKv0cKv++88+OCDcd1112X11apVK/r27RuXX3553HXXXfHkk0/G8OHDY8SIEZmvRx55pEh1FP4+69SpU4zvYsvK8rXRuHHjeOONN+LOO++Mtm3bbnLM+vXr4+23347LL788dt999/jFL35RaXYfAQAAKpaqWx8CAAAAFcugQYPipptuynxyd+zYsTF8+PA4+uiji7VO4RuWK1asKHYthefUrVu32GtUdIVvYJ900knxq1/9arvWbNas2Vavc//990eLFi226zp77733ds0vrHbt2nHppZfGxRdfHGPGjIlXX301Ro0aFePGjYtVq1ZljV27dm385S9/iZdffjneeOONIn/ifuXKlcV6nRV+jW7qRv3atWs3Ou7jV7/6Vdx4441b3dFgypQpRaqjcM2bCy5si7J6DX6nWrVq8dvf/jZ++9vfxrvvvhuvvPJKjBo1KsaOHRvffPNN1tiCgoJ45JFHMruhFN6FAgAAoDQJDAAAAFDpVK9ePa688soYOHBgpu/yyy+Po446KlKpVJHXadiwYVZ7W7Y1X7BgwRbXTILCxzI0aNAgevfuXerX6dChQ3Tp0qXEr1MS8vLy4pBDDolDDjkkhgwZEuvWrYt33303Xnzxxfj3v/8dU6dOzYydMmVKDBw4MJ5//vkirb1gwYJiBQYKv64bNGiw0ZhRo0ZlfQK+b9++ce+99xZp/cJHDWzOjjvumNWeN29ekeYVRVm9Bjdl//33j/333z8uuuiiKCgoiAkTJsSLL74Y//nPf2LChAmZcXPnzo2f/vSnMWHChMjLsykoAABQNvzXBwAAAJXSySefHO3atcu0P/zww3j88ceLtUarVq2y2t+/uVcUa9asyfp0dY0aNaJp06bFWqMyaN26dVb7+zfDK+J1SkO1atXi4IMPjqFDh8Znn30Wf/vb37JuGr/wwgsxefLkIq318ccfF+vaH330UVa78M8xIuLtt9/Oag8ePLjI63/yySdFGld4+/733nuvyNfYmvLy2sjLy4t99903Lrnkkvjwww/jiSeeiFq1amWe//jjj+Oll17KSW0AAEAyCQwAAABQKVWpUiWuuuqqrL4rrrgiNmzYUOQ1DjrooKz2qFGjIp1OF3n+6NGjY926dZn2fvvtF9WrVy/y/MqiS5cuWVvCjx07NlavXl3i1+nZs2dW+9VXXy3xa5SFVCoVgwcPjp/97GdZ/W+++WaR5r/++uvFut4bb7yR1d7Urgzf310gIoq1bX5Rfw8777xz7LHHHpn2vHnz4t133y3ydbakrF6DxfXjH/84zjvvvKy+ov6eAQAASoLAAAAAAJXWT3/609h3330z7U8//TQefvjhIs/fc889s3YEmDlzZrz22mtFnn/fffdltbt3717kuZVJ9erV47DDDsu0V6xYEffff3+JX6d3795Rter/P33xscce26ZjJMqLbt26ZbULH2+xOY899lhWUGVLRo8eHV988UWmvfPOO28yDFA4KLN27doirf/111/Hk08+WaSxERFHHHFEVvuOO+4o8twtKavX4LbY1t8zAABASRAYAAAAoNJKpVJxzTXXZPUNHTq0yDdTU6lUnHbaaVl9F1xwQZF2KRg/fnw89thjWWsNGjSoSNetjC644IKs9pAhQ2LWrFkleo2mTZvGL37xi0x7xYoVceaZZ5boNcpS4RvHDRs2LNK8/Pz8It1oT6fTcdFFF2X1DRw4MFKp1EZjd95556x2UT8F/7vf/S7WrFlTpLHfjf/+UQyPPPJIvPzyy0WevyVl8RrcFtv6ewYAACgJAgMAAABUakcddVTWJ3hnzJgRX331VZHn//a3v806Y/z999+PM844Y4tHE8yaNSt++tOfZo0ZMGBA7L777pud06NHj0ilUpmvK6+8ssg1VgSHHnpoHH744Zn2/Pnzo2/fvvHpp58WeY2CgoJ4+umnN7rJ/X2XX3551tbz//nPf+L0008v8ifiIyIWLVoU11xzTTz77LNFnrM1P//5z4t1VMDixYvjnnvuyerr3LlzkedfdtllW90N47zzzou33nor065Zs2acccYZmxzbtWvXrPb111+/1U/CX3755TFs2LAiVvytPfbYI+sohnQ6Hccdd1yMGjWqSPNXrFgRb7/99iafK4vX4JlnnhnPPvtskY8uWbNmzUbhjuL8ngEAALaXwAAAAACV3rXXXrvNc1u0aBE33nhjVt8999wThx122EY3JlesWBH33ntvdO7cOb788stM/4477hh/+9vftrmGyuKhhx6Kli1bZtpTpkyJzp07x+9///uYMGHCJm+yLl68OEaOHBnnnntu7LbbbvGjH/0oxo0bt9lrtGnTJu69996svrvuuiv22muvuPvuu+Prr7/eaE46nY5p06bFww8/HD/+8Y+jRYsW8cc//rFEjzMYPnx49OjRIzp06BBDhgyJt956K1auXLnRuFWrVsWwYcPiwAMPjJkzZ2b699577zjggAOKdK1WrVrFmjVr4ogjjoihQ4fG/Pnzs57/6KOPon///nHbbbdl9V9xxRXRqlWrTa7ZvXv3rOe+/PLL6NatW4wYMSLr95ZOp2Ps2LHRp0+fzPuuffv2Rar7O3/961+jTZs2mfY333wTvXv3jkGDBsX777+/0etk9erV8eabb8a5554brVq1in/84x+bXbu0X4NjxoyJ/v37R+vWreP888+PUaNGxTfffLPRuHXr1sWLL74Y3bp1i3feeSfTv/POO0e/fv02/8MBAAAoYal0USPPAAAAkEO77bZb1g3UxYsXR4MGDYo8v2/fvjFixIhNPre1tdLpdJx66qnx8MMPb/TcTjvtFC1btozVq1fH9OnTY9WqVVnP16pVK5566qmsTzZvSo8ePbI+gT5kyJBS2WVgxowZ0bp160z71FNPjQceeGCr80aNGhU9e/bc7vo++uijOProo7MCFd+pX79+NG/ePOrWrRvLly+PRYsWxZw5czYa1717961+4vzWW2+NCy64IAoKCjZ6rmXLltG4ceOoWrVqLFmyJObOnRvLli3baNz9998fAwcOLPL3tiUNGjSIpUuXZvVVqVIlWrRoETvuuGNUr149/l97d/fa4/8HcPz1+bpZYzeNMFuUuSnGNqKIlMS05eaEnEj+BVISR9qBxYmUM8LhpLSIEwfYaqsppGWrYbYmZmNF4vOx7xH9ZpvNfd/f9XgcXtd77+t9fbqOdj2v63r9+nV0dHQM+2TGlClT4vbt27FixYoR5/762rl582Zs3rw50ul0RERMnDgx5s2bF/n5+dHT0xPd3d3D5qisrIz6+vqYNGnSqOdQV1cXu3btGra9oKAgSkpKIpPJRGdnZ/T19X3ZN2vWrKirq4v169d/2Taea+7hw4exZcuW6OrqGrZv2rRpUVxcHNnZ2dHf3x9PnjwZ8puNNf/vvAYrKiri3r17Q7alUqkoLi6O6dOnR3Z2dgwMDERHR0e8f/9+yLgJEybElStXorq6etS1AwAA/GoT//YCAAAA4E+oqakZNRgYSyqVivPnz0dhYWGcPHlyyE3oly9fDnuC+7PCwsKoq6uLdevW/dBx/x8tW7YsWlpaYs+ePXHjxo0h+968eTPspvpI5s6dO+aY/fv3R2lpaezbt2/YDd9nz56NeLP4f2VlZcXMmTPHPM7PyGQy8fTp0yEhzNeKi4ujrq5u1FhgJBs2bIiLFy/G3r1748OHD5FOp6O9vX3U8VVVVXHp0qVvxgIRETt37oyampo4cuTIkCfx+/v7o6WlZdj4OXPmxLVr1yInJ2fca/+stLQ0mpqaYufOndHY2DhkX19f35Ao4Xv9qWvws8HBwejq6hoxfvisoKAgzp07JxYAAAD+OJ8kAAAAIBFWrVoVO3bs+OG/T6VSUVtbG3fv3o1t27ZFVlbWqGOLiori6NGj0d7eLhYYwYwZM+L69etx69at2Lp1a0ydOvWb41OpVCxfvjwOHToU9+/fjwsXLozrOJWVldHR0RGnTp2KsrKySKVS3xyfk5MT1dXVcebMmejp6Ymqqqpxn9NYmpubo7a2NjZu3Djm+UZELFiwII4dOxaPHj2KNWvWfPfxdu/eHc3NzbFp06ZRx5SUlMTZs2fj6tWrkZ2dPa55Dx8+HFevXo3y8vJRx+Tl5cWBAwfiwYMHsXTp0u9e+2dFRUXR0NAQly9fjrVr18aECRNGHZtKpaKioiKOHz8eJ06cGHPu33UN1tfXx+nTp6O6unpcb0ApKiqKgwcPRltbW2zfvn3M8QAAAL+aTxIAAADAD3j37l3cuXMnOjs7o7e398sT6aWlpVFRUfG3l/ef8vHjx2hubo7Hjx9Hb29vvH37NqZOnRoFBQWxaNGiWLJkSeTn5//0cV6+fBlNTU3x/PnzePXqVXz69Cny8vKisLAwFi9eHAsXLhzzKftfIZPJRGtra7S3t0d3d/eXzyHk5uZGcXFxVFRUDPlsxFi+/iTB1//q6erqioaGhujs7Ix0Oh2zZ8+OpUuXxsqVK3/qPFpbW6OpqSlevHgR6XQ6pk+fHosXL47Vq1fH5MmTf2rukfT390djY2P09PREb29vpFKpyM/Pj/nz50d5eflPvRHid1yDg4OD0dbWFu3t7dHZ2RkDAwORyWQiNzc3CgsLo6ysLBYtWhT//ON5HgAA4O8RDAAAAAD8h40VDAAAAMBoJMwAAAAAAAAAkECCAQAAAAAAAABIIMEAAAAAAAAAACSQYAAAAAAAAAAAEkgwAAAAAAAAAAAJJBgAAAAAAAAAgAQSDAAAAAAAAABAAqUGBwcH//YiAAAAAAAAAIA/yxsGAAAAAAAAACCBBAMAAAAAAAAAkECCAQAAAAAAAABIIMEAAAAAAAAAACSQYAAAAAAAAAAAEkgwAAAAAAAAAAAJJBgAAAAAAAAAgAQSDAAAAAAAAABAAgkGAAAAAAAAACCBBAMAAAAAAAAAkECCAQAAAAAAAABIIMEAAAAAAAAAACSQYAAAAAAAAAAAEkgwAAAAAAAAAAAJJBgAAAAAAAAAgAQSDAAAAAAAAABAAgkGAAAAAAAAACCBBAMAAAAAAAAAkECCAQAAAAAAAABIIMEAAAAAAAAAACSQYAAAAAAAAAAAEkgwAAAAAAAAAAAJJBgAAAAAAAAAgAQSDAAAAAAAAABAAgkGAAAAAAAAACCBBAMAAAAAAAAAkECCAQAAAAAAAABIIMEAAAAAAAAAACTQv1ek6Q3GhZkeAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1235,7 +1213,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 30, @@ -1244,7 +1222,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1260,9 +1238,7 @@ "ax.hist(values)\n", "\n", "ylims = ax.get_ylim()\n", - "ax.vlines(\n", - " np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3\n", - ")\n", + "ax.vlines(np.mean(list(values)), *ylims, \"tab:orange\", \"dashed\", label=\"Mean\", lw=3)\n", "ax.set_ylim(*ylims)\n", "\n", "ax.set_xlabel(\"Utilisation\")\n", @@ -1298,9 +1274,7 @@ "for project, project_students in matching.items():\n", " for student in project_students:\n", " inverted_matching[student.name] = project.name\n", - " student_preference_of_matching.append(\n", - " student._pref_names.index(project.name)\n", - " )" + " student_preference_of_matching.append(student._pref_names.index(project.name))" ] }, { @@ -1572,7 +1546,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1618,7 +1592,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 36, @@ -1627,7 +1601,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1692,9 +1666,7 @@ "outputs": [], "source": [ "project_with_space_names = [\n", - " project.name\n", - " for project in game.projects\n", - " if len(project.matching) < project.capacity\n", + " project.name for project in game.projects if len(project.matching) < project.capacity\n", "] + list(unranked_projects)\n", "\n", "supervisor_with_space_names = [\n", @@ -1745,17 +1717,17 @@ "metadata": {}, "outputs": [], "source": [ - "projects_with_space[\"supervisor_capacity\"] = projects_with_space[\n", - " \"supervisor\"\n", - "].apply(lambda x: get_capacity(supervisors, \"supervisor\", x))\n", + "projects_with_space[\"supervisor_capacity\"] = projects_with_space[\"supervisor\"].apply(\n", + " lambda x: get_capacity(supervisors, \"supervisor\", x)\n", + ")\n", "\n", "projects_with_space[\"project_matches\"] = projects_with_space[\"code\"].apply(\n", " lambda x: get_number_of_matches(x, \"projects\", game)\n", ")\n", "\n", - "projects_with_space[\"supervisor_matches\"] = projects_with_space[\n", - " \"supervisor\"\n", - "].apply(lambda x: get_number_of_matches(x, \"supervisors\", game))\n", + "projects_with_space[\"supervisor_matches\"] = projects_with_space[\"supervisor\"].apply(\n", + " lambda x: get_number_of_matches(x, \"supervisors\", game)\n", + ")\n", "\n", "projects_with_space = projects_with_space[\n", " [\n", @@ -1873,9 +1845,7 @@ } ], "source": [ - "projects_with_space = projects_with_space.set_index(\n", - " [\"supervisor\", \"code\"]\n", - ").sort_index()\n", + "projects_with_space = projects_with_space.set_index([\"supervisor\", \"code\"]).sort_index()\n", "\n", "projects_with_space" ] @@ -1891,7 +1861,7 @@ "metadata": { "celltoolbar": "Tags", "kernelspec": { - "display_name": "matching", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -1905,7 +1875,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.13.1" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 3033b7c1..46bfcd06 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,3 @@ -[build-system] -requires = ["setuptools>=62"] -build-backend = "setuptools.build_meta" - [project] name = "matching" authors = [ @@ -11,7 +7,7 @@ authors = [ description = "A package for solving matching games" readme = "README.md" requires-python = ">=3.10" -license = {text = "MIT License"} +license = {text = "MIT Licence"} keywords = [ "game-theory", "gale-shapley", @@ -29,29 +25,36 @@ classifiers = [ "Topic :: Scientific/Engineering :: Information Analysis", ] dependencies = [ - "numpy>=1.21.6", + "numpy>=2.2.4", "scipy>=1.11.3", ] dynamic = ["version"] +[build-system] +requires = ["setuptools>=62"] +build-backend = "setuptools.build_meta" + [project.optional-dependencies] test = [ - "hypothesis>=6.31.6", - "nbval>=0.10.0", - "pytest>=6.2.5", - "pytest-cov>=3.0.0", - "pytest-randomly>=3.10", + "hypothesis>=6.129.4", + "nbval>=0.11.0", + "pytest>=7.4.4", + "pytest-cov>=6.0.0", + "pytest-randomly>=3.16.0", ] docs = [ - "ipython>=7.10", - "matplotlib>=3", - "nbsphinx>=0.8.8", - "pandas>=1.1.5", - "PyYAML>=6", - "quartodoc>=0.5.0; python_version>'3.8'", + "ipython>=7.34.0", + "matplotlib>=3.10.1", + "nbsphinx>=0.9.7", + "pandas>=2.2.3", + "pyyaml>=6.0.1", + "quartodoc>=0.9.1", +] +dev = [ + "matching[docs,test]", + "pytest-sugar>=1.0.0", + "ruff>=0.11.1", ] -lint = ["ruff<1.0"] -dev = ["matching[docs,lint,test]", "pre-commit"] [project.urls] homepage = "https://github.com/daffidwilde/matching" @@ -61,12 +64,9 @@ changelog = "https://github.com/daffidwilde/matching/blob/main/CHANGES.md" [tool.setuptools.dynamic] version = {attr = "matching.__version__"} -[tool.coverage.report] -omit = ["src/**/__init__.py"] - [tool.ruff] +line-length = 99 extend-include = ["*.ipynb"] -line-length = 79 [tool.ruff.lint] extend-select = ["D", "I", "W"] @@ -83,3 +83,6 @@ known-first-party = ["matching"] [tool.ruff.lint.pydocstyle] convention = "numpy" + +[tool.coverage.run] +branch = true diff --git a/src/matching/__init__.py b/src/matching/__init__.py index 538e3ee7..efb21ee2 100644 --- a/src/matching/__init__.py +++ b/src/matching/__init__.py @@ -7,8 +7,10 @@ warnings.simplefilter("always") +from . import matchings from .base import BaseGame, BaseMatching, BasePlayer -from .matchings import MultipleMatching, SingleMatching +from .matchings import _MultipleMatching as MultipleMatching +from .matchings import _SingleMatching as SingleMatching from .players import Hospital, Player, Project, Supervisor __version__ = "2.0.0" @@ -18,11 +20,11 @@ "BaseMatching", "BasePlayer", "Hospital", - "Matching", "MultipleMatching", "Player", "Project", "SingleMatching", "Supervisor", "__version__", + "matchings", ] diff --git a/src/matching/algorithms/hospital_resident.py b/src/matching/algorithms/hospital_resident.py index 61cf491c..52d6c1a3 100644 --- a/src/matching/algorithms/hospital_resident.py +++ b/src/matching/algorithms/hospital_resident.py @@ -13,9 +13,9 @@ def _unmatch_pair(resident, hospital): def _check_available(hospital): """Check if a hospital is willing and able to take an applicant.""" - return len(hospital.matching) < hospital.capacity and set( - hospital.prefs - ).difference(hospital.matching) + return len(hospital.matching) < hospital.capacity and set(hospital.prefs).difference( + hospital.matching + ) def hospital_resident(residents, hospitals, optimal="resident"): diff --git a/src/matching/algorithms/student_allocation.py b/src/matching/algorithms/student_allocation.py index 81db0d76..383af816 100644 --- a/src/matching/algorithms/student_allocation.py +++ b/src/matching/algorithms/student_allocation.py @@ -111,9 +111,7 @@ def student_optimal(students, projects): successors = supervisor.get_successors() for successor in successors: supervisor_projects = [ - project - for project in supervisor.projects - if project in successor.prefs + project for project in supervisor.projects if project in successor.prefs ] for project in supervisor_projects: @@ -167,9 +165,7 @@ def supervisor_optimal(projects, supervisors): _delete_pair(student, successor) free_supervisors = [ - supervisor - for supervisor in supervisors - if supervisor.get_favourite() is not None + supervisor for supervisor in supervisors if supervisor.get_favourite() is not None ] return {p: p.matching for p in projects} diff --git a/src/matching/base.py b/src/matching/base.py index 2255a0f0..e6e6fac7 100644 --- a/src/matching/base.py +++ b/src/matching/base.py @@ -151,9 +151,7 @@ def _check_inputs_player_prefs_unique(self, party): unique_prefs.append(other) else: warnings.warn( - PreferencesChangedWarning( - f"{player} has ranked {other} multiple times." - ) + PreferencesChangedWarning(f"{player} has ranked {other} multiple times.") ) if self.clean: @@ -172,8 +170,7 @@ def _check_inputs_player_prefs_all_in_party(self, party, other_party): if other not in others: warnings.warn( PreferencesChangedWarning( - f"{player} has ranked a non-{other_party[:-1]}: " - f"{other}." + f"{player} has ranked a non-{other_party[:-1]}: {other}." ) ) if self.clean: @@ -187,11 +184,7 @@ def _check_inputs_player_prefs_nonempty(self, party, other_party): for player in vars(self)[party]: if not player.prefs: - warnings.warn( - PlayerExcludedWarning( - f"{player} has an empty preference list." - ) - ) + warnings.warn(PlayerExcludedWarning(f"{player} has an empty preference list.")) if self.clean: self._remove_player(player, party, other_party) diff --git a/src/matching/games/_old_hospital_resident.py b/src/matching/games/_old_hospital_resident.py new file mode 100644 index 00000000..c65054ef --- /dev/null +++ b/src/matching/games/_old_hospital_resident.py @@ -0,0 +1,268 @@ +"""An old module for the hospital-resident assignment problem.""" + +import copy +import warnings + +from matching import BaseGame, MultipleMatching +from matching import Player as Resident +from matching.algorithms import hospital_resident +from matching.exceptions import ( + MatchingError, + PlayerExcludedWarning, + PreferencesChangedWarning, +) +from matching.players import Hospital + + +class HospitalResident(BaseGame): + """Solver for the hospital-resident assignment problem (HR). + + In this case, a blocking pair is any resident-hospital pair that + satisfies **all** of the following: + + - They are present in each other's preference lists; + - either the resident is unmatched, or they prefer the hospital + to their current match; + - either the hospital is under-subscribed, or they prefer the + resident to at least one of their current matches. + + Parameters + ---------- + residents : list of Player + The residents in the matching game. Each resident must rank a + subset of those in ``hospitals``. + hospitals : list of Hospital + The hospitals in the matching game. Each hospital must rank all + of (and only) the residents which rank it. + clean : bool + Indicator for whether the players of the game should be cleaned. + Cleaning is reductive in nature, removing players from the game + and/or other player's preferences if they do not meet the + requirements of the game. + + Attributes + ---------- + matching : MultipleMatching or None + Once the game is solved, a matching is available as a + ``MultipleMatching`` object with the hospitals as keys and their + resident matches as values. Initialises as ``None``. + blocking_pairs : list of (Player, Hospital) or None + Initialises as ``None``. Otherwise, a list of the + resident-hospital blocking pairs. + """ + + def __init__(self, residents, hospitals, clean=False): + residents, hospitals = copy.deepcopy([residents, hospitals]) + self.residents = residents + self.hospitals = hospitals + self.clean = clean + + self._all_residents = residents + self._all_hospitals = hospitals + + super().__init__(clean) + self.check_inputs() + + @classmethod + def create_from_dictionaries(cls, resident_prefs, hospital_prefs, capacities, clean=False): + """Create an instance from a set of dictionaries. + + A preference dictionary for residents and hospitals is required, + along with a dictionary detailing the hospital capacities. If + ``clean``, then remove players from the game and/or player + preferences if they do not satisfy the conditions of the game. + """ + + residents, hospitals = _make_players(resident_prefs, hospital_prefs, capacities) + game = cls(residents, hospitals, clean) + + return game + + def solve(self, optimal="resident"): + """Solve the instance of HR. Return the matching. + + The party optimality can be controlled using the ``optimal`` + parameter. + """ + + self.matching = MultipleMatching( + hospital_resident(self.residents, self.hospitals, optimal) + ) + return self.matching + + def check_validity(self): + """Check whether the current matching is valid.""" + + unacceptable_issues = self._check_for_unacceptable_matches( + "residents" + ) + self._check_for_unacceptable_matches("hospitals") + + oversubscribed_issues = self._check_for_oversubscribed_players("hospitals") + + if unacceptable_issues or oversubscribed_issues: + raise MatchingError( + unacceptable_matches=unacceptable_issues, + oversubscribed_hospitals=oversubscribed_issues, + ) + + return True + + def _check_for_unacceptable_matches(self, party): + """Check that no one in ``party`` has an unacceptable match.""" + + issues = [] + for player in vars(self)[party]: + issue = player.check_if_match_is_unacceptable(unmatched_okay=True) + if isinstance(issue, list): + issues.extend(issue) + elif isinstance(issue, str): + issues.append(issue) + + return issues + + def _check_for_oversubscribed_players(self, party): + """Check that no player in `party` is over-subscribed.""" + + issues = [] + for player in vars(self)[party]: + issue = player.check_if_oversubscribed() + if issue: + issues.append(issue) + + return issues + + def check_stability(self): + """Check for the existence of any blocking pairs.""" + + blocking_pairs = [] + for resident in self.residents: + for hospital in self.hospitals: + if ( + _check_mutual_preference(resident, hospital) + and _check_resident_unhappy(resident, hospital) + and _check_hospital_unhappy(resident, hospital) + ): + blocking_pairs.append((resident, hospital)) + + self.blocking_pairs = blocking_pairs + return not any(blocking_pairs) + + def check_inputs(self): + """Check if any rules of the game have been broken. + + Any violations will be flagged as warnings. If the ``clean`` + attribute is in use, then any violations will be removed. + """ + + self._check_inputs_player_prefs_unique("residents") + self._check_inputs_player_prefs_unique("hospitals") + + self._check_inputs_player_prefs_all_in_party("residents", "hospitals") + self._check_inputs_player_prefs_all_in_party("hospitals", "residents") + + self._check_inputs_player_prefs_all_reciprocated("hospitals") + self._check_inputs_player_reciprocated_all_prefs("hospitals", "residents") + + self._check_inputs_player_prefs_nonempty("residents", "hospitals") + self._check_inputs_player_prefs_nonempty("hospitals", "residents") + + self._check_inputs_player_capacity("hospitals", "residents") + + def _check_inputs_player_prefs_all_reciprocated(self, party): + """Check everyone has only ranked players who ranked them.""" + + for player in vars(self)[party]: + for other in player.prefs: + if player not in other.prefs: + warnings.warn( + PreferencesChangedWarning(f"{player} ranked {other} but they did not.") + ) + if self.clean: + player._forget(other) + + def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): + """Check everyone has ranked all the players who ranked them.""" + + players = vars(self)[party] + others = vars(self)[other_party] + for player in players: + others_that_ranked = [other for other in others if player in other.prefs] + for other in others_that_ranked: + if other not in player.prefs: + warnings.warn( + PreferencesChangedWarning(f"{other} ranked {player} but they did not.") + ) + if self.clean: + other._forget(player) + + def _check_inputs_player_capacity(self, party, other_party): + """Check everyone has a capacity of at least one.""" + + for player in vars(self)[party]: + if player.capacity < 1: + warnings.warn(PlayerExcludedWarning(player)) + + if self.clean: + self._remove_player(player, party, other_party) + + +def _check_mutual_preference(resident, hospital): + """Check whether two players have a preference of each other.""" + + return resident in hospital.prefs and hospital in resident.prefs + + +def _check_resident_unhappy(resident, hospital): + """Check whether a resident is unhappy given a hospital. + + An unhappy resident is either unmatched or they prefer the hospital + to their current match. + """ + + return resident.matching is None or resident.prefers(hospital, resident.matching) + + +def _check_hospital_unhappy(resident, hospital): + """Check whether a hospital is unhappy given a resident. + + An unhappy hospital is either under-subscribed or they prefer the + resident to at least one of their current matches. + """ + + return len(hospital.matching) < hospital.capacity or any( + [hospital.prefers(resident, match) for match in hospital.matching] + ) + + +def _make_players(resident_prefs, hospital_prefs, capacities): + """Make a set of residents and hospitals from the dictionaries.""" + + resident_dict, hospital_dict = _make_instances(resident_prefs, hospital_prefs, capacities) + + for resident_name, resident in resident_dict.items(): + prefs = [hospital_dict[name] for name in resident_prefs[resident_name]] + resident.set_prefs(prefs) + + for hospital_name, hospital in hospital_dict.items(): + prefs = [resident_dict[name] for name in hospital_prefs[hospital_name]] + hospital.set_prefs(prefs) + + residents = list(resident_dict.values()) + hospitals = list(hospital_dict.values()) + + return residents, hospitals + + +def _make_instances(resident_prefs, hospital_prefs, capacities): + """Create ``Player`` (resident) and ``Hospital`` instances.""" + + resident_dict, hospital_dict = {}, {} + for resident_name in resident_prefs: + resident = Resident(name=resident_name) + resident_dict[resident_name] = resident + for hospital_name in hospital_prefs: + capacity = capacities[hospital_name] + hospital = Hospital(name=hospital_name, capacity=capacity) + hospital_dict[hospital_name] = hospital + + return resident_dict, hospital_dict diff --git a/src/matching/games/hospital_resident.py b/src/matching/games/hospital_resident.py index 13593fd5..d15831da 100644 --- a/src/matching/games/hospital_resident.py +++ b/src/matching/games/hospital_resident.py @@ -1,286 +1,358 @@ """The HR game class and supporting functions.""" -import copy import warnings -from matching import BaseGame, MultipleMatching -from matching import Player as Resident -from matching.algorithms import hospital_resident -from matching.exceptions import ( - MatchingError, - PlayerExcludedWarning, - PreferencesChangedWarning, -) -from matching.players import Hospital +import numpy as np +from matching import convert, matchings -class HospitalResident(BaseGame): - """Solver for the hospital-resident assignment problem (HR). - In this case, a blocking pair is any resident-hospital pair that - satisfies **all** of the following: - - - They are present in each other's preference lists; - - either the resident is unmatched, or they prefer the hospital - to their current match; - - either the hospital is under-subscribed, or they prefer the - resident to at least one of their current matches. +class HospitalResident: + """ + Solver for the hospital-resident assignment problem (HR). Parameters ---------- - residents : list of Player - The residents in the matching game. Each resident must rank a - subset of those in ``hospitals``. - hospitals : list of Hospital - The hospitals in the matching game. Each hospital must rank all - of (and only) the residents which rank it. - clean : bool - Indicator for whether the players of the game should be cleaned. - Cleaning is reductive in nature, removing players from the game - and/or other player's preferences if they do not meet the - requirements of the game. + resident_ranks : np.ndarray + The rank matrix of all hospitals by the residents. + hospital_ranks : np.ndarray + The rank matrix of all residents by the hospitals. + capacities : np.ndarray + Capacity matrix for the hospitals. Attributes ---------- + num_residents : int + Number of residents. + num_hospitals : int + Number of hospitals. matching : MultipleMatching or None - Once the game is solved, a matching is available as a - ``MultipleMatching`` object with the hospitals as keys and their - resident matches as values. Initialises as ``None``. - blocking_pairs : list of (Player, Hospital) or None - Initialises as ``None``. Otherwise, a list of the - resident-hospital blocking pairs. + Once the game is solved, a matching is available. This uses the + indices of the hospital and resident rank matrices as keys and + values, respectively, in a `MultipleMatching` object. + Initialises as `None`. """ - def __init__(self, residents, hospitals, clean=False): - residents, hospitals = copy.deepcopy([residents, hospitals]) - self.residents = residents - self.hospitals = hospitals - self.clean = clean + def __init__(self, resident_ranks, hospital_ranks, capacities): + self.resident_ranks = resident_ranks.copy() + self.hospital_ranks = hospital_ranks.copy() + self.capacities = capacities.copy() - self._all_residents = residents - self._all_hospitals = hospitals + self.num_residents = len(resident_ranks) + self.num_hospitals = len(hospital_ranks) + self.matching = None + self._preference_lookup = None - super().__init__(clean) - self.check_inputs() + self.check_input_validity() @classmethod - def create_from_dictionaries( - cls, resident_prefs, hospital_prefs, capacities, clean=False - ): - """Create an instance from a set of dictionaries. - - A preference dictionary for residents and hospitals is required, - along with a dictionary detailing the hospital capacities. If - ``clean``, then remove players from the game and/or player - preferences if they do not satisfy the conditions of the game. + def from_utilities(cls, resident_utils, hospital_utils, capacities): """ - - residents, hospitals = _make_players( - resident_prefs, hospital_prefs, capacities - ) - game = cls(residents, hospitals, clean) - - return game - - def solve(self, optimal="resident"): - """Solve the instance of HR. Return the matching. - - The party optimality can be controlled using the ``optimal`` - parameter. + Create an instance of HR from utility matrices. + + Higher utilities indicate higher preferences. If there are any + ties, they are broken in order of appearance. + + Parameters + ---------- + resident_utils : np.ndarray + Resident utility matrix. + hospital_utils : np.ndarray + Hospital utility matrix. + capacities : np.ndarray + Hospital capacity vector. + + Returns + ------- + HospitalResident + An instance of HR with utilities resolved as rank matrices. """ + resident_ranks = convert.utility_to_rank(resident_utils) + hospital_ranks = convert.utility_to_rank(hospital_utils) - self.matching = MultipleMatching( - hospital_resident(self.residents, self.hospitals, optimal) - ) - return self.matching - - def check_validity(self): - """Check whether the current matching is valid.""" - - unacceptable_issues = self._check_for_unacceptable_matches( - "residents" - ) + self._check_for_unacceptable_matches("hospitals") - - oversubscribed_issues = self._check_for_oversubscribed_players( - "hospitals" - ) + return cls(resident_ranks, hospital_ranks, capacities) - if unacceptable_issues or oversubscribed_issues: - raise MatchingError( - unacceptable_matches=unacceptable_issues, - oversubscribed_hospitals=oversubscribed_issues, - ) - - return True - - def _check_for_unacceptable_matches(self, party): - """Check that no one in ``party`` has an unacceptable match.""" - - issues = [] - for player in vars(self)[party]: - issue = player.check_if_match_is_unacceptable(unmatched_okay=True) - if isinstance(issue, list): - issues.extend(issue) - elif isinstance(issue, str): - issues.append(issue) - - return issues - - def _check_for_oversubscribed_players(self, party): - """Check that no player in `party` is over-subscribed.""" - - issues = [] - for player in vars(self)[party]: - issue = player.check_if_oversubscribed() - if issue: - issues.append(issue) - - return issues - - def check_stability(self): - """Check for the existence of any blocking pairs.""" + @classmethod + def from_preferences(cls, resident_prefs, hospital_prefs, capacities): + """ + Create an instance of HR from preference list dictionaries. + + Each dictionary should contain a strict ordering of the other + side by each player. The ranking is taken by the order of the + preference list. + + Parameters + ---------- + resident_prefs : dict + Resident preference lists. + hospital_prefs : dict + Hospital preference lists. + capacities : dict + Hospital capacities. + + Returns + ------- + HospitalResident + An instance of HR with preference lists resolved as rank + matrices. + """ + residents, hospitals = sorted(resident_prefs), sorted(hospital_prefs) - blocking_pairs = [] - for resident in self.residents: - for hospital in self.hospitals: - if ( - _check_mutual_preference(resident, hospital) - and _check_resident_unhappy(resident, hospital) - and _check_hospital_unhappy(resident, hospital) - ): - blocking_pairs.append((resident, hospital)) + resident_ranks = convert.preference_to_rank(resident_prefs, hospitals) + hospital_ranks = convert.preference_to_rank(hospital_prefs, residents) + capacity_array = np.array([capacities.get(h, 0) for h in hospitals]) - self.blocking_pairs = blocking_pairs - return not any(blocking_pairs) + game = cls(resident_ranks, hospital_ranks, capacity_array) + game._preference_lookup = {"residents": residents, "hospitals": hospitals} - def check_inputs(self): - """Check if any rules of the game have been broken. + return game - Any violations will be flagged as warnings. If the ``clean`` - attribute is in use, then any violations will be removed. + def check_input_validity(self): """ + Determine whether this game instance is valid or not. - self._check_inputs_player_prefs_unique("residents") - self._check_inputs_player_prefs_unique("hospitals") - - self._check_inputs_player_prefs_all_in_party("residents", "hospitals") - self._check_inputs_player_prefs_all_in_party("hospitals", "residents") - - self._check_inputs_player_prefs_all_reciprocated("hospitals") - self._check_inputs_player_reciprocated_all_prefs( - "hospitals", "residents" - ) + Invalid games can still be solved, but the matching will not be + truly stable in the absence of blocking pairs. - self._check_inputs_player_prefs_nonempty("residents", "hospitals") - self._check_inputs_player_prefs_nonempty("hospitals", "residents") + Warns + ----- + UserWarning + If (a) any player has not made a strict, exhaustive ranking + of the players who ranked them, or (b) any hospital has an + invalid capacity. + """ + for hospital, ranks in enumerate(self.hospital_ranks): + self._check_player_ranks(hospital, ranks, self.resident_ranks, "hospital") - self._check_inputs_player_capacity("hospitals", "residents") + for resident, ranks in enumerate(self.resident_ranks): + self._check_player_ranks(resident, ranks, self.hospital_ranks, "resident") - def _check_inputs_player_prefs_all_reciprocated(self, party): - """Check everyone has only ranked players who ranked them.""" + self._check_capacities() - for player in vars(self)[party]: - for other in player.prefs: - if player not in other.prefs: - warnings.warn( - PreferencesChangedWarning( - f"{player} ranked {other} but they did not." - ) - ) - if self.clean: - player._forget(other) + @staticmethod + def _check_player_ranks(player, player_ranks, other_ranks, side): + """ + Check whether a player has made a valid ranking. + + Parameters + ---------- + player : int + Player for whom to check the ranks. + player_ranks : np.ndarray + Ranking by the player. + other_ranks : np.ndarray + Rankings of the players on the other side. + side : {"resident", "hospital"} + Side of the matching for the player. + + Warns + ----- + UserWarning + If the player has not made a strict, exhaustive ranking of + the all the players who ranked them. + """ + ranked_player = [other for other, ranks in enumerate(other_ranks) if player in ranks] + same_size = len(ranked_player) == len(player_ranks) + same_elements = set(ranked_player) == set(player_ranks) + if not same_size or not same_elements: + warnings.warn( + f"{side.title()} {player} has not made a strict, exhaustive ranking of " + f"the players who ranked them.", + UserWarning, + ) - def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): - """Check everyone has ranked all the players who ranked them.""" + def _check_capacities(self): + """ + Check whether the hospital capacities are valid. - players = vars(self)[party] - others = vars(self)[other_party] - for player in players: - others_that_ranked = [ - other for other in others if player in other.prefs - ] - for other in others_that_ranked: - if other not in player.prefs: - warnings.warn( - PreferencesChangedWarning( - f"{other} ranked {player} but they did not." - ) - ) - if self.clean: - other._forget(player) + Warns + ----- + UserWarning + If any hospital has an invalid capacity. + """ + for hospital, capacity in enumerate(self.capacities): + if capacity <= 0: + warnings.warn( + f"Hospital {hospital} has a capacity of {capacity}.", + UserWarning, + ) - def _check_inputs_player_capacity(self, party, other_party): - """Check everyone has a capacity of at least one.""" + def solve(self, optimal="resident"): + """ + Solve the instance of HR. + + This method uses the adapted Gale-Shapley algorithms introduced + by Alvin Roth in 1984 (https://doi.org/10.1086/261272). The + algorithms find a unique, stable and party-optimal matching for + any valid set of residents and hospitals. + + The optimality of the matching is with respect to one party and + is subsequently the worst stable matching for the other party. + + Parameters + ---------- + optimal : {"resident", "hospital"}, default="resident" + Party for whom to optimise the matching. + + Raises + ------ + ValueError + If `optimal` is anything other than the permitted values. + + Returns + ------- + HRMatching + A dictionary-like object containing the matching. The keys + correspond to the hospitals in the instance, while the + values are lists of the residents matched to them. + """ + if optimal == "resident": + matching = self._resident_optimal() + elif optimal == "hospital": + matching = self._hospital_optimal() + else: + raise ValueError( + f'Invalid choice for `optimal`. Must be "resident" or "hospital", not "{optimal}".' + ) - for player in vars(self)[party]: - if player.capacity < 1: - warnings.warn(PlayerExcludedWarning(player)) + self.matching = matchings.HRMatching(matching, keys="hospitals", values="residents") + if self._preference_lookup: + self._convert_matching_to_preferences() - if self.clean: - self._remove_player(player, party, other_party) + return self.matching + def _resident_optimal(self): + """ + Execute the resident-optimal algorithm given some rankings. -def _check_mutual_preference(resident, hospital): - """Check whether two players have a preference of each other.""" + Returns + ------- + dict + Solution mapping hospitals to their matched residents. + """ + resident_ranks = self.resident_ranks + hospital_ranks = self.hospital_ranks + capacities = self.capacities - return resident in hospital.prefs and hospital in resident.prefs + matching = {h: [] for h in range(self.num_hospitals)} + free_residents = set(range(self.num_residents)) + while free_residents: + resident = free_residents.pop() + resident_rank = resident_ranks[resident] + if np.min(resident_rank) == self.num_hospitals: + continue -def _check_resident_unhappy(resident, hospital): - """Check whether a resident is unhappy given a hospital. + hospital = resident_rank.argmin() + hospital_rank = hospital_ranks[hospital] + hospital_matches = matching[hospital] + capacity = capacities[hospital] - An unhappy resident is either unmatched or they prefer the hospital - to their current match. - """ + if len(hospital_matches) == capacity: + idx = hospital_rank[hospital_matches].argmax() + worst = hospital_matches[idx] + del hospital_matches[idx] + free_residents.add(worst) - return resident.matching is None or resident.prefers( - hospital, resident.matching - ) + hospital_matches.append(resident) + if len(hospital_matches) == capacity: + worst = hospital_matches[hospital_rank[hospital_matches].argmax()] + successors = np.where(hospital_rank > hospital_rank[worst]) + resident_ranks[successors, hospital] = self.num_hospitals + hospital_rank[successors] = self.num_residents -def _check_hospital_unhappy(resident, hospital): - """Check whether a hospital is unhappy given a resident. + return matching - An unhappy hospital is either under-subscribed or they prefer the - resident to at least one of their current matches. - """ + def _hospital_optimal(self): + """ + Execute the hospital-optimal algorithm given some rankings. - return len(hospital.matching) < hospital.capacity or any( - [hospital.prefers(resident, match) for match in hospital.matching] - ) + Returns + ------- + dict + Solution mapping hospitals to their matched residents. + """ + def _get_current_match(resident, matching): + """ + Get the current match for a resident (and its index) if any. + + Parameters + ---------- + resident : int + Resident for whom to search. + matching : dict + Mapping of hospitals to their matched residents. + + Returns + ------- + tuple[int, int] | None + Currently matched hospital and its position in the + resident's ranking or `None` if the resident is free. + """ + for hospital, residents in matching.items(): + for idx, res in enumerate(residents): + if res == resident: + return hospital, idx + + return None, None + + resident_ranks = self.resident_ranks.copy() + hospital_ranks = self.hospital_ranks.copy() + capacities = self.capacities + + matching = {h: [] for h in range(self.num_hospitals)} + free_hospitals = set(range(self.num_hospitals)) + + while free_hospitals: + hospital = free_hospitals.pop() + hospital_rank = hospital_ranks[hospital] + hospital_matches = matching.get(hospital) + options = [ + res if i not in hospital_matches else self.num_residents + for i, res in enumerate(hospital_rank) + ] -def _make_players(resident_prefs, hospital_prefs, capacities): - """Make a set of residents and hospitals from the dictionaries.""" + is_at_capacity = len(hospital_matches) == capacities[hospital] + has_no_options = np.min(options) == self.num_residents + has_no_ranking = np.min(hospital_rank) == self.num_residents + if is_at_capacity or has_no_options or has_no_ranking: + continue - resident_dict, hospital_dict = _make_instances( - resident_prefs, hospital_prefs, capacities - ) + resident = np.argmin(options) + resident_rank = resident_ranks[resident] - for resident_name, resident in resident_dict.items(): - prefs = [hospital_dict[name] for name in resident_prefs[resident_name]] - resident.set_prefs(prefs) + current_match, idx = _get_current_match(resident, matching) + if current_match is not None: + current_match_matches = matching[current_match] + del current_match_matches[idx] + free_hospitals.add(current_match) - for hospital_name, hospital in hospital_dict.items(): - prefs = [resident_dict[name] for name in hospital_prefs[hospital_name]] - hospital.set_prefs(prefs) + hospital_matches.append(resident) + free_hospitals.add(hospital) - residents = list(resident_dict.values()) - hospitals = list(hospital_dict.values()) + successors = np.where(resident_rank > resident_rank[hospital]) + hospital_ranks[successors, resident] = self.num_residents + resident_rank[successors] = self.num_hospitals - return residents, hospitals + return matching + def _convert_matching_to_preferences(self): + """ + Replace the rank indices with preference terms in a matching. -def _make_instances(resident_prefs, hospital_prefs, capacities): - """Create ``Player`` (resident) and ``Hospital`` instances.""" + This internal function is included for users who wish to create + a matching from a set of preference list dictionaries. - resident_dict, hospital_dict = {}, {} - for resident_name in resident_prefs: - resident = Resident(name=resident_name) - resident_dict[resident_name] = resident - for hospital_name in hospital_prefs: - capacity = capacities[hospital_name] - hospital = Hospital(name=hospital_name, capacity=capacity) - hospital_dict[hospital_name] = hospital + Attributes + ---------- + HRMatching + The converted matching instance. + """ + converted = {} + residents, hospitals = self._preference_lookup.values() + for hospital, resident_matches in self.matching.items(): + converted[hospitals[hospital]] = [residents[resident] for resident in resident_matches] - return resident_dict, hospital_dict + self.matching = matchings.HRMatching(converted, keys="hospitals", values="residents") diff --git a/src/matching/games/stable_marriage.py b/src/matching/games/stable_marriage.py index b0ff8d54..2bfcc86a 100644 --- a/src/matching/games/stable_marriage.py +++ b/src/matching/games/stable_marriage.py @@ -4,8 +4,7 @@ import numpy as np -from matching import convert -from matching.matchings import SingleMatching +from matching import convert, matchings class StableMarriage: @@ -60,7 +59,7 @@ def from_utilities(cls, suitor_utils, reviewer_utils): Returns ------- - game : StableMarriage + StableMarriage An instance of SM with utilities resolved as rank matrices. """ @@ -87,7 +86,7 @@ def from_preferences(cls, suitor_prefs, reviewer_prefs): Returns ------- - game : StableMarriage + StableMarriage An instance of SM with preference lists resolved as rank matrices. """ @@ -102,6 +101,29 @@ def from_preferences(cls, suitor_prefs, reviewer_prefs): return game + def check_input_validity(self): + """ + Determine whether this game instance is valid or not. + + Invalid games can still be solved, but the matching will not be + truly stable in the absence of blocking pairs. + + Warns + ----- + UserWarning + If (a) the player sets are not the same size; or (b) any + player has not made a strict, exhaustive, and unique ranking + of the players on the other side of the matching. + """ + + self._check_number_of_players() + + for suitor, ranks in enumerate(self.suitor_ranks): + self._check_player_ranks(suitor, ranks, "suitor") + + for reviewer, ranks in enumerate(self.reviewer_ranks): + self._check_player_ranks(reviewer, ranks, "reviewer") + def _check_number_of_players(self): """ Check whether the player sets are the same size. @@ -150,28 +172,58 @@ def _check_player_ranks(self, player, ranks, side): UserWarning, ) - def check_input_validity(self): + def solve(self, optimal="suitor"): """ - Determine whether this game instance is valid or not. + Solve the instance of SM. - Invalid games can still be solved, but the matching will not be - truly stable in the absence of blocking pairs. + This method uses an extended version of the Gale-Shapley + algorithm that makes use of the inherent structures of SM + instances. The algorithm finds a unique, stable and optimal + matching for any valid set of suitors and reviewers. - Warns - ----- - UserWarning - If (a) the player sets are not the same size; or (b) any - player has not made a strict, exhaustive, and unique ranking - of the players on the other side of the matching. + The optimality of the matching is with respect to one party and + is subsequently the worst stable matching for the other party. + + Parameters + ---------- + optimal : {"suitor", "reviewer"}, default="suitor" + Party for whom to optimise the matching. + + Raises + ------ + ValueError + If `optimal` is anything other than the permitted values. + + Returns + ------- + SMMatching + A dictionary-like object containing the matching. The keys + correspond to the reviewers in the instance, while the + values are the suitors. """ - self._check_number_of_players() + if optimal not in ("suitor", "reviewer"): + raise ValueError( + f'Invalid choice for `optimal`. Must be "suitor" or "reviewer", not "{optimal}".' + ) - for suitor, ranks in enumerate(self.suitor_ranks): - self._check_player_ranks(suitor, ranks, "suitor") + keys, values = "reviewers", "suitors" - for reviewer, ranks in enumerate(self.reviewer_ranks): - self._check_player_ranks(reviewer, ranks, "reviewer") + if optimal == "reviewer": + self._invert_player_sets() + keys, values = values, keys + + matching = matchings.SMMatching(self._stable_marriage(), keys=keys, values=values) + + if optimal == "reviewer": + matching = matching.invert() + self._invert_player_sets() + + self.matching = matching + if self._preference_lookup: + self._convert_matching_to_preferences() + + return self.matching def _invert_player_sets(self): """ @@ -196,7 +248,7 @@ def _stable_marriage(self): Returns ------- - matching : dict + dict Solution to the game instance. """ @@ -210,10 +262,7 @@ def _stable_marriage(self): reviewer_rank = reviewer_ranks[reviewer] current = matching.get(reviewer) - if ( - current is not None - and (suitor_ranks[current] < self.num_reviewers).any() - ): + if current is not None and (suitor_ranks[current] < self.num_reviewers).any(): free_suitors.append(current) matching[reviewer] = suitor @@ -233,7 +282,7 @@ def _convert_matching_to_preferences(self): Attributes ---------- - matching : SingleMatching + SMMatching The converted matching instance. """ @@ -242,63 +291,4 @@ def _convert_matching_to_preferences(self): for reviewer, suitor in self.matching.items(): converted[reviewers[reviewer]] = suitors[suitor] - self.matching = SingleMatching( - converted, valid=self.matching.valid, stable=self.matching.stable - ) - - def solve(self, optimal="suitor"): - """ - Solve the instance of SM. - - This method uses an extended version of the Gale-Shapley - algorithm that makes use of the inherent structures of SM - instances. The algorithm finds a unique, stable and optimal - matching for any valid set of suitors and reviewers. - - The optimality of the matching is with respect to one party and - is subsequently the worst stable matching for the other party. - - Parameters - ---------- - optimal : {"suitor", "reviewer"}, default "suitor" - Party for whom to optimise the matching. Must be one of - `"suitor"` or `"reviewer"`. Default is `"suitor"`. - - Raises - ------ - ValueError - If `optimal` is anything other than the permitted values. - - Returns - ------- - matching : SingleMatching - A dictionary-like object containing the matching. The keys - correspond to the reviewers in the instance, while the - values are the suitors. - """ - - if optimal not in ("suitor", "reviewer"): - raise ValueError( - "Invalid choice for `optimal`. " - f'Must be "suitor" or "reviewer", not "{optimal}".' - ) - - keys, values = "reviewers", "suitors" - - if optimal == "reviewer": - self._invert_player_sets() - keys, values = values, keys - - matching = SingleMatching( - self._stable_marriage(), keys=keys, values=values - ) - - if optimal == "reviewer": - matching = matching.invert() - self._invert_player_sets() - - self.matching = matching - if self._preference_lookup: - self._convert_matching_to_preferences() - - return self.matching + self.matching = matchings.SMMatching(converted) diff --git a/src/matching/games/stable_roommates.py b/src/matching/games/stable_roommates.py index 678fac53..77701ba4 100644 --- a/src/matching/games/stable_roommates.py +++ b/src/matching/games/stable_roommates.py @@ -75,9 +75,9 @@ def check_stability(self): for other in others: if (other, player) not in blocking_pairs: both_matched = player.matching and other.matching - prefer_each_other = player.prefers( - other, player.matching - ) and other.prefers(player, other.matching) + prefer_each_other = player.prefers(other, player.matching) and other.prefers( + player, other.matching + ) if both_matched and prefer_each_other: blocking_pairs.append((player, other)) diff --git a/src/matching/games/student_allocation.py b/src/matching/games/student_allocation.py index 0f576d05..3c8756e2 100644 --- a/src/matching/games/student_allocation.py +++ b/src/matching/games/student_allocation.py @@ -11,9 +11,10 @@ MatchingError, PreferencesChangedWarning, ) -from matching.games import HospitalResident from matching.players import Project, Supervisor +from ._old_hospital_resident import HospitalResident + class StudentAllocation(HospitalResident): """Solver for the student-allocation problem (SA). @@ -63,9 +64,7 @@ class StudentAllocation(HospitalResident): """ def __init__(self, students, projects, supervisors, clean=False): - students, projects, supervisors = copy.deepcopy( - [students, projects, supervisors] - ) + students, projects, supervisors = copy.deepcopy([students, projects, supervisors]) self.students = students self.projects = projects self.supervisors = supervisors @@ -131,9 +130,7 @@ def solve(self, optimal="student"): """ self.matching = MultipleMatching( - student_allocation( - self.students, self.projects, self.supervisors, optimal - ) + student_allocation(self.students, self.projects, self.supervisors, optimal) ) return self.matching @@ -192,15 +189,11 @@ def check_inputs(self): self._check_inputs_player_prefs_nonempty("supervisors", "students") self._check_inputs_player_prefs_all_reciprocated("projects") - self._check_inputs_player_reciprocated_all_prefs( - "projects", "students" - ) + self._check_inputs_player_reciprocated_all_prefs("projects", "students") self._check_inputs_player_prefs_nonempty("projects", "students") self._check_inputs_player_prefs_all_reciprocated("supervisors") - self._check_inputs_player_reciprocated_all_prefs( - "supervisors", "students" - ) + self._check_inputs_player_reciprocated_all_prefs("supervisors", "students") self._check_inputs_player_prefs_nonempty("supervisors", "students") self._check_inputs_player_capacity("projects", "students") @@ -218,9 +211,7 @@ def _check_inputs_player_prefs_all_reciprocated(self, party): if party == "supervisors": for supervisor in self.supervisors: for student in supervisor.prefs: - student_prefs_supervisors = { - p.supervisor for p in student.prefs - } + student_prefs_supervisors = {p.supervisor for p in student.prefs} if supervisor not in student_prefs_supervisors: warnings.warn( PreferencesChangedWarning( @@ -248,10 +239,7 @@ def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): students_that_ranked = [ student for student in self.students - if any( - project in student.prefs - for project in supervisor.projects - ) + if any(project in student.prefs for project in supervisor.projects) ] for student in students_that_ranked: @@ -264,15 +252,11 @@ def _check_inputs_player_reciprocated_all_prefs(self, party, other_party): ) if self.clean: - for project in set(supervisor.projects) & set( - student.prefs - ): + for project in set(supervisor.projects) & set(student.prefs): student._forget(project) else: - super()._check_inputs_player_reciprocated_all_prefs( - party, other_party - ) + super()._check_inputs_player_reciprocated_all_prefs(party, other_party) def _check_inputs_supervisor_capacities_sufficient(self): """Check each supervisor has space for its largest project.""" @@ -295,9 +279,7 @@ def _check_inputs_supervisor_capacities_necessary(self): """Check each supervisor has no surplus given their projects.""" for supervisor in self.supervisors: - total_project_capacity = sum( - p.capacity for p in supervisor.projects - ) + total_project_capacity = sum(p.capacity for p in supervisor.projects) if supervisor.capacity > total_project_capacity: warnings.warn( @@ -319,9 +301,7 @@ def _check_student_unhappy(student, project): their current match. """ - return student.matching is None or student.prefers( - project, student.matching - ) + return student.matching is None or student.prefers(project, student.matching) def _check_project_unhappy(project, student): @@ -341,8 +321,7 @@ def _check_project_unhappy(project, student): project_undersubscribed = len(project.matching) < project.capacity both_undersubscribed = ( - project_undersubscribed - and len(supervisor.matching) < supervisor.capacity + project_undersubscribed and len(supervisor.matching) < supervisor.capacity ) supervisor_full = len(supervisor.matching) == supervisor.capacity @@ -353,9 +332,7 @@ def _check_project_unhappy(project, student): project_upsetting_supervisor = len( project.matching - ) == project.capacity and supervisor.prefers( - student, project.get_worst_match() - ) + ) == project.capacity and supervisor.prefers(student, project.get_worst_match()) return ( both_undersubscribed diff --git a/src/matching/matchings.py b/src/matching/matchings.py new file mode 100644 index 00000000..dcaf4b5d --- /dev/null +++ b/src/matching/matchings.py @@ -0,0 +1,110 @@ +"""Module for the matching object classes.""" + +import collections + + +class _BaseMatching(dict): + """ + Dictionary-like object for holding game solutions. For inheritance. + + Parameters + ---------- + dictionary : dict + Dictionary of matched up pairs. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + """ + + KEYS = "keys" + VALUES = "values" + + def __init__(self, dictionary=None, *, keys=None, values=None): + super().__init__(dictionary or {}) + + self.keys_ = keys or self.KEYS + self.values_ = values or self.VALUES + + def __repr__(self): + name = self.__class__.__name__ + return f'{name}({super().__repr__()}, keys="{self.keys_}", values="{self.values_}")' + + def __eq__(self, other): + if isinstance(other, _BaseMatching): + return super().__eq__(other) and vars(self) == vars(other) + if isinstance(other, dict): + return super().__eq__(other) + + +class _SingleMatching(_BaseMatching): + """ + Dictionary-like object for solutions to games with singular matches. + + Parameters + ---------- + dictionary : dict + Dictionary of matched up pairs. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + """ + + def invert(self): + """ + Invert the keys and values in the dictionary. + + Returns + ------- + inverted : SingleMatching + An inverted matching. + """ + inverted = {val: key for key, val in self.items()} + + return self.__class__(inverted, keys=self.values_, values=self.keys_) + + +class _MultipleMatching(_BaseMatching): + """ + Dictionary-like object for solutions to games with multiple matches. + + Parameters + ---------- + dictionary : dict + Dictionary mapping players to their matches. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + """ + + def invert(self): + """ + Invert the keys and list values in the dictionary. + + Returns + ------- + MultipleMatching + An inverted matching. + """ + inverted = collections.defaultdict(list) + for key, values in self.items(): + for value in values: + inverted[value].append(key) + + return self.__class__(dict(inverted), keys=self.values_, values=self.keys_) + + +class SMMatching(_SingleMatching): + """Dictionary-like object for solutions to SM game instances.""" + + KEYS = "reviewers" + VALUES = "suitors" + + +class HRMatching(_MultipleMatching): + """Dictionary-like object for solutions to HR game instances.""" + + KEYS = "hospitals" + VALUES = "residents" diff --git a/src/matching/matchings/__init__.py b/src/matching/matchings/__init__.py deleted file mode 100644 index c7b049ed..00000000 --- a/src/matching/matchings/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -"""Classes for different types of matchings.""" - -from .multiple import MultipleMatching -from .single import SingleMatching - -__all__ = ["MultipleMatching", "SingleMatching"] diff --git a/src/matching/matchings/multiple.py b/src/matching/matchings/multiple.py deleted file mode 100644 index da253c3e..00000000 --- a/src/matching/matchings/multiple.py +++ /dev/null @@ -1,35 +0,0 @@ -"""Classes for handling multiple match matchings.""" - -from matching.base import BaseMatching -from matching.players import Player - - -class MultipleMatching(BaseMatching): - """Matching class for games with multiple matches like HR or SA. - - Parameters - ---------- - dictionary - A dictionary comprised of ``Hospital, List[Player]`` pairs. - """ - - def __init__(self, dictionary): - super().__init__(dictionary) - - def __setitem__(self, player, new): - """Set a player's match and match each of them to the player. - - First check if the player is present, and that the new match is - a valid collection of players. - """ - - self._check_player_in_keys(player) - self._check_new_valid_type(new, (list, tuple)) - for other in new: - self._check_new_valid_type(other, Player) - - player.matching = new - for other in new: - other.matching = player - - self._data[player] = new diff --git a/src/matching/matchings/single.py b/src/matching/matchings/single.py deleted file mode 100644 index 73f56486..00000000 --- a/src/matching/matchings/single.py +++ /dev/null @@ -1,65 +0,0 @@ -"""Classes for handling single match matchings.""" - - -class SingleMatching(dict): - """ - Dictionary-like object for solutions to games with singular matches. - - Parameters - ---------- - dictionary : dict - Dictionary of matched up pairs. - keys : str - Name of the key-side party. Renamed `keys_`. - values : str - Name of the value-side party. Renamed `values_`. - valid : bool or None - Validity of the matching. Initialises as `None`. - stable : bool or None - Stability of the matching. Initialises as `None`. - """ - - def __init__( - self, - dictionary=None, - *, - keys="reviewers", - values="suitors", - valid=None, - stable=None, - ): - super().__init__(dictionary or {}) - - self.keys_ = keys - self.values_ = values - self.valid = valid - self.stable = stable - - def __repr__(self): - return ( - f"SingleMatching({super().__repr__()}, " - f'keys="{self.keys_}", values="{self.values_}")' - ) - - def __eq__(self, other): - return super().__eq__(other) and vars(self) == vars(other) - - def invert(self): - """ - Invert the keys and values in the dictionary. - - Creates a new matching instance with keys and values reversed, - and passes over the validity and stability attributes. - - Returns - ------- - inverted : SingleMatching - An inverted matching. - """ - return SingleMatching( - {val: key for key, val in self.items()}, - keys=self.values_, - values=self.keys_, - valid=self.valid, - stable=self.stable, - ) diff --git a/src/matching/players/supervisor.py b/src/matching/players/supervisor.py index 421cc260..16d593e8 100644 --- a/src/matching/players/supervisor.py +++ b/src/matching/players/supervisor.py @@ -60,9 +60,7 @@ def set_prefs(self, students): self._original_prefs = students[:] for project in self.projects: - acceptable = [ - student for student in students if project in student.prefs - ] + acceptable = [student for student in students if project in student.prefs] project.set_prefs(acceptable) def get_favourite(self): diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 00000000..64bfcf1b --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1 @@ +"""Tests for the `matching` package.""" diff --git a/tests/base/test_matching.py b/tests/base/test_matching.py index 153e4e14..51325151 100644 --- a/tests/base/test_matching.py +++ b/tests/base/test_matching.py @@ -65,9 +65,7 @@ def test_getitem(dictionary): """Check that you can access items in a matching correctly.""" matching = BaseMatching(dictionary) - for (mkey, mval), (dkey, dval) in zip( - matching.items(), dictionary.items() - ): + for (mkey, mval), (dkey, dval) in zip(matching.items(), dictionary.items()): assert matching[mkey] == mval assert (mkey, mval) == (dkey, dval) diff --git a/tests/common.py b/tests/common.py new file mode 100644 index 00000000..b0c83c34 --- /dev/null +++ b/tests/common.py @@ -0,0 +1,58 @@ +"""Objects used among many tests.""" + +from unittest import mock + +import numpy as np +from hypothesis import strategies as st +from hypothesis.extra import numpy as st_numpy + + +def mocked_game(game, *args): + """Create an instance of a game that mocks its input validator.""" + + with mock.patch(f"matching.games.{game.__name__}.check_input_validity") as validator: + instance = game(*args) + + validator.assert_called_once_with() + + return instance + + +@st.composite +def st_single_ranks(draw, nrows: int, ncols: int | None = None): + """Create a single rank matrix.""" + if ncols is None: + ncols = nrows + + rank = draw( + st.lists( + st.permutations(range(ncols)), + min_size=nrows, + max_size=nrows, + ) + ) + + return np.array(rank) + + +@st.composite +def st_single_utilities(draw, nrows: int, ncols: int | None = None): + """Create a single utility matrix.""" + if ncols is None: + ncols = nrows + + utility = draw( + st_numpy.arrays( + dtype=float, + elements=st.floats(0, 1, allow_nan=False), + shape=(nrows, ncols), + ) + ) + + return utility + + +@st.composite +def st_sizes(draw, nmin=1, nmax=5): + """Create a size for a side in a game.""" + return draw(st.integers(nmin, nmax)) diff --git a/tests/hospital_resident/strategies.py b/tests/hospital_resident/strategies.py new file mode 100644 index 00000000..9a99d997 --- /dev/null +++ b/tests/hospital_resident/strategies.py @@ -0,0 +1,103 @@ +"""Composite strategies for HR unit tests.""" + +import numpy as np +from hypothesis import strategies as st + +from ..common import st_single_ranks, st_single_utilities, st_sizes + + +@st.composite +def st_ranks(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of rankings for a test.""" + + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) + + resident_ranks = draw(st_single_ranks(rsize, hsize)) + hospital_ranks = draw(st_single_ranks(hsize, rsize)) + + return resident_ranks, hospital_ranks + + +@st.composite +def st_capacities(draw, hmin=1, hmax=3): + """Create a capacity vector.""" + + size = draw(st_sizes(hmin, hmax)) + capacities = draw(st.lists(st.integers(1, 2), min_size=size, max_size=size)) + + return np.array(capacities) + + +@st.composite +def st_ranks_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of rankings and capacities for a test.""" + + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) + + resident_ranks, hospital_ranks = draw(st_ranks(hsize, hsize, rsize, rsize)) + capacities = draw(st_capacities(hsize, hsize)) + + return resident_ranks, hospital_ranks, capacities + + +@st.composite +def st_utilities_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of utilities and capacities for a test.""" + + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) + + resident_utility = draw(st_single_utilities(rsize, hsize)) + hospital_utility = draw(st_single_utilities(hsize, rsize)) + capacities = draw(st_capacities(hsize, hsize)) + + return resident_utility, hospital_utility, capacities + + +@st.composite +def st_preferences_capacities(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of preferences and capacities for a test.""" + + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) + + residents = draw(st.lists(st.integers(), min_size=rsize, max_size=rsize, unique=True)) + hospitals = draw(st.lists(st.text(), min_size=hsize, max_size=hsize, unique=True)) + + resident_preferences = {r: draw(st.permutations(hospitals)) for r in residents} + hospital_preferences = {h: draw(st.permutations(residents)) for h in hospitals} + capacities = dict(zip(hospital_preferences, draw(st_capacities(hsize, hsize)))) + + return resident_preferences, hospital_preferences, capacities + + +@st.composite +def st_preference_matchings(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a set of preferences and a matching to go with them.""" + + resident_preferences, hospital_preferences, capacities = draw( + st_preferences_capacities(hmin, hmax, rmin, rmax) + ) + + matched_residents = draw( + st.lists(st.sampled_from(list(resident_preferences.keys())), unique=True) + ) + resident_matching = {} + spaces = capacities.copy() + for resident in matched_residents: + resident_idx = list(resident_preferences.keys()).index(resident) + hospital = draw(st.sampled_from(resident_preferences[resident])) + hospital_idx = list(hospital_preferences.keys()).index(hospital) + if spaces[hospital]: + resident_matching[resident_idx] = hospital_idx + spaces[hospital] -= 1 + + matching = { + hospital: [r for r in resident_matching if resident_matching[r] == hospital] + for hospital, _ in enumerate(hospital_preferences) + if hospital in resident_matching.values() + } + + return resident_preferences, hospital_preferences, capacities, matching diff --git a/tests/hospital_resident/test_algorithm.py b/tests/hospital_resident/test_algorithm.py index 204ef6c6..4a07c6bf 100644 --- a/tests/hospital_resident/test_algorithm.py +++ b/tests/hospital_resident/test_algorithm.py @@ -1,69 +1,146 @@ -"""Tests for the Hospital-Resident algorithm.""" +"""Unit tests for the Hospital-Resident algorithms.""" import numpy as np from hypothesis import given -from matching.algorithms.hospital_resident import ( - hospital_optimal, - hospital_resident, - resident_optimal, -) +from matching.games import HospitalResident -from .util import players +from ..common import mocked_game +from .strategies import st_ranks_capacities -@given(players_=players()) -def test_hospital_resident(players_): - """Test the algorithm produces a valid solution.""" +def _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities): + """Assert that the matching has the right shape and elements.""" - residents, hospitals = players_ + assert isinstance(matching, dict) - matching = hospital_resident(residents, hospitals) - assert set(hospitals) == set(matching.keys()) + matched_hospitals = set(matching.keys()) + matched_residents = set([r for rs in matching.values() for r in rs]) - matched_residents = {r for rs in matching.values() for r in rs} - for resident in residents: - if resident.matching: - assert resident in matched_residents - else: - assert resident not in matched_residents + assert matched_hospitals <= set(np.unique(resident_ranks)) + assert matched_residents <= set(np.unique(hospital_ranks)) + for hospital, residents in matching.items(): + assert len(residents) <= capacities[hospital] -@given(players_=players()) -def test_resident_optimal(players_): - """Test that the resident-optimal algorithm is resident-optimal.""" - residents, hospitals = players_ +@given(st_ranks_capacities()) +def test_resident_optimal_resident_optimal(ranks_capacities): + """ + Check the resident-optimal algorithm is optimal for residents. - matching = resident_optimal(residents, hospitals) - assert set(hospitals) == set(matching.keys()) + We affirm this by going through the residents and checking that + either they are unmatched or they prefer their match to any other + hospital. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) - assert all( - [ - r in set(residents) - for r in { - r_match for matches in matching.values() for r_match in matches - } - ] - ) + matching = game._resident_optimal() - for resident in residents: - if resident.matching: - assert resident.prefs.index(resident.matching) == 0 + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + for resident, resident_rank in enumerate(game.resident_ranks): + hospital = next((h for h, rs in matching.items() if resident in rs), None) + if hospital is None: + continue -@given(players_=players()) -def test_hospital_optimal(players_): - """Test that the hospital-optimal algorithm is hospital-optimal.""" + preferred_hospitals, *_ = np.where(resident_rank < resident_rank[hospital]) + assert not preferred_hospitals.any() - _, hospitals = players_ - matching = hospital_optimal(hospitals) - assert set(hospitals) == set(matching.keys()) +@given(st_ranks_capacities()) +def test_resident_optimal_hospital_pessimal(ranks_capacities): + """ + Check the resident-optimal algorithm is pessimal for hospitals. - for hospital, matches in matching.items(): - old_idx = -np.inf - for resident in matches: - idx = hospital.prefs.index(resident) - assert idx >= old_idx - old_idx = idx + We affirm this by going through the hospitals and checking that if + they prefer a resident to their worst current match, then the + resident matched to them already or prefers their match to the + hospital. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + matching = game._resident_optimal() + + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + + for hospital, residents in matching.items(): + if not residents: + continue + + hospital_rank = game.hospital_ranks[hospital] + worst_match = hospital_rank[residents].max() + preferred_residents, *_ = np.where(hospital_rank < worst_match) + for preferred in preferred_residents: + if preferred in residents: + continue + + preferred_rank = game.resident_ranks[preferred] + partner = next((h for h, rs in matching.items() if preferred in rs), None) + + assert partner is not None + assert preferred_rank[partner] < preferred_rank[hospital] + + +@given(st_ranks_capacities()) +def test_hospital_optimal_hospital_optimal(ranks_capacities): + """ + Check the hospital-optimal algorithm is optimal for hospitals. + + We affirm this by going through the matching and checking that for + each hospital, if they prefer a resident to their best current + match, then the resident prefers their match to the hospital. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + matching = game._hospital_optimal() + + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + + for hospital, residents in matching.items(): + if not residents: + continue + + hospital_rank = game.hospital_ranks[hospital] + best_match = hospital_rank[residents].min() + preferred_residents, *_ = np.where(hospital_rank < best_match) + for preferred in preferred_residents: + preferred_rank = game.resident_ranks[preferred] + partner = next((h for h, rs in matching.items() if preferred in rs), None) + + assert partner is not None + assert preferred_rank[partner] < preferred_rank[hospital] + + +@given(st_ranks_capacities()) +def test_hospital_optimal_resident_pessimal(ranks_capacities): + """ + Check the hospital-optimal algorithm is pessimal for residents. + + We affirm this by going through the residents and checking that if + they prefer a hospital to their current match, then the hospital + prefers their worst match to the resident. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + matching = game._hospital_optimal() + + _assert_matching_is_valid_shape(matching, hospital_ranks, resident_ranks, capacities) + + for resident, resident_rank in enumerate(game.resident_ranks): + hospital = next((h for h, rs in matching.items() if resident in rs), None) + if hospital is None: + continue + + preferred_hospitals, *_ = np.where(resident_rank < resident_rank[hospital]) + for preferred in preferred_hospitals: + preferred_matches = matching.get(preferred) + assert preferred_matches is not None + + preferred_rank = game.hospital_ranks[preferred] + worst_match = preferred_rank[preferred_matches].max() + assert preferred_rank[resident] > worst_match diff --git a/tests/hospital_resident/test_examples.py b/tests/hospital_resident/test_examples.py index 4f1c5e4e..373f9ecb 100644 --- a/tests/hospital_resident/test_examples.py +++ b/tests/hospital_resident/test_examples.py @@ -2,13 +2,13 @@ import json import os +import warnings from matching.games import HospitalResident def test_readme_example(): - """Test the example used in the repo README.""" - + """Test the example formerly used in the README.""" resident_prefs = { "A": ["C"], "S": ["C", "M"], @@ -16,90 +16,86 @@ def test_readme_example(): "J": ["C", "G", "M"], "L": ["M", "C", "G"], } - hospital_prefs = { "M": ["D", "L", "S", "J"], "C": ["D", "A", "S", "L", "J"], "G": ["D", "J", "L"], } - capacities = {hosp: 2 for hosp in hospital_prefs} - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities - ) - (A, S, D, J, L), (M, C, G) = game.residents, game.hospitals - + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) matching = game.solve() - assert matching == {M: [L, S], C: [D, A], G: [J]} + + assert matching == {"M": ["L", "S"], "C": ["A", "D"], "G": ["J"]} def test_example_in_issue_67(): """Test the example given in #67.""" - group_prefs = { "Group 1": ["Intellectual property", "Privacy"], "Group 2": ["Privacy", "Fairness in AI"], "Group 3": ["Privacy", "Social media"], } - topic_hospital_prefs = { "Fairness in AI": ["Group 2"], "Intellectual property": ["Group 1"], "Privacy": ["Group 3", "Group 2", "Group 1"], "Social media": ["Group 3"], } - capacities = {t: 2 for t in topic_hospital_prefs} - game = HospitalResident.create_from_dictionaries( - group_prefs, topic_hospital_prefs, capacities - ) - (G1, G2, G3), (F, I, P, S) = game.residents, game.hospitals - + game = HospitalResident.from_preferences(group_prefs, topic_hospital_prefs, capacities) matching = game.solve() - assert matching == {I: [G1], P: [G3, G2], F: [], S: []} + + assert matching == { + "Fairness in AI": [], + "Intellectual property": ["Group 1"], + "Privacy": ["Group 2", "Group 3"], + "Social media": [], + } def test_resident_loses_all_preferences(): """Test example that forces a resident to be removed.""" - resident_prefs = {"A": ["X"], "B": ["X", "Y"]} hospital_prefs = {"X": ["B", "A"], "Y": ["B"]} capacities = {"X": 1, "Y": 1} - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities - ) - (_, B), (X, Y) = game.residents, game.hospitals - + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) matching = game.solve() - assert matching == {X: [B], Y: []} + + assert matching == {"X": ["B"], "Y": []} def test_example_in_issue_159(): - """Test the example given in #159. + """ + Test the example given in #159. The example in this is particularly large, so we've moved the dictionaries to a test data directory. """ - here = os.path.join(os.path.dirname(__file__)) with open(os.path.join(here, "data", "issue_159.json"), "r") as f: preferences = json.load(f) - resident_prefs = { - int(res): prefs for res, prefs in preferences["residents"].items() - } - hospital_prefs = { - int(hos): prefs for hos, prefs in preferences["hospitals"].items() - } - + resident_prefs = {int(res): prefs for res, prefs in preferences["residents"].items()} + hospital_prefs = {int(hos): prefs for hos, prefs in preferences["hospitals"].items()} capacities = {hospital: 1 for hospital in hospital_prefs} - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities, clean=True - ) - - for player in game.residents + game.hospitals: - assert player.prefs + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) + + for ranking, preferences in zip(game.resident_ranks, resident_prefs.values()): + minimum, limit = min(ranking), game.num_hospitals + if not preferences: + minimum == limit + else: + assert minimum < limit + + for ranking, preferences in zip(game.hospital_ranks, hospital_prefs.values()): + minimum, limit = min(ranking), game.num_residents + if not preferences: + assert minimum == limit + else: + assert minimum < limit diff --git a/tests/hospital_resident/test_game.py b/tests/hospital_resident/test_game.py new file mode 100644 index 00000000..0d4baa0e --- /dev/null +++ b/tests/hospital_resident/test_game.py @@ -0,0 +1,277 @@ +"""Unit tests for the HospitalResident class.""" + +import warnings +from unittest import mock + +import numpy as np +import pytest +from hypothesis import given +from hypothesis import strategies as st + +from matching import matchings +from matching.games import HospitalResident, hospital_resident + +from ..common import mocked_game +from .strategies import ( + st_preference_matchings, + st_preferences_capacities, + st_ranks_capacities, + st_utilities_capacities, +) + + +@given(st_ranks_capacities()) +def test_init(ranks_capacities): + """Check instantiation given some rankings and capacities.""" + + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + assert isinstance(game, HospitalResident) + assert (game.resident_ranks == resident_ranks).all() + assert (game.hospital_ranks == hospital_ranks).all() + assert (game.capacities == capacities).all() + + assert game.num_residents == len(resident_ranks) + assert game.num_hospitals == len(hospital_ranks) + assert game.matching is None + assert game._preference_lookup is None + + +@given(st_utilities_capacities()) +def test_from_utilities(utilities_capacities): + """Check instantiation from utility matrices.""" + + *utilities, capacities = utilities_capacities + resident_utility, hospital_utility = utilities + + with ( + mock.patch("matching.games.HospitalResident.check_input_validity") as validator, + mock.patch("matching.convert.utility_to_rank") as ranker, + ): + effects = (resident_utility.argsort(), hospital_utility.argsort()) + ranker.side_effect = list(effects) + game = HospitalResident.from_utilities(resident_utility, hospital_utility, capacities) + + assert isinstance(game, HospitalResident) + assert (game.resident_ranks == effects[0]).all() + assert (game.hospital_ranks == effects[1]).all() + assert (game.capacities == capacities).all() + + assert game.num_residents == len(resident_utility) + assert game.num_hospitals == len(hospital_utility) + assert game.matching is None + assert game._preference_lookup is None + + assert ranker.call_count == 2 + for call, utility in zip(ranker.call_args_list, utilities): + arg, *_ = call.args + assert np.array_equal(arg, utility) + + validator.assert_called_once_with() + + +@given(st_preferences_capacities()) +def test_from_preferences(preferences_capacities): + """Check instantiation from preference list dictionaries.""" + + *preferences, capacities = preferences_capacities + resident_preferences, hospital_preferences = preferences + + with ( + mock.patch("matching.games.HospitalResident.check_input_validity") as validator, + mock.patch("matching.convert.preference_to_rank") as ranker, + ): + effects = ( + np.array(list(resident_preferences.values())), + np.array(list(hospital_preferences.values())), + ) + ranker.side_effect = list(effects) + game = HospitalResident.from_preferences( + resident_preferences, hospital_preferences, capacities + ) + + assert isinstance(game, HospitalResident) + assert (game.resident_ranks == effects[0]).all() + assert (game.hospital_ranks == effects[1]).all() + + assert game.num_residents == len(resident_preferences) + assert game.num_hospitals == len(hospital_preferences) + assert game.matching is None + + assert isinstance(game._preference_lookup, dict) + assert game._preference_lookup == { + "residents": sorted(resident_preferences), + "hospitals": sorted(hospital_preferences), + } + + assert isinstance(game.capacities, np.ndarray) + assert game.capacities.shape == (len(hospital_preferences),) + for cap, hospital in zip(game.capacities, game._preference_lookup["hospitals"]): + assert cap == capacities.get(hospital) + + assert ranker.call_count == 2 + for call, preference, others in zip( + ranker.call_args_list, + preferences, + (hospital_preferences, resident_preferences), + ): + assert call.args == (preference, sorted(others)) + + validator.assert_called_once_with() + + +@given(st_ranks_capacities()) +def test_check_input_validity(ranks_capacities): + """ + Check that the input validator works as expected. + + This method is not called in the constructor, so we need to call + it manually. We mock the stage functions this method wraps to + check that they are called correctly. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + + with ( + mock.patch.object(game, "_check_player_ranks") as mock_check_ranks, + mock.patch.object(game, "_check_capacities") as mock_check_capacities, + ): + game.check_input_validity() + + assert mock_check_ranks.call_count == len(resident_ranks) + len(hospital_ranks) + + call_args = mock_check_ranks.call_args_list + for hospital, hospital_rank in enumerate(hospital_ranks): + call = call_args.pop(0) + assert call.kwargs == {} + for arg, item in zip(call.args, (hospital, hospital_rank, resident_ranks, "hospital")): + assert np.equal(arg, item).all() + + for resident, resident_rank in enumerate(resident_ranks): + call = call_args.pop(0) + assert call.kwargs == {} + for arg, item in zip(call.args, (resident, resident_rank, hospital_ranks, "resident")): + assert np.equal(arg, item).all() + + mock_check_capacities.assert_called_once_with() + + +@given(st_ranks_capacities()) +def test_check_player_ranks_no_warning(ranks_capacities): + """Check that the player ranks check can not raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_player_ranks(0, resident_ranks[0], hospital_ranks, "resident") + + +@given(st_ranks_capacities()) +def test_check_player_ranks_warns(ranks_capacities): + """Check that the player ranks check can raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + hospital_ranks[0][-1] = 1000 + + with pytest.warns(UserWarning, match="Hospital 0 has not made a strict"): + game._check_player_ranks(0, hospital_ranks[0], resident_ranks, "hospital") + + +@given(st_ranks_capacities()) +def test_check_capacities_no_warning(ranks_capacities): + """Check that the capacity check can not raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_capacities() + + +@given(st_ranks_capacities()) +def test_check_capacities_warns(ranks_capacities): + """Check that the capacity check can raise a warning.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, resident_ranks, hospital_ranks, capacities) + game.capacities[0] = 0 + + with pytest.warns(UserWarning, match="Hospital 0 has a capacity of 0"): + game._check_capacities() + + +@given(st_ranks_capacities(), st.sampled_from(["resident", "hospital"]), st.booleans()) +def test_solve(ranks_capacities, optimal, preference_lookup): + """ + Check the solver works as it should. + + This method wraps the algorithm functions for the HR game, as well + as the matching-preference conversion function. So, we mock all of + these and check they are called correctly. + """ + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + game._preference_lookup = preference_lookup + + with ( + mock.patch.object(game, "_resident_optimal") as mock_resident_optimal, + mock.patch.object(game, "_hospital_optimal") as mock_hospital_optimal, + mock.patch.object(game, "_convert_matching_to_preferences") as mock_convert, + mock.patch.object(hospital_resident.matchings, "HRMatching") as mock_matching, + ): + matching = game.solve(optimal=optimal) + + assert matching == game.matching == mock_matching.return_value + + if optimal == "resident": + mock_resident_optimal.assert_called_once_with() + mock_hospital_optimal.assert_not_called() + mock_matching.assert_called_once_with( + mock_resident_optimal.return_value, keys="hospitals", values="residents" + ) + if optimal == "hospital": + mock_hospital_optimal.assert_called_once_with() + mock_resident_optimal.assert_not_called() + mock_matching.assert_called_once_with( + mock_hospital_optimal.return_value, keys="hospitals", values="residents" + ) + + if preference_lookup: + mock_convert.assert_called_once_with() + else: + mock_convert.assert_not_called() + + +@given(st_ranks_capacities(), st.text(min_size=1)) +def test_solve_raises_with_bad_optimal(ranks_capacities, optimal): + """Check that the solver raises an error with a bad optimal value.""" + resident_ranks, hospital_ranks, capacities = ranks_capacities + game = mocked_game(HospitalResident, *ranks_capacities) + + with pytest.raises(ValueError, match="Invalid choice for `optimal`"): + game.solve(optimal=optimal) + + +@given(st_preference_matchings()) +def test_convert_matching_to_preferences(preference_matchings): + """Test that a matching can use the terms from some preferences.""" + + resident_prefs, hospital_prefs, capacities, matching = preference_matchings + + with mock.patch.object(HospitalResident, "check_input_validity") as validator: + game = HospitalResident.from_preferences(resident_prefs, hospital_prefs, capacities) + + game.matching = matchings.HRMatching(matching) + + game._convert_matching_to_preferences() + converted = game.matching + + assert isinstance(converted, matchings.HRMatching) + assert converted.keys_ == "hospitals" + assert converted.values_ == "residents" + + assert set(converted.keys()) <= set(hospital_prefs) + assert set([r for rs in converted.values() for r in rs]) <= set(resident_prefs) + + validator.assert_called_once_with() diff --git a/tests/hospital_resident/test_solver.py b/tests/hospital_resident/test_solver.py deleted file mode 100644 index dfac0b0d..00000000 --- a/tests/hospital_resident/test_solver.py +++ /dev/null @@ -1,371 +0,0 @@ -"""Unit tests for the HR solver.""" - -import warnings - -import pytest -from hypothesis import given -from hypothesis.strategies import booleans, sampled_from - -from matching import MultipleMatching -from matching import Player as Resident -from matching.exceptions import ( - MatchingError, - PlayerExcludedWarning, - PreferencesChangedWarning, -) -from matching.games import HospitalResident -from matching.players import Hospital - -from .util import connections, games, players - - -@given(players=players(), clean=booleans()) -def test_init(players, clean): - """Test for correct instantiation given a set of players.""" - - residents, hospitals = players - - game = HospitalResident(residents, hospitals, clean) - - for resident, game_resident in zip(residents, game.residents): - assert resident.name == game_resident.name - assert resident._pref_names == game_resident._pref_names - - for hospital, game_hospital in zip(hospitals, game.hospitals): - assert hospital.name == game_hospital.name - assert hospital._pref_names == game_hospital._pref_names - assert hospital.capacity == game_hospital.capacity - - assert all([resident.matching is None for resident in game.residents]) - assert all([hospital.matching == [] for hospital in game.hospitals]) - assert game.matching is None - - -@given(connections=connections(), clean=booleans()) -def test_create_from_dictionaries(connections, clean): - """Test for correct instantiation given a set of dictionaries.""" - - resident_prefs, hospital_prefs, capacities = connections - - game = HospitalResident.create_from_dictionaries( - resident_prefs, hospital_prefs, capacities, clean - ) - - for resident in game.residents: - assert resident._pref_names == resident_prefs[resident.name] - assert resident.matching is None - - for hospital in game.hospitals: - assert hospital._pref_names == hospital_prefs[hospital.name] - assert hospital.capacity == capacities[hospital.name] - assert hospital.matching == [] - - assert game.matching is None - assert game.clean is clean - - -@given(game=games()) -def test_check_inputs(game): - """Test that inputs to an instance of HR can be verified.""" - - with warnings.catch_warnings(): - warnings.simplefilter("error") - game.check_inputs() - - assert game.residents == game._all_residents - assert game.hospitals == game._all_hospitals - - -@given(game=games()) -def test_check_inputs_resident_prefs_all_hospitals(game): - """Test each resident has only hospitals in its preference list. - - If not, check that a warning is caught and the resident's - preferences are changed. - """ - - resident = game.residents[0] - resident.prefs = [Resident("foo")] - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_prefs_all_in_party("residents", "hospitals") - - assert len(record) == 1 - - message = str(record[0].message) - - assert resident.name in message - assert "foo" in message - - if game.clean: - assert resident.prefs == [] - - -@given(game=games()) -def test_check_inputs_hospital_prefs_all_residents(game): - """Test each hospital has only residents in its preference list. - - If not, check that a warning is caught and the hospitals's - preferences are changed. - """ - - hospital = game.hospitals[0] - hospital.prefs = [Resident("foo")] - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_prefs_all_in_party("hospitals", "residents") - - assert len(record) == 1 - - message = str(record[0].message) - - assert hospital.name in message - assert "foo" in message - - if game.clean: - assert hospital.prefs == [] - - -@given(game=games()) -def test_check_inputs_hospital_prefs_all_reciprocated(game): - """Test each hospital has ranked only residents that have ranked it. - - If not, check that a warning is caught and the hospital has - forgotten any such residents. - """ - - hospital = game.hospitals[0] - resident = hospital.prefs[0] - resident._forget(hospital) - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_prefs_all_reciprocated("hospitals") - - assert len(record) == 1 - - message = str(record[0].message) - - assert hospital.name in message - assert resident.name in message - - if game.clean: - assert resident not in hospital.prefs - - -@given(game=games()) -def test_check_inputs_hospital_reciprocated_all_prefs(game): - """Test each hospital has ranked all residents that have ranked it. - - If not, check that a warning is caught and any such resident has - forgotten the hospital. - """ - - hospital = game.hospitals[0] - resident = hospital.prefs[0] - hospital._forget(resident) - - with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_reciprocated_all_prefs( - "hospitals", "residents" - ) - - assert len(record) == 1 - - message = str(record[0].message) - - assert hospital.name in message - assert resident.name in message - - if game.clean: - assert hospital not in resident.prefs - - -@given(game=games()) -def test_check_inputs_resident_prefs_all_nonempty(game): - """Test that each resident has a non-empty preference list. - - If not, check that a warning is caught and the resident has been - removed from the game. - """ - - resident = game.residents[0] - resident.prefs = [] - - with pytest.warns(PlayerExcludedWarning) as record: - game._check_inputs_player_prefs_nonempty("residents", "hospitals") - - assert len(record) == 1 - assert resident.name in str(record[0].message) - - if game.clean: - assert resident not in game.residents - - -@given(game=games()) -def test_check_inputs_hospital_prefs_all_nonempty(game): - """Test that each hospital has a non-empty preference list. - - If not, check that a warning is caught and the player has been - removed from the game. - """ - - hospital = game.hospitals[0] - hospital.prefs = [] - - with pytest.warns(PlayerExcludedWarning) as record: - game._check_inputs_player_prefs_nonempty("hospitals", "residents") - - assert len(record) == 1 - assert hospital.name in str(record[0].message) - - if game.clean: - assert hospital not in game.hospitals - - -@given(game=games()) -def test_check_inputs_hospital_capacity(game): - """Test each hospital has a positive integer capacity. - - If not, raise an Exception detailing the hospital. - """ - - hospital = game.hospitals[0] - capacity = hospital.capacity - hospital.capacity = 0 - - assert hospital._original_capacity == capacity - - with pytest.warns(PlayerExcludedWarning) as record: - game._check_inputs_player_capacity("hospitals", "residents") - - assert len(record) == 1 - assert hospital.name in str(record[0].message) - - if game.clean: - assert hospital not in game.hospitals - - -@given(game=games(), optimal=sampled_from(["resident", "hospital"])) -def test_solve(game, optimal): - """Test for the correct solving of games.""" - - matching = game.solve(optimal) - assert isinstance(matching, MultipleMatching) - - hospitals = sorted(game.hospitals, key=lambda h: h.name) - matching_keys = sorted(matching.keys(), key=lambda k: k.name) - for game_hospital, hospital in zip(matching_keys, hospitals): - assert game_hospital.name == hospital.name - assert game_hospital._pref_names == hospital._pref_names - assert game_hospital.capacity == hospital.capacity - - matched_residents = [ - resident for match in matching.values() for resident in match - ] - - assert matched_residents != [] and set(matched_residents).issubset( - set(game.residents) - ) - - for resident in set(game.residents) - set(matched_residents): - assert resident.matching is None - - -@given(game=games()) -def test_check_validity(game): - """Test for a valid matching when the game is solved.""" - - game.solve() - assert game.check_validity() - - -@given(game=games()) -def test_check_for_unacceptable_matches_residents(game): - """Test that matched residents have a preference of their match.""" - - resident = game.residents[0] - hospital = Hospital(name="foo", capacity=1) - resident.matching = hospital - - issues = game._check_for_unacceptable_matches("residents") - assert len(issues) == 1 - - issue = issues[0] - assert issue.startswith(resident.name) - assert issue.endswith(f"{resident.prefs}.") - assert hospital.name in issue - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.unacceptable_matches[0] - assert issue == error - - -@given(game=games()) -def test_check_for_unacceptable_matches_hospitals(game): - """Test that each hospital has a preference of all its matches.""" - - hospital = game.hospitals[0] - resident = Resident(name="foo") - hospital.matching.append(resident) - - issues = game._check_for_unacceptable_matches("hospitals") - assert len(issues) == 1 - - issue = issues[0] - assert issue.startswith(hospital.name) - assert issue.endswith(f"{hospital.prefs}.") - assert resident.name in issue - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.unacceptable_matches[0] - assert issue == error - - -@given(game=games()) -def test_check_for_oversubscribed_hospitals(game): - """Test that no hospitals can be oversubscribed.""" - - hospital = game.hospitals[0] - hospital.matching = range(hospital.capacity + 1) - - issues = game._check_for_oversubscribed_players("hospitals") - assert len(issues) == 1 - - issue = issues[0] - assert issue.startswith(hospital.name) - assert issue.endswith(f"{hospital.capacity}.") - assert str(hospital.matching) in issue - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.oversubscribed_hospitals[0] - assert issue == error - - -def test_check_stability(): - """Test checker for whether matching is stable or not.""" - - residents = [Resident("A"), Resident("B"), Resident("C")] - hospitals = [Hospital("X", 2), Hospital("Y", 2)] - - (a, b, c), (x, y) = residents, hospitals - - a.set_prefs([x, y]) - b.set_prefs([y]) - c.set_prefs([y, x]) - - x.set_prefs([c, a]) - y.set_prefs([a, b, c]) - - game = HospitalResident(residents, hospitals) - - matching = game.solve() - assert game.check_stability() - - (a, b, c), (x, y) = game.residents, game.hospitals - matching[x] = [c] - matching[y] = [a, b] - - assert not game.check_stability() diff --git a/tests/hospital_resident/util.py b/tests/hospital_resident/util.py index fb130df9..eb6f4ec5 100644 --- a/tests/hospital_resident/util.py +++ b/tests/hospital_resident/util.py @@ -43,9 +43,7 @@ def connections( resident_prefs = {} hospital_prefs = {h: [] for h in hospital_names} for resident in resident_names: - hospitals = draw( - lists(sampled_from(hospital_names), min_size=1, unique=True) - ) + hospitals = draw(lists(sampled_from(hospital_names), min_size=1, unique=True)) resident_prefs[resident] = hospitals for hospital in hospitals: hospital_prefs[hospital].append(resident) diff --git a/tests/matchings/__init__.py b/tests/matchings/__init__.py new file mode 100644 index 00000000..ad36acb8 --- /dev/null +++ b/tests/matchings/__init__.py @@ -0,0 +1 @@ +"""Tests for the `matching.matchings` module.""" diff --git a/tests/matchings/test_hospital_resident.py b/tests/matchings/test_hospital_resident.py new file mode 100644 index 00000000..7792f905 --- /dev/null +++ b/tests/matchings/test_hospital_resident.py @@ -0,0 +1,109 @@ +"""Tests for the `HRMatching` class.""" + +from hypothesis import given +from hypothesis import strategies as st + +from matching import matchings + +from ..common import st_sizes + + +@st.composite +def st_params(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a parameter set for a HRMatching instance.""" + + hsize = draw(st_sizes(hmin, hmax)) + rsize = draw(st_sizes(rmin, rmax)) + capacities = draw(st.lists(st.integers(1, 2), min_size=hsize, max_size=hsize)) + + matched_residents = draw(st.lists(st.integers(0, rsize - 1), unique=True)) + if not matched_residents: + matching = None + else: + resident_matching = {} + for resident in matched_residents: + hospital = draw(st.integers(0, hsize - 1)) + if capacities[hospital]: + resident_matching[resident] = hospital + capacities[hospital] -= 1 + + matching = { + hospital: [r for r in resident_matching if resident_matching[r] == hospital] + for hospital in range(hsize) + if hospital in resident_matching.values() + } + + params = dict( + dictionary=matching, keys=draw(st.text(min_size=1)), values=draw(st.text(min_size=1)) + ) + + return params + + +@st.composite +def st_matchings(draw, hmin=1, hmax=3, rmin=1, rmax=5): + """Create a HRMatching instance.""" + + params = draw(st_params(hmin, hmax, rmin, rmax)) + + return matchings.HRMatching(**params) + + +@given(st_params()) +def test_init(params): + """Check that a HRMatching can be created correctly.""" + + matching = matchings.HRMatching(**params) + + assert isinstance(matching, matchings.HRMatching) + assert isinstance(matching, dict) + + dictionary = params["dictionary"] or {} + assert matching.items() == dictionary.items() + assert vars(matching) == {"keys_": params["keys"], "values_": params["values"]} + + +@given(st_matchings()) +def test_repr(matching): + """Check that the string representation of a matching is correct.""" + + repr_ = repr(matching) + + assert isinstance(repr_, str) + assert repr_.startswith("HRMatching") + assert str(dict(matching)) in repr_ + assert matching.keys_ in repr_ + assert matching.values_ in repr_ + + +@given(st_params()) +def test_eq(params): + """Check that two HRMatchings are equal.""" + + matching1 = matchings.HRMatching(**params) + matching2 = matchings.HRMatching(**params) + + assert matching1 == matching2 + assert matching1 is not matching2 + + if params["dictionary"] is not None: + key = next(iter(params["dictionary"].keys())) + matching2[key] = None + + assert matching1 != matching2 + assert vars(matching1) == vars(matching2) + + +@given(st_matchings()) +def test_invert(matching): + """Check that the invert method works correctly.""" + + inverted = matching.invert() + + assert isinstance(inverted, matchings.HRMatching) + assert inverted.keys_ == matching.values_ + assert inverted.values_ == matching.keys_ + + for key, values in matching.items(): + for value in values: + assert inverted[value] == [key] diff --git a/tests/matchings/test_single.py b/tests/matchings/test_single.py deleted file mode 100644 index a9085e2c..00000000 --- a/tests/matchings/test_single.py +++ /dev/null @@ -1,106 +0,0 @@ -"""Unit tests for the SingleMatching class.""" - -from hypothesis import given -from hypothesis import strategies as st - -from matching.matchings import SingleMatching - - -@st.composite -def st_single_params(draw, min_size=2, max_size=5): - """Create a parameter set for a SingleMatching instance.""" - - size = draw(st.integers(min_size, max_size)) - midpoint = size // 2 - players = list(range(size)) - keys, values = players[:midpoint], players[midpoint:] - dictionary = draw(st.sampled_from((None, dict(zip(keys, values))))) - - keys = draw(st.text()) - values = draw(st.text()) - valid = draw(st.sampled_from((None, False, True))) - stable = draw(st.sampled_from((None, False, True))) - - params = dict( - dictionary=dictionary, - keys=keys, - values=values, - valid=valid, - stable=stable, - ) - - return params - - -@st.composite -def st_singles(draw, min_size=2, max_size=5): - """Create a SingleMatching instance.""" - - params = draw(st_single_params(min_size, max_size)) - - return SingleMatching(**params) - - -@given(st_single_params()) -def test_init(params): - """Check that a SingleMatching can be created correctly.""" - - matching = SingleMatching(**params) - - assert isinstance(matching, SingleMatching) - assert isinstance(matching, dict) - - dictionary = params["dictionary"] or {} - assert matching.items() == dictionary.items() - assert vars(matching) == { - "keys_": params["keys"], - "values_": params["values"], - "valid": params["valid"], - "stable": params["stable"], - } - - -@given(st_singles()) -def test_repr(matching): - """Check that the string representation of a matching is correct.""" - - repr_ = repr(matching) - - assert isinstance(repr_, str) - assert repr_.startswith("SingleMatching") - assert str(dict(matching)) in repr_ - assert matching.keys_ in repr_ - assert matching.values_ in repr_ - - -@given(st_single_params()) -def test_eq(params): - """Check the equivalence dunder works as expected.""" - - matching1 = SingleMatching(**params) - matching2 = SingleMatching(**params) - - assert matching1 == matching2 - - if params["dictionary"] is not None: - key = next(iter(params["dictionary"].keys())) - matching2[key] = None - - assert matching1 != matching2 - assert vars(matching1) == vars(matching2) - - -@given(st_singles()) -def test_invert(matching): - """Check the matching inverter works as it should.""" - - inverted = matching.invert() - - assert isinstance(inverted, SingleMatching) - assert set(inverted.items()) == set( - (val, key) for key, val in matching.items() - ) - assert inverted.keys_ == matching.values_ - assert inverted.values_ == matching.keys_ - assert inverted.valid == matching.valid - assert inverted.stable == matching.stable diff --git a/tests/matchings/test_stable_marriage.py b/tests/matchings/test_stable_marriage.py new file mode 100644 index 00000000..da02ef0c --- /dev/null +++ b/tests/matchings/test_stable_marriage.py @@ -0,0 +1,92 @@ +"""Tests for the `SMMatching` class.""" + +from hypothesis import given +from hypothesis import strategies as st + +from matching import matchings + +from ..common import st_sizes + + +@st.composite +def st_params(draw, min_size=2, max_size=5): + """Create a parameter set for a SMMatching instance.""" + + size = draw(st_sizes(min_size, max_size)) + midpoint = size // 2 + players = list(range(size)) + keys, values = players[:midpoint], players[midpoint:] + dictionary = draw(st.sampled_from((None, dict(zip(keys, values))))) + + keys = draw(st.text(min_size=1)) + values = draw(st.text(min_size=1)) + + params = dict(dictionary=dictionary, keys=keys, values=values) + + return params + + +@st.composite +def st_matchings(draw, min_size=2, max_size=5): + """Create a SMMatching instance.""" + + params = draw(st_params(min_size, max_size)) + + return matchings.SMMatching(**params) + + +@given(st_params()) +def test_init(params): + """Check that a SMMatching can be created correctly.""" + + matching = matchings.SMMatching(**params) + + assert isinstance(matching, matchings.SMMatching) + assert isinstance(matching, dict) + + dictionary = params["dictionary"] or {} + assert matching.items() == dictionary.items() + assert vars(matching) == {"keys_": params["keys"], "values_": params["values"]} + + +@given(st_matchings()) +def test_repr(matching): + """Check that the string representation of a matching is correct.""" + + repr_ = repr(matching) + + assert isinstance(repr_, str) + assert repr_.startswith("SMMatching") + assert str(dict(matching)) in repr_ + assert matching.keys_ in repr_ + assert matching.values_ in repr_ + + +@given(st_params()) +def test_eq(params): + """Check the equivalence dunder works as expected.""" + + matching1 = matchings.SMMatching(**params) + matching2 = matchings.SMMatching(**params) + + assert matching1 == matching2 + assert matching1 is not matching2 + + if params["dictionary"] is not None: + key = next(iter(params["dictionary"].keys())) + matching2[key] = None + + assert matching1 != matching2 + assert vars(matching1) == vars(matching2) + + +@given(st_matchings()) +def test_invert(matching): + """Check the matching inverter works as it should.""" + + inverted = matching.invert() + + assert isinstance(inverted, matchings.SMMatching) + assert set(inverted.items()) == set((val, key) for key, val in matching.items()) + assert inverted.keys_ == matching.values_ + assert inverted.values_ == matching.keys_ diff --git a/tests/stable_marriage/strategies.py b/tests/stable_marriage/strategies.py index 97616e04..a8013bbc 100644 --- a/tests/stable_marriage/strategies.py +++ b/tests/stable_marriage/strategies.py @@ -1,36 +1,8 @@ """Composite strategies for SM unit tests.""" -from unittest import mock - -import numpy as np from hypothesis import strategies as st -from hypothesis.extra import numpy as st_numpy - -from matching.games import StableMarriage - - -def mocked_game(suitor_ranks, reviewer_ranks): - """Create an instance of SM that mocks the input validator.""" - - with mock.patch( - "matching.games.StableMarriage.check_input_validity" - ) as validator: - game = StableMarriage(suitor_ranks, reviewer_ranks) - - validator.assert_called_once_with() - - return game - - -@st.composite -def st_single_ranks(draw, size): - """Create a single rank matrix.""" - - rank = draw( - st.lists(st.permutations(range(size)), min_size=size, max_size=size) - ) - return np.array(rank) +from ..common import st_single_ranks, st_single_utilities @st.composite @@ -56,21 +28,6 @@ def st_player_ranks(draw, pmin=1, pmax=5): return suitor_ranks, reviewer_ranks, player, ranks, side -@st.composite -def st_single_utilities(draw, size): - """Create a single utility matrix.""" - - utility = draw( - st_numpy.arrays( - dtype=float, - elements=st.floats(0, 1, allow_nan=False), - shape=(size, size), - ) - ) - - return utility - - @st.composite def st_utilities(draw, pmin=1, pmax=5): """Create a set of utility matrices.""" diff --git a/tests/stable_marriage/test_algorithm.py b/tests/stable_marriage/test_algorithm.py index 8c4a4782..6581f03e 100644 --- a/tests/stable_marriage/test_algorithm.py +++ b/tests/stable_marriage/test_algorithm.py @@ -1,9 +1,12 @@ -"""Integration tests for the Stable Marriage Problem algorithm.""" +"""Unit tests for the Stable Marriage algorithm.""" import numpy as np from hypothesis import given -from .strategies import mocked_game, st_ranks +from matching.games import StableMarriage + +from ..common import mocked_game +from .strategies import st_ranks def _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks): @@ -12,9 +15,7 @@ def _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks): assert isinstance(matching, dict) assert (np.sort(list(matching.keys())) == np.unique(suitor_ranks)).all() - assert ( - np.sort(list(matching.values())) == np.unique(reviewer_ranks) - ).all() + assert (np.sort(list(matching.values())) == np.unique(reviewer_ranks)).all() @given(st_ranks()) @@ -22,7 +23,7 @@ def test_stable_marriage_suitor_optimal(ranks): """Test that the SM algorithm is valid and suitor-optimal.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) matching = game._stable_marriage() @@ -31,10 +32,7 @@ def test_stable_marriage_suitor_optimal(ranks): for reviewer, suitor in matching.items(): suitor_rank = game.suitor_ranks[suitor] preferred_reviewers, *_ = np.where(suitor_rank < suitor_rank[reviewer]) - for preferred in preferred_reviewers: - preferred_rank = game.reviewer_ranks[preferred] - partner = matching[preferred] - assert preferred_rank[suitor] > preferred_rank[partner] + assert not preferred_reviewers.any() @given(st_ranks()) @@ -42,7 +40,7 @@ def test_stable_marriage_reviewer_pessimal(ranks): """Test that the SM algorithm is valid and reviewer-pessimal.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) matching = game._stable_marriage() @@ -54,7 +52,5 @@ def test_stable_marriage_reviewer_pessimal(ranks): for lesser in lesser_suitors: lesser_rank = game.suitor_ranks[lesser] - partner = next( - rev for rev, sui in matching.items() if sui == lesser - ) + partner = next(rev for rev, sui in matching.items() if sui == lesser) assert lesser_rank[partner] < lesser_rank[reviewer] diff --git a/tests/stable_marriage/test_examples.py b/tests/stable_marriage/test_examples.py index 18c1cd2d..a9401047 100644 --- a/tests/stable_marriage/test_examples.py +++ b/tests/stable_marriage/test_examples.py @@ -25,12 +25,10 @@ def test_pride_and_prejudice(): "L": ("B", "W", "D", "C"), } - game = StableMarriage.from_preferences( - suitor_preferences, reviewer_preferences - ) + game = StableMarriage.from_preferences(suitor_preferences, reviewer_preferences) matching = game.solve() - assert dict(matching) == {"J": "B", "C": "C", "E": "D", "L": "W"} + assert matching == {"J": "B", "C": "C", "E": "D", "L": "W"} def test_readme_example(): @@ -47,12 +45,10 @@ def test_readme_example(): "F": ["C", "B", "A"], } - game = StableMarriage.from_preferences( - suitor_preferences, reviewer_preferences - ) + game = StableMarriage.from_preferences(suitor_preferences, reviewer_preferences) matching = game.solve() - assert dict(matching) == {"E": "A", "D": "B", "F": "C"} + assert matching == {"E": "A", "D": "B", "F": "C"} def test_matchingr_example(): @@ -66,4 +62,4 @@ def test_matchingr_example(): matching = game.solve() - assert dict(matching) == {0: 1, 1: 0} + assert matching == {0: 1, 1: 0} diff --git a/tests/stable_marriage/test_game.py b/tests/stable_marriage/test_game.py index 7881353b..a6e4f8df 100644 --- a/tests/stable_marriage/test_game.py +++ b/tests/stable_marriage/test_game.py @@ -9,10 +9,10 @@ from hypothesis import strategies as st from matching.games import StableMarriage -from matching.matchings import SingleMatching +from matching.matchings import SMMatching +from ..common import mocked_game from .strategies import ( - mocked_game, st_player_ranks, st_preference_matchings, st_preferences, @@ -26,8 +26,9 @@ def test_init(ranks): """Test for correct instantiation given some rankings.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) + assert isinstance(game, StableMarriage) assert (game.suitor_ranks == suitor_ranks).all() assert (game.reviewer_ranks == reviewer_ranks).all() @@ -44,9 +45,7 @@ def test_from_utilities(utilities): suitor_utility, reviewer_utility = utilities with ( - mock.patch( - "matching.games.StableMarriage.check_input_validity" - ) as validator, + mock.patch("matching.games.StableMarriage.check_input_validity") as validator, mock.patch("matching.convert.utility_to_rank") as ranker, ): effects = (suitor_utility.argsort(), reviewer_utility.argsort()) @@ -77,9 +76,7 @@ def test_from_preferences(preferences): suitor_prefs, reviewer_prefs = preferences with ( - mock.patch( - "matching.games.StableMarriage.check_input_validity" - ) as validator, + mock.patch("matching.games.StableMarriage.check_input_validity") as validator, mock.patch("matching.convert.preference_to_rank") as ranker, ): effects = ( @@ -118,7 +115,7 @@ def test_from_preferences(preferences): def test_check_number_of_players_no_warning(ranks): """Test the number of players can be checked without warning.""" - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) with warnings.catch_warnings(): warnings.simplefilter("error") @@ -132,7 +129,7 @@ def test_check_number_of_players_warning(ranks): suitor_ranks, reviewer_ranks = ranks suitor_ranks = np.vstack((suitor_ranks, suitor_ranks[-1][::-1])) - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) match = ( r"^Number of suitors \(\d{1,2}\) " @@ -147,7 +144,7 @@ def test_check_player_ranks_no_warning(player_ranks): """Test the rank checker runs without warning for a valid set.""" suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) with warnings.catch_warnings(): warnings.simplefilter("error") @@ -161,7 +158,7 @@ def test_check_player_ranks_warning(player_ranks): suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks ranks[-1] = 1000 - game = mocked_game(suitor_ranks, reviewer_ranks) + game = mocked_game(StableMarriage, suitor_ranks, reviewer_ranks) match = f"{side.title()} {player} has not strictly ranked" with pytest.warns(UserWarning, match=match): @@ -179,23 +176,17 @@ def test_check_input_validity(ranks): """Test the logic of the input validator.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) with ( - mock.patch( - "matching.games.StableMarriage._check_number_of_players" - ) as check_num_players, - mock.patch( - "matching.games.StableMarriage._check_player_ranks" - ) as check_player_ranks, + mock.patch("matching.games.StableMarriage._check_number_of_players") as check_num_players, + mock.patch("matching.games.StableMarriage._check_player_ranks") as check_player_ranks, ): game.check_input_validity() check_num_players.assert_called_once_with() - assert check_player_ranks.call_count == ( - len(suitor_ranks) + len(reviewer_ranks) - ) + assert check_player_ranks.call_count == (len(suitor_ranks) + len(reviewer_ranks)) suitor_args = _zip_enumerated_ranks_with_side(suitor_ranks, "suitor") reviewer_args = _zip_enumerated_ranks_with_side(reviewer_ranks, "reviewer") @@ -214,7 +205,7 @@ def test_invert_player_sets(ranks): """Test that the player set attributes can be swapped.""" suitor_ranks, reviewer_ranks = ranks - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) game._invert_player_sets() @@ -232,18 +223,12 @@ def test_invert_player_sets(ranks): def test_solve_valid_optimal(ranks, optimal, solution): """Test the solver runs as it should with valid inputs.""" - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) with ( - mock.patch( - "matching.games.StableMarriage._invert_player_sets" - ) as player_set_inverter, - mock.patch( - "matching.games.StableMarriage._stable_marriage" - ) as stable_marriage, - mock.patch( - "matching.matchings.SingleMatching.invert" - ) as matching_inverter, + mock.patch("matching.games.StableMarriage._invert_player_sets") as player_set_inverter, + mock.patch("matching.games.StableMarriage._stable_marriage") as stable_marriage, + mock.patch("matching.matchings.SMMatching.invert") as matching_inverter, ): stable_marriage.return_value = solution matching_inverter.return_value = "inverted_matching" @@ -260,7 +245,7 @@ def test_solve_valid_optimal(ranks, optimal, solution): ] assert matching == "inverted_matching" else: - assert isinstance(matching, SingleMatching) + assert isinstance(matching, SMMatching) assert dict(matching) == solution @@ -268,19 +253,13 @@ def test_solve_valid_optimal(ranks, optimal, solution): def test_solve_invalid_optimal_raises(ranks, optimal): """Test the solver raises an error with invalid optimal.""" - game = mocked_game(*ranks) + game = mocked_game(StableMarriage, *ranks) match = "^Invalid choice for `optimal`." with ( - mock.patch( - "matching.games.StableMarriage._invert_player_sets" - ) as player_set_inverter, - mock.patch( - "matching.games.StableMarriage._stable_marriage" - ) as stable_marriage, - mock.patch( - "matching.matchings.SingleMatching.invert" - ) as matching_inverter, + mock.patch("matching.games.StableMarriage._invert_player_sets") as player_set_inverter, + mock.patch("matching.games.StableMarriage._stable_marriage") as stable_marriage, + mock.patch("matching.matchings.SMMatching.invert") as matching_inverter, pytest.raises(ValueError, match=match), ): game.solve(optimal) @@ -296,21 +275,19 @@ def test_convert_matching_to_preferences(preference_matchings): suitor_prefs, reviewer_prefs, matching = preference_matchings - # the arrays here aren't used anywhere internally, just placeholders - with warnings.catch_warnings(): - warnings.simplefilter("ignore") + with mock.patch.object(StableMarriage, "check_input_validity") as validator: game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs) - game.matching = SingleMatching(matching) + game.matching = SMMatching(matching) game._convert_matching_to_preferences() converted = game.matching - assert isinstance(converted, SingleMatching) + assert isinstance(converted, SMMatching) assert converted.keys_ == "reviewers" assert converted.values_ == "suitors" - assert converted.valid is None - assert converted.stable is None assert set(converted.keys()) == set(reviewer_prefs) assert set(converted.values()) == set(suitor_prefs) + + validator.assert_called_once_with() diff --git a/tests/stable_marriage/util.py b/tests/stable_marriage/util.py index 566538e6..718adbee 100644 --- a/tests/stable_marriage/util.py +++ b/tests/stable_marriage/util.py @@ -53,21 +53,15 @@ def make_prefs(player_names, seed): np.random.seed(seed) suitor_names, reviewer_names = player_names - suitor_prefs = { - name: np.random.permutation(reviewer_names).tolist() - for name in suitor_names - } + suitor_prefs = {name: np.random.permutation(reviewer_names).tolist() for name in suitor_names} reviewer_prefs = { - name: np.random.permutation(suitor_names).tolist() - for name in reviewer_names + name: np.random.permutation(suitor_names).tolist() for name in reviewer_names } return suitor_prefs, reviewer_prefs STABLE_MARRIAGE = given( - player_names=get_player_names( - suitor_pool=["A", "B", "C"], reviewer_pool=["X", "Y", "Z"] - ), + player_names=get_player_names(suitor_pool=["A", "B", "C"], reviewer_pool=["X", "Y", "Z"]), seed=integers(min_value=0, max_value=2**32 - 1), ) diff --git a/tests/stable_roommates/test_algorithm.py b/tests/stable_roommates/test_algorithm.py index bef68f9e..a15b4d3c 100644 --- a/tests/stable_roommates/test_algorithm.py +++ b/tests/stable_roommates/test_algorithm.py @@ -22,9 +22,7 @@ def test_first_phase(players): players = first_phase(players) - player_matched = { - player: player.matching is not None for player in players - } + player_matched = {player: player.matching is not None for player in players} assert sum(player_matched.values()) >= len(players) - 1 for player in players: diff --git a/tests/stable_roommates/test_examples.py b/tests/stable_roommates/test_examples.py index 2450acb1..ecc12be1 100644 --- a/tests/stable_roommates/test_examples.py +++ b/tests/stable_roommates/test_examples.py @@ -84,10 +84,7 @@ def test_large_example_from_book(): def test_example_in_issue_64(): """Test the example provided in #64.""" - players = [ - Player(name) - for name in ("charlie", "peter", "elise", "paul", "kelly", "sam") - ] + players = [Player(name) for name in ("charlie", "peter", "elise", "paul", "kelly", "sam")] charlie, peter, elise, paul, kelly, sam = players charlie.set_prefs([peter, paul, sam, kelly, elise]) diff --git a/tests/student_allocation/test_algorithm.py b/tests/student_allocation/test_algorithm.py index f2ef7f0b..32a3e14b 100644 --- a/tests/student_allocation/test_algorithm.py +++ b/tests/student_allocation/test_algorithm.py @@ -34,9 +34,7 @@ def test_student_allocation( @STUDENT_ALLOCATION -def test_student_optimal( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_student_optimal(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that the student-optimal algorithm is student-optimal.""" np.random.seed(seed) @@ -47,12 +45,7 @@ def test_student_optimal( assert set(projects) == set(matching.keys()) assert all( - [ - s in set(students) - for s in { - match for matches in matching.values() for match in matches - } - ] + [s in set(students) for s in {match for matches in matching.values() for match in matches}] ) for student in students: @@ -74,12 +67,7 @@ def test_supervisor_optimal( assert set(projects) == set(matching.keys()) assert all( - [ - s in set(students) - for s in { - match for matches in matching.values() for match in matches - } - ] + [s in set(students) for s in {match for matches in matching.values() for match in matches}] ) for supervisor in supervisors: diff --git a/tests/student_allocation/test_examples.py b/tests/student_allocation/test_examples.py index bafb86f1..f1dcbac3 100644 --- a/tests/student_allocation/test_examples.py +++ b/tests/student_allocation/test_examples.py @@ -34,7 +34,5 @@ def test_example_in_docs(): a, b, c, d, e = game.students x1, x2, y1, y2 = game.projects - matching = student_allocation( - game.students, game.projects, game.supervisors - ) + matching = student_allocation(game.students, game.projects, game.supervisors) assert matching == {x1: [c, a], x2: [], y1: [d], y2: [b, e]} diff --git a/tests/student_allocation/test_solver.py b/tests/student_allocation/test_solver.py index f94297a3..db02a9f5 100644 --- a/tests/student_allocation/test_solver.py +++ b/tests/student_allocation/test_solver.py @@ -18,9 +18,7 @@ @STUDENT_ALLOCATION -def test_init( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_init(student_names, project_names, supervisor_names, capacities, seed, clean): """Test for correct instantiation given some players.""" students, projects, supervisors, game = make_game( @@ -90,9 +88,7 @@ def test_remove_supervisor_and_projects( ): """Test that a supervisor and its projects can be removed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] projects = supervisor.projects @@ -103,14 +99,10 @@ def test_remove_supervisor_and_projects( @STUDENT_ALLOCATION -def test_remove_student( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_remove_student(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that a student can be removed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) student = game.students[0] @@ -119,14 +111,10 @@ def test_remove_student( @STUDENT_ALLOCATION -def test_check_inputs( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_check_inputs(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that inputs to an instance of SA can be verified.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) with warnings.catch_warnings(record=True): warnings.simplefilter("error") @@ -147,9 +135,7 @@ def test_check_inputs_project_prefs_all_reciprocated( any such students. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) project = game.projects[0] student = project.prefs[0] @@ -179,9 +165,7 @@ def test_check_inputs_supervisor_prefs_all_reciprocated( projects have forgotten any such students. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] student = supervisor.prefs[0] @@ -202,9 +186,7 @@ def test_check_inputs_supervisor_prefs_all_reciprocated( if clean: assert student not in supervisor.prefs - assert all( - student not in project.prefs for project in supervisor.projects - ) + assert all(student not in project.prefs for project in supervisor.projects) @STUDENT_ALLOCATION @@ -217,18 +199,14 @@ def test_check_inputs_project_reciprocated_all_prefs( forgotten the project. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) project = game.projects[0] student = project.prefs[0] project._forget(student) with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_reciprocated_all_prefs( - "projects", "students" - ) + game._check_inputs_player_reciprocated_all_prefs("projects", "students") assert len(record) == 1 @@ -252,18 +230,14 @@ def test_check_inputs_supervisor_reciprocated_all_prefs( forgotten all projects belonging to that supervisor. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] student = supervisor.prefs[0] supervisor.prefs.remove(student) with pytest.warns(PreferencesChangedWarning) as record: - game._check_inputs_player_reciprocated_all_prefs( - "supervisors", "students" - ) + game._check_inputs_player_reciprocated_all_prefs("supervisors", "students") assert len(record) == 1 @@ -274,9 +248,7 @@ def test_check_inputs_supervisor_reciprocated_all_prefs( if clean: assert supervisor not in student.prefs - assert all( - project not in student.prefs for project in supervisor.projects - ) + assert all(project not in student.prefs for project in supervisor.projects) @STUDENT_ALLOCATION @@ -289,9 +261,7 @@ def test_check_inputs_supervisor_capacities_sufficient( updated to their supervisor's. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) project = game.projects[0] supervisor_capacity = project.supervisor.capacity @@ -322,9 +292,7 @@ def test_check_inputs_supervisor_capacities_necessary( updated to be the sum of its projects. """ - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) supervisor = game.supervisors[0] total_project_capacity = sum(p.capacity for p in supervisor.projects) @@ -346,9 +314,7 @@ def test_check_inputs_supervisor_capacities_necessary( @STUDENT_ALLOCATION -def test_solve( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_solve(student_names, project_names, supervisor_names, capacities, seed, clean): """Test that the class can solve games correctly.""" for optimal in ["student", "supervisor"]: @@ -372,12 +338,8 @@ def test_solve( assert game_project.capacity == project.capacity assert game_project.supervisor.name == project.supervisor.name - matched_students = [ - stud for match in matching.values() for stud in match - ] - assert matched_students != [] and set(matched_students).issubset( - set(game.students) - ) + matched_students = [stud for match in matching.values() for stud in match] + assert matched_students != [] and set(matched_students).issubset(set(game.students)) for student in matched_students: supervisor = student.matching.supervisor @@ -388,14 +350,10 @@ def test_solve( @STUDENT_ALLOCATION -def test_check_validity( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def test_check_validity(student_names, project_names, supervisor_names, capacities, seed, clean): """Test for a valid matching when the game is solved.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() assert game.check_validity() @@ -407,9 +365,7 @@ def test_check_for_unacceptable_matches_students( ): """Test that each matched student must have ranked their match.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() student = game.students[0] @@ -430,9 +386,7 @@ def test_check_for_unacceptable_matches_projects( ): """Test that each project must rank all their matches.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() project = game.projects[0] @@ -453,9 +407,7 @@ def test_check_for_unacceptable_matches_supervisors( ): """Test that each supervisor must rank all their matches.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() supervisor = game.supervisors[0] @@ -476,9 +428,7 @@ def test_check_for_oversubscribed_projects( ): """Test that all projects must not be over-subscribed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() project = game.projects[0] @@ -498,9 +448,7 @@ def test_check_for_oversubscribed_supervisors( ): """Test that all supervisors must not be over-subscribed.""" - *_, game = make_game( - student_names, project_names, supervisor_names, capacities, seed, clean - ) + *_, game = make_game(student_names, project_names, supervisor_names, capacities, seed, clean) game.solve() supervisor = game.supervisors[0] diff --git a/tests/student_allocation/util.py b/tests/student_allocation/util.py index 7545ccd8..46fe5ee4 100644 --- a/tests/student_allocation/util.py +++ b/tests/student_allocation/util.py @@ -15,15 +15,9 @@ def get_possible_prefs(players): """Get list of possible non-empty preferences from some players.""" - all_ordered_subsets = { - tuple(set(sub)) for sub in it.product(players, repeat=len(players)) - } + all_ordered_subsets = {tuple(set(sub)) for sub in it.product(players, repeat=len(players))} - possible_prefs = [ - list(perm) - for sub in all_ordered_subsets - for perm in it.permutations(sub) - ] + possible_prefs = [list(perm) for sub in all_ordered_subsets for perm in it.permutations(sub)] return possible_prefs @@ -32,12 +26,8 @@ def make_players(student_names, project_names, supervisor_names, capacities): """Given some names and capacities, make a set of players for SA.""" students = [Student(name) for name in student_names] - projects = [ - Project(name, cap) for name, cap in zip(project_names, capacities) - ] - supervisors = [ - Supervisor(name, capacity=None) for name in supervisor_names - ] + projects = [Project(name, cap) for name, cap in zip(project_names, capacities)] + supervisors = [Supervisor(name, capacity=None) for name in supervisor_names] if len(students) > len(projects): students = students[: len(projects)] @@ -45,9 +35,7 @@ def make_players(student_names, project_names, supervisor_names, capacities): for project in projects: project.set_supervisor(np.random.choice(supervisors)) - supervisors = [ - supervisor for supervisor in supervisors if supervisor.projects - ] + supervisors = [supervisor for supervisor in supervisors if supervisor.projects] for supervisor in supervisors: capacities = sorted([proj.capacity for proj in supervisor.projects]) min_cap, max_cap = max(capacities), sum(capacities) @@ -72,9 +60,7 @@ def make_players(student_names, project_names, supervisor_names, capacities): return students, projects, supervisors -def make_game( - student_names, project_names, supervisor_names, capacities, seed, clean -): +def make_game(student_names, project_names, supervisor_names, capacities, seed, clean): """Make all of the players and the game itself.""" np.random.seed(seed) @@ -86,9 +72,7 @@ def make_game( return students, projects, supervisors, game -def make_connections( - student_names, project_names, supervisor_names, capacities, seed -): +def make_connections(student_names, project_names, supervisor_names, capacities, seed): """Make a set of preferences and affiliations from some names.""" np.random.seed(seed) @@ -114,9 +98,7 @@ def make_connections( if student not in sup_prefs: sup_prefs.append(student) - chosen_projects = { - p for projects in student_prefs.values() for p in projects - } + chosen_projects = {p for projects in student_prefs.values() for p in projects} for project in set(project_names) - chosen_projects: del project_supervisors[project] del project_capacities[project] @@ -161,9 +143,7 @@ def make_connections( max_size=3, unique=True, ), - capacities=lists( - integers(min_value=1, max_value=2), min_size=5, max_size=5 - ), + capacities=lists(integers(min_value=1, max_value=2), min_size=5, max_size=5), seed=integers(min_value=0, max_value=2**32 - 1), clean=booleans(), ) diff --git a/tests/test_convert.py b/tests/test_convert.py index caa9be02..eb3c5528 100644 --- a/tests/test_convert.py +++ b/tests/test_convert.py @@ -13,9 +13,7 @@ def utilities(draw, smin=1, smax=10, unique=True): """Create a utility matrix for a test.""" shape = draw(st.tuples(st.integers(smin, smax), st.integers(smin, smax))) - utilities = draw( - arrays(float, shape, elements=st.floats(0, 1), unique=unique) - ) + utilities = draw(arrays(float, shape, elements=st.floats(0, 1), unique=unique)) return utilities @@ -24,12 +22,8 @@ def utilities(draw, smin=1, smax=10, unique=True): def preferences(draw, pmin=1, pmax=10): """Create a preference dictionary to test.""" - players = draw( - st.lists(st.integers(), min_size=pmin, max_size=pmax, unique=True) - ) - others = draw( - st.lists(st.text(), min_size=pmin, max_size=pmax, unique=True) - ) + players = draw(st.lists(st.integers(), min_size=pmin, max_size=pmax, unique=True)) + others = draw(st.lists(st.text(), min_size=pmin, max_size=pmax, unique=True)) preference = {player: draw(st.permutations(others)) for player in players} diff --git a/tests/test_matchings.py b/tests/test_matchings.py deleted file mode 100644 index 85bb654d..00000000 --- a/tests/test_matchings.py +++ /dev/null @@ -1,58 +0,0 @@ -"""Tests for the matching classes.""" - -from hypothesis import given -from hypothesis.strategies import ( - composite, - integers, - lists, - sampled_from, - text, -) - -from matching import MultipleMatching -from matching.players import Hospital, Player - - -@composite -def multiples( - draw, - host_names_from=text(), - player_names_from=text(), - min_hosts=2, - max_hosts=5, - min_players=10, - max_players=20, -): - """A strategy for creating multiple-match matchings from players.""" - - num_hosts = draw(integers(min_value=min_hosts, max_value=max_hosts)) - num_players = draw(integers(min_value=min_players, max_value=max_players)) - - hosts = [ - Hospital(draw(host_names_from), max_players) for _ in range(num_hosts) - ] - players = [Player(draw(player_names_from)) for _ in range(num_players)] - - dictionary = {} - for host in hosts: - matches = draw(lists(sampled_from(players), min_size=0, unique=True)) - dictionary[host] = matches - - return dictionary - - -@given(dictionary=multiples()) -def test_multiple_setitem(dictionary): - """Test that a host player in a matching can have a list match.""" - - matching = MultipleMatching(dictionary) - host = list(dictionary.keys())[0] - players = list( - {player for players in dictionary.values() for player in players} - )[:-1] - - matching[host] = players - assert matching[host] == players - assert host.matching == players - for player in players: - assert player.matching == host diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..b0574075 --- /dev/null +++ b/uv.lock @@ -0,0 +1,2408 @@ +version = 1 +revision = 1 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929 }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321 }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, +] + +[[package]] +name = "attrs" +version = "25.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537 }, +] + +[[package]] +name = "beartype" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/48/fe1177f4272a1bc344f3371414aa5b76e19c30d7280d711ce90c5335a6f5/beartype-0.20.0.tar.gz", hash = "sha256:599ecc86b88549bcb6d1af626f44d85ffbb9151ace5d7f9f3b493dce2ffee529", size = 1390635 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/ce/9cf60b72e3fbd36a6dd16e31ecbe9ae137a8ead77cb24a5f75302adfc9a9/beartype-0.20.0-py3-none-any.whl", hash = "sha256:090d10e3540b3fca209a0ab5f1c15f9652a075da0a7249c2e6713011e9e5f6ef", size = 1139097 }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f0/3c/adaf39ce1fb4afdd21b611e3d530b183bb7759c9b673d60db0e347fd4439/beautifulsoup4-4.13.3.tar.gz", hash = "sha256:1bd32405dacc920b42b83ba01644747ed77456a65760e285fbc47633ceddaf8b", size = 619516 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/49/6abb616eb3cbab6a7cca303dc02fdf3836de2e0b834bf966a7f5271a34d8/beautifulsoup4-4.13.3-py3-none-any.whl", hash = "sha256:99045d7d3f08f91f0d656bc9b7efbae189426cd913d830294a15eefa0ea4df16", size = 186015 }, +] + +[[package]] +name = "black" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "mypy-extensions" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "platformdirs" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/94/49/26a7b0f3f35da4b5a65f081943b7bcd22d7002f5f0fb8098ec1ff21cb6ef/black-25.1.0.tar.gz", hash = "sha256:33496d5cd1222ad73391352b4ae8da15253c5de89b93a80b3e2c8d9a19ec2666", size = 649449 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/3b/4ba3f93ac8d90410423fdd31d7541ada9bcee1df32fb90d26de41ed40e1d/black-25.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:759e7ec1e050a15f89b770cefbf91ebee8917aac5c20483bc2d80a6c3a04df32", size = 1629419 }, + { url = "https://files.pythonhosted.org/packages/b4/02/0bde0485146a8a5e694daed47561785e8b77a0466ccc1f3e485d5ef2925e/black-25.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e519ecf93120f34243e6b0054db49c00a35f84f195d5bce7e9f5cfc578fc2da", size = 1461080 }, + { url = "https://files.pythonhosted.org/packages/52/0e/abdf75183c830eaca7589144ff96d49bce73d7ec6ad12ef62185cc0f79a2/black-25.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:055e59b198df7ac0b7efca5ad7ff2516bca343276c466be72eb04a3bcc1f82d7", size = 1766886 }, + { url = "https://files.pythonhosted.org/packages/dc/a6/97d8bb65b1d8a41f8a6736222ba0a334db7b7b77b8023ab4568288f23973/black-25.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:db8ea9917d6f8fc62abd90d944920d95e73c83a5ee3383493e35d271aca872e9", size = 1419404 }, + { url = "https://files.pythonhosted.org/packages/7e/4f/87f596aca05c3ce5b94b8663dbfe242a12843caaa82dd3f85f1ffdc3f177/black-25.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a39337598244de4bae26475f77dda852ea00a93bd4c728e09eacd827ec929df0", size = 1614372 }, + { url = "https://files.pythonhosted.org/packages/e7/d0/2c34c36190b741c59c901e56ab7f6e54dad8df05a6272a9747ecef7c6036/black-25.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96c1c7cd856bba8e20094e36e0f948718dc688dba4a9d78c3adde52b9e6c2299", size = 1442865 }, + { url = "https://files.pythonhosted.org/packages/21/d4/7518c72262468430ead45cf22bd86c883a6448b9eb43672765d69a8f1248/black-25.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce2e264d59c91e52d8000d507eb20a9aca4a778731a08cfff7e5ac4a4bb7096", size = 1749699 }, + { url = "https://files.pythonhosted.org/packages/58/db/4f5beb989b547f79096e035c4981ceb36ac2b552d0ac5f2620e941501c99/black-25.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:172b1dbff09f86ce6f4eb8edf9dede08b1fce58ba194c87d7a4f1a5aa2f5b3c2", size = 1428028 }, + { url = "https://files.pythonhosted.org/packages/83/71/3fe4741df7adf015ad8dfa082dd36c94ca86bb21f25608eb247b4afb15b2/black-25.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4b60580e829091e6f9238c848ea6750efed72140b91b048770b64e74fe04908b", size = 1650988 }, + { url = "https://files.pythonhosted.org/packages/13/f3/89aac8a83d73937ccd39bbe8fc6ac8860c11cfa0af5b1c96d081facac844/black-25.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e2978f6df243b155ef5fa7e558a43037c3079093ed5d10fd84c43900f2d8ecc", size = 1453985 }, + { url = "https://files.pythonhosted.org/packages/6f/22/b99efca33f1f3a1d2552c714b1e1b5ae92efac6c43e790ad539a163d1754/black-25.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b48735872ec535027d979e8dcb20bf4f70b5ac75a8ea99f127c106a7d7aba9f", size = 1783816 }, + { url = "https://files.pythonhosted.org/packages/18/7e/a27c3ad3822b6f2e0e00d63d58ff6299a99a5b3aee69fa77cd4b0076b261/black-25.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:ea0213189960bda9cf99be5b8c8ce66bb054af5e9e861249cd23471bd7b0b3ba", size = 1440860 }, + { url = "https://files.pythonhosted.org/packages/98/87/0edf98916640efa5d0696e1abb0a8357b52e69e82322628f25bf14d263d1/black-25.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8f0b18a02996a836cc9c9c78e5babec10930862827b1b724ddfe98ccf2f2fe4f", size = 1650673 }, + { url = "https://files.pythonhosted.org/packages/52/e5/f7bf17207cf87fa6e9b676576749c6b6ed0d70f179a3d812c997870291c3/black-25.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:afebb7098bfbc70037a053b91ae8437c3857482d3a690fefc03e9ff7aa9a5fd3", size = 1453190 }, + { url = "https://files.pythonhosted.org/packages/e3/ee/adda3d46d4a9120772fae6de454c8495603c37c4c3b9c60f25b1ab6401fe/black-25.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:030b9759066a4ee5e5aca28c3c77f9c64789cdd4de8ac1df642c40b708be6171", size = 1782926 }, + { url = "https://files.pythonhosted.org/packages/cc/64/94eb5f45dcb997d2082f097a3944cfc7fe87e071907f677e80788a2d7b7a/black-25.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:a22f402b410566e2d1c950708c77ebf5ebd5d0d88a6a2e87c86d9fb48afa0d18", size = 1442613 }, + { url = "https://files.pythonhosted.org/packages/09/71/54e999902aed72baf26bca0d50781b01838251a462612966e9fc4891eadd/black-25.1.0-py3-none-any.whl", hash = "sha256:95e8176dae143ba9097f351d174fdaf0ccd29efb414b362ae3fd72bf0f710717", size = 207646 }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406 }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2025.1.31" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 }, + { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 }, + { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 }, + { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 }, + { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 }, + { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 }, + { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 }, + { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 }, + { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 }, + { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 }, + { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 }, + { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 }, + { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 }, + { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 }, + { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 }, + { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 }, + { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 }, + { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 }, + { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 }, + { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 }, + { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 }, + { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 }, + { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 }, + { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 }, + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 }, + { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 }, + { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 }, + { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 }, + { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 }, + { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 }, + { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 }, + { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 }, + { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 }, + { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 }, + { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 }, + { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013 }, + { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285 }, + { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449 }, + { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892 }, + { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123 }, + { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943 }, + { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063 }, + { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578 }, + { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629 }, + { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778 }, + { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453 }, + { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479 }, + { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790 }, + { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 }, + { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 }, + { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 }, + { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 }, + { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 }, + { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 }, + { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 }, + { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 }, + { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 }, + { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 }, + { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 }, + { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 }, + { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 }, + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, + { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 }, + { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 }, + { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 }, + { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 }, + { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 }, + { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 }, + { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 }, + { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 }, + { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 }, + { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 }, + { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 }, + { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 }, + { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, +] + +[[package]] +name = "click" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, +] + +[[package]] +name = "comm" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/a8/fb783cb0abe2b5fded9f55e5703015cdf1c9c85b3669087c538dd15a6a86/comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e", size = 6210 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/75/49e5bfe642f71f272236b5b2d2691cf915a7283cc0ceda56357b61daa538/comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3", size = 7180 }, +] + +[[package]] +name = "contourpy" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/c2/fc7193cc5383637ff390a712e88e4ded0452c9fbcf84abe3de5ea3df1866/contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699", size = 13465753 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/80937fe3efe0edacf67c9a20b955139a1a622730042c1ea991956f2704ad/contourpy-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a045f341a77b77e1c5de31e74e966537bba9f3c4099b35bf4c2e3939dd54cdab", size = 268466 }, + { url = "https://files.pythonhosted.org/packages/82/1d/e3eaebb4aa2d7311528c048350ca8e99cdacfafd99da87bc0a5f8d81f2c2/contourpy-1.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:500360b77259914f7805af7462e41f9cb7ca92ad38e9f94d6c8641b089338124", size = 253314 }, + { url = "https://files.pythonhosted.org/packages/de/f3/d796b22d1a2b587acc8100ba8c07fb7b5e17fde265a7bb05ab967f4c935a/contourpy-1.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2f926efda994cdf3c8d3fdb40b9962f86edbc4457e739277b961eced3d0b4c1", size = 312003 }, + { url = "https://files.pythonhosted.org/packages/bf/f5/0e67902bc4394daee8daa39c81d4f00b50e063ee1a46cb3938cc65585d36/contourpy-1.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adce39d67c0edf383647a3a007de0a45fd1b08dedaa5318404f1a73059c2512b", size = 351896 }, + { url = "https://files.pythonhosted.org/packages/1f/d6/e766395723f6256d45d6e67c13bb638dd1fa9dc10ef912dc7dd3dcfc19de/contourpy-1.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abbb49fb7dac584e5abc6636b7b2a7227111c4f771005853e7d25176daaf8453", size = 320814 }, + { url = "https://files.pythonhosted.org/packages/a9/57/86c500d63b3e26e5b73a28b8291a67c5608d4aa87ebd17bd15bb33c178bc/contourpy-1.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0cffcbede75c059f535725c1680dfb17b6ba8753f0c74b14e6a9c68c29d7ea3", size = 324969 }, + { url = "https://files.pythonhosted.org/packages/b8/62/bb146d1289d6b3450bccc4642e7f4413b92ebffd9bf2e91b0404323704a7/contourpy-1.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab29962927945d89d9b293eabd0d59aea28d887d4f3be6c22deaefbb938a7277", size = 1265162 }, + { url = "https://files.pythonhosted.org/packages/18/04/9f7d132ce49a212c8e767042cc80ae390f728060d2eea47058f55b9eff1c/contourpy-1.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974d8145f8ca354498005b5b981165b74a195abfae9a8129df3e56771961d595", size = 1324328 }, + { url = "https://files.pythonhosted.org/packages/46/23/196813901be3f97c83ababdab1382e13e0edc0bb4e7b49a7bff15fcf754e/contourpy-1.3.1-cp310-cp310-win32.whl", hash = "sha256:ac4578ac281983f63b400f7fe6c101bedc10651650eef012be1ccffcbacf3697", size = 173861 }, + { url = "https://files.pythonhosted.org/packages/e0/82/c372be3fc000a3b2005061ca623a0d1ecd2eaafb10d9e883a2fc8566e951/contourpy-1.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:174e758c66bbc1c8576992cec9599ce8b6672b741b5d336b5c74e35ac382b18e", size = 218566 }, + { url = "https://files.pythonhosted.org/packages/12/bb/11250d2906ee2e8b466b5f93e6b19d525f3e0254ac8b445b56e618527718/contourpy-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8b974d8db2c5610fb4e76307e265de0edb655ae8169e8b21f41807ccbeec4b", size = 269555 }, + { url = "https://files.pythonhosted.org/packages/67/71/1e6e95aee21a500415f5d2dbf037bf4567529b6a4e986594d7026ec5ae90/contourpy-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:20914c8c973f41456337652a6eeca26d2148aa96dd7ac323b74516988bea89fc", size = 254549 }, + { url = "https://files.pythonhosted.org/packages/31/2c/b88986e8d79ac45efe9d8801ae341525f38e087449b6c2f2e6050468a42c/contourpy-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d40d37c1c3a4961b4619dd9d77b12124a453cc3d02bb31a07d58ef684d3d86", size = 313000 }, + { url = "https://files.pythonhosted.org/packages/c4/18/65280989b151fcf33a8352f992eff71e61b968bef7432fbfde3a364f0730/contourpy-1.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:113231fe3825ebf6f15eaa8bc1f5b0ddc19d42b733345eae0934cb291beb88b6", size = 352925 }, + { url = "https://files.pythonhosted.org/packages/f5/c7/5fd0146c93220dbfe1a2e0f98969293b86ca9bc041d6c90c0e065f4619ad/contourpy-1.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dbbc03a40f916a8420e420d63e96a1258d3d1b58cbdfd8d1f07b49fcbd38e85", size = 323693 }, + { url = "https://files.pythonhosted.org/packages/85/fc/7fa5d17daf77306840a4e84668a48ddff09e6bc09ba4e37e85ffc8e4faa3/contourpy-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a04ecd68acbd77fa2d39723ceca4c3197cb2969633836ced1bea14e219d077c", size = 326184 }, + { url = "https://files.pythonhosted.org/packages/ef/e7/104065c8270c7397c9571620d3ab880558957216f2b5ebb7e040f85eeb22/contourpy-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c414fc1ed8ee1dbd5da626cf3710c6013d3d27456651d156711fa24f24bd1291", size = 1268031 }, + { url = "https://files.pythonhosted.org/packages/e2/4a/c788d0bdbf32c8113c2354493ed291f924d4793c4a2e85b69e737a21a658/contourpy-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:31c1b55c1f34f80557d3830d3dd93ba722ce7e33a0b472cba0ec3b6535684d8f", size = 1325995 }, + { url = "https://files.pythonhosted.org/packages/a6/e6/a2f351a90d955f8b0564caf1ebe4b1451a3f01f83e5e3a414055a5b8bccb/contourpy-1.3.1-cp311-cp311-win32.whl", hash = "sha256:f611e628ef06670df83fce17805c344710ca5cde01edfdc72751311da8585375", size = 174396 }, + { url = "https://files.pythonhosted.org/packages/a8/7e/cd93cab453720a5d6cb75588cc17dcdc08fc3484b9de98b885924ff61900/contourpy-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b2bdca22a27e35f16794cf585832e542123296b4687f9fd96822db6bae17bfc9", size = 219787 }, + { url = "https://files.pythonhosted.org/packages/37/6b/175f60227d3e7f5f1549fcb374592be311293132207e451c3d7c654c25fb/contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509", size = 271494 }, + { url = "https://files.pythonhosted.org/packages/6b/6a/7833cfae2c1e63d1d8875a50fd23371394f540ce809d7383550681a1fa64/contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc", size = 255444 }, + { url = "https://files.pythonhosted.org/packages/7f/b3/7859efce66eaca5c14ba7619791b084ed02d868d76b928ff56890d2d059d/contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454", size = 307628 }, + { url = "https://files.pythonhosted.org/packages/48/b2/011415f5e3f0a50b1e285a0bf78eb5d92a4df000553570f0851b6e309076/contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80", size = 347271 }, + { url = "https://files.pythonhosted.org/packages/84/7d/ef19b1db0f45b151ac78c65127235239a8cf21a59d1ce8507ce03e89a30b/contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec", size = 318906 }, + { url = "https://files.pythonhosted.org/packages/ba/99/6794142b90b853a9155316c8f470d2e4821fe6f086b03e372aca848227dd/contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9", size = 323622 }, + { url = "https://files.pythonhosted.org/packages/3c/0f/37d2c84a900cd8eb54e105f4fa9aebd275e14e266736778bb5dccbf3bbbb/contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b", size = 1266699 }, + { url = "https://files.pythonhosted.org/packages/3a/8a/deb5e11dc7d9cc8f0f9c8b29d4f062203f3af230ba83c30a6b161a6effc9/contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d", size = 1326395 }, + { url = "https://files.pythonhosted.org/packages/1a/35/7e267ae7c13aaf12322ccc493531f1e7f2eb8fba2927b9d7a05ff615df7a/contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e", size = 175354 }, + { url = "https://files.pythonhosted.org/packages/a1/35/c2de8823211d07e8a79ab018ef03960716c5dff6f4d5bff5af87fd682992/contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d", size = 220971 }, + { url = "https://files.pythonhosted.org/packages/9a/e7/de62050dce687c5e96f946a93546910bc67e483fe05324439e329ff36105/contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2", size = 271548 }, + { url = "https://files.pythonhosted.org/packages/78/4d/c2a09ae014ae984c6bdd29c11e74d3121b25eaa117eca0bb76340efd7e1c/contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5", size = 255576 }, + { url = "https://files.pythonhosted.org/packages/ab/8a/915380ee96a5638bda80cd061ccb8e666bfdccea38d5741cb69e6dbd61fc/contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81", size = 306635 }, + { url = "https://files.pythonhosted.org/packages/29/5c/c83ce09375428298acd4e6582aeb68b1e0d1447f877fa993d9bf6cd3b0a0/contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2", size = 345925 }, + { url = "https://files.pythonhosted.org/packages/29/63/5b52f4a15e80c66c8078a641a3bfacd6e07106835682454647aca1afc852/contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7", size = 318000 }, + { url = "https://files.pythonhosted.org/packages/9a/e2/30ca086c692691129849198659bf0556d72a757fe2769eb9620a27169296/contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c", size = 322689 }, + { url = "https://files.pythonhosted.org/packages/6b/77/f37812ef700f1f185d348394debf33f22d531e714cf6a35d13d68a7003c7/contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3", size = 1268413 }, + { url = "https://files.pythonhosted.org/packages/3f/6d/ce84e79cdd128542ebeb268f84abb4b093af78e7f8ec504676673d2675bc/contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1", size = 1326530 }, + { url = "https://files.pythonhosted.org/packages/72/22/8282f4eae20c73c89bee7a82a19c4e27af9b57bb602ecaa00713d5bdb54d/contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82", size = 175315 }, + { url = "https://files.pythonhosted.org/packages/e3/d5/28bca491f65312b438fbf076589dcde7f6f966b196d900777f5811b9c4e2/contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd", size = 220987 }, + { url = "https://files.pythonhosted.org/packages/2f/24/a4b285d6adaaf9746e4700932f579f1a7b6f9681109f694cfa233ae75c4e/contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30", size = 285001 }, + { url = "https://files.pythonhosted.org/packages/48/1d/fb49a401b5ca4f06ccf467cd6c4f1fd65767e63c21322b29b04ec40b40b9/contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751", size = 268553 }, + { url = "https://files.pythonhosted.org/packages/79/1e/4aef9470d13fd029087388fae750dccb49a50c012a6c8d1d634295caa644/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342", size = 310386 }, + { url = "https://files.pythonhosted.org/packages/b0/34/910dc706ed70153b60392b5305c708c9810d425bde12499c9184a1100888/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c", size = 349806 }, + { url = "https://files.pythonhosted.org/packages/31/3c/faee6a40d66d7f2a87f7102236bf4780c57990dd7f98e5ff29881b1b1344/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f", size = 321108 }, + { url = "https://files.pythonhosted.org/packages/17/69/390dc9b20dd4bb20585651d7316cc3054b7d4a7b4f8b710b2b698e08968d/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda", size = 327291 }, + { url = "https://files.pythonhosted.org/packages/ef/74/7030b67c4e941fe1e5424a3d988080e83568030ce0355f7c9fc556455b01/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242", size = 1263752 }, + { url = "https://files.pythonhosted.org/packages/f0/ed/92d86f183a8615f13f6b9cbfc5d4298a509d6ce433432e21da838b4b63f4/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1", size = 1318403 }, + { url = "https://files.pythonhosted.org/packages/b3/0e/c8e4950c77dcfc897c71d61e56690a0a9df39543d2164040301b5df8e67b/contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1", size = 185117 }, + { url = "https://files.pythonhosted.org/packages/c1/31/1ae946f11dfbd229222e6d6ad8e7bd1891d3d48bde5fbf7a0beb9491f8e3/contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546", size = 236668 }, + { url = "https://files.pythonhosted.org/packages/3e/4f/e56862e64b52b55b5ddcff4090085521fc228ceb09a88390a2b103dccd1b/contourpy-1.3.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b457d6430833cee8e4b8e9b6f07aa1c161e5e0d52e118dc102c8f9bd7dd060d6", size = 265605 }, + { url = "https://files.pythonhosted.org/packages/b0/2e/52bfeeaa4541889f23d8eadc6386b442ee2470bd3cff9baa67deb2dd5c57/contourpy-1.3.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb76c1a154b83991a3cbbf0dfeb26ec2833ad56f95540b442c73950af2013750", size = 315040 }, + { url = "https://files.pythonhosted.org/packages/52/94/86bfae441707205634d80392e873295652fc313dfd93c233c52c4dc07874/contourpy-1.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:44a29502ca9c7b5ba389e620d44f2fbe792b1fb5734e8b931ad307071ec58c53", size = 218221 }, +] + +[[package]] +name = "coverage" +version = "7.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/36/465f5492443265e1278f9a82ffe6aeed3f1db779da0d6e7d4611a5cfb6af/coverage-7.7.0.tar.gz", hash = "sha256:cd879d4646055a573775a1cec863d00c9ff8c55860f8b17f6d8eee9140c06166", size = 809969 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/f5/2b801fe88f199707cf9ec66dcee036e7073b5a208a4a161b64371b3f1e35/coverage-7.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a538a23119d1e2e2ce077e902d02ea3d8e0641786ef6e0faf11ce82324743944", size = 210608 }, + { url = "https://files.pythonhosted.org/packages/07/44/bcc030cf977d1069a28742c0a67284c6e831ef172f914055b3d45da83f89/coverage-7.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1586ad158523f4133499a4f322b230e2cfef9cc724820dbd58595a5a236186f4", size = 211042 }, + { url = "https://files.pythonhosted.org/packages/2c/3f/b427f17e1bcf3e1f5ac42fc0b6cb623616f2aedcfc7fde17a058afb62568/coverage-7.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b6c96d69928a3a6767fab8dc1ce8a02cf0156836ccb1e820c7f45a423570d98", size = 240168 }, + { url = "https://files.pythonhosted.org/packages/58/92/6e8d71c5e651f152ffc518ec4cd7add87035533e88af29e233635c0f0dfb/coverage-7.7.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7f18d47641282664276977c604b5a261e51fefc2980f5271d547d706b06a837f", size = 238079 }, + { url = "https://files.pythonhosted.org/packages/40/33/1c25ae35c16972dc379c24cd7dde20359d076dee00687825c92a53e43b02/coverage-7.7.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2a1e18a85bd066c7c556d85277a7adf4651f259b2579113844835ba1a74aafd", size = 239216 }, + { url = "https://files.pythonhosted.org/packages/4d/3d/adf40bdd07a49e1880632c1bc6b31f42d32cf0bfe6b4d294a8f706d70078/coverage-7.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:70f0925c4e2bfc965369f417e7cc72538fd1ba91639cf1e4ef4b1a6b50439b3b", size = 239126 }, + { url = "https://files.pythonhosted.org/packages/72/a5/51e39811cd0ec0569a25fe8e6bac0a00efa222a3e49d51d64f5ba0dce24a/coverage-7.7.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b0fac2088ec4aaeb5468b814bd3ff5e5978364bfbce5e567c44c9e2854469f6c", size = 237842 }, + { url = "https://files.pythonhosted.org/packages/ab/b7/c5796906cd9eed6d258138f1fddc8d6af01b6d07b3c183bac4a9731ac383/coverage-7.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b3e212a894d8ae07fde2ca8b43d666a6d49bbbddb10da0f6a74ca7bd31f20054", size = 238136 }, + { url = "https://files.pythonhosted.org/packages/d7/8a/bd34ea3c602b3ef323a001d375f9b1d663e901079bb26b5f9b8f96fae32b/coverage-7.7.0-cp310-cp310-win32.whl", hash = "sha256:f32b165bf6dfea0846a9c9c38b7e1d68f313956d60a15cde5d1709fddcaf3bee", size = 213320 }, + { url = "https://files.pythonhosted.org/packages/94/60/6e7efe849e305a233623a80aaeba7ebb02809fa63ab8a1e49c4323b8083b/coverage-7.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:a2454b12a3f12cc4698f3508912e6225ec63682e2ca5a96f80a2b93cef9e63f3", size = 214219 }, + { url = "https://files.pythonhosted.org/packages/e8/ec/9e0c9358a3bd56b1ddbf266b889ea9d51ee29e58fb72712d5600663fa806/coverage-7.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a0a207c87a9f743c8072d059b4711f8d13c456eb42dac778a7d2e5d4f3c253a7", size = 210722 }, + { url = "https://files.pythonhosted.org/packages/be/bd/7b47a4302423a13960ee30682900d7ca20cee15c978b1d9ea9594d59d352/coverage-7.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2d673e3add00048215c2cc507f1228a7523fd8bf34f279ac98334c9b07bd2656", size = 211154 }, + { url = "https://files.pythonhosted.org/packages/c6/7c/ae54d9022440196bf9f3fad535388678a3db186980ff58a4956ddeb849a2/coverage-7.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f81fe93dc1b8e5673f33443c0786c14b77e36f1025973b85e07c70353e46882b", size = 243787 }, + { url = "https://files.pythonhosted.org/packages/2d/21/913a2a2d89a2221f4410fbea4ff84e64ddf4367a4b9eb2c328bd01a1a401/coverage-7.7.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d8c7524779003d59948c51b4fcbf1ca4e27c26a7d75984f63488f3625c328b9b", size = 241473 }, + { url = "https://files.pythonhosted.org/packages/40/f1/5ae36fffd542fb86ab3b2d5e012af0840265f3dd001ad0ffabe9e4dbdcf6/coverage-7.7.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c124025430249118d018dcedc8b7426f39373527c845093132196f2a483b6dd", size = 243259 }, + { url = "https://files.pythonhosted.org/packages/47/1b/abc87bad7f606a4df321bd8300413fe13700099a163e7d63453c7c70c1b2/coverage-7.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e7f559c36d5cdc448ee13e7e56ed7b6b5d44a40a511d584d388a0f5d940977ba", size = 242904 }, + { url = "https://files.pythonhosted.org/packages/e0/b3/ff0cf15f5709996727dda2fa00af6f4da92ea3e16168400346f2f742341a/coverage-7.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:37cbc7b0d93dfd133e33c7ec01123fbb90401dce174c3b6661d8d36fb1e30608", size = 241079 }, + { url = "https://files.pythonhosted.org/packages/05/c9/fcad82aad05b1eb8040e6c25ae7a1303716cc05718d4dd326e0fab31aa14/coverage-7.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7d2a65876274acf544703e943c010b60bd79404e3623a1e5d52b64a6e2728de5", size = 241617 }, + { url = "https://files.pythonhosted.org/packages/59/9f/d1efe149afa5c3a459c08bf04f7e6917ef4ee8e3440df5c3e87d6b972870/coverage-7.7.0-cp311-cp311-win32.whl", hash = "sha256:f5a2f71d6a91238e7628f23538c26aa464d390cbdedf12ee2a7a0fb92a24482a", size = 213372 }, + { url = "https://files.pythonhosted.org/packages/88/d2/4b58f03e399185b01fb3168d4b870882de9c7a10e273f99c8f25ec690302/coverage-7.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:ae8006772c6b0fa53c33747913473e064985dac4d65f77fd2fdc6474e7cd54e4", size = 214285 }, + { url = "https://files.pythonhosted.org/packages/b7/47/f7b870caa26082ff8033be074ac61dc175a6b0c965adf7b910f92a6d7cfe/coverage-7.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:056d3017ed67e7ddf266e6f57378ece543755a4c9231e997789ab3bd11392c94", size = 210907 }, + { url = "https://files.pythonhosted.org/packages/ea/eb/40b39bdc6c1da403257f0fcb2c1b2fd81ff9f66c13abbe3862f42780e1c1/coverage-7.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:33c1394d8407e2771547583b66a85d07ed441ff8fae5a4adb4237ad39ece60db", size = 211162 }, + { url = "https://files.pythonhosted.org/packages/53/08/42a2db41b4646d6261122773e222dd7105e2306526f2d7846de6fee808ec/coverage-7.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fbb7a0c3c21908520149d7751cf5b74eb9b38b54d62997b1e9b3ac19a8ee2fe", size = 245223 }, + { url = "https://files.pythonhosted.org/packages/78/2a/0ceb328a7e67e8639d5c7800b8161d4b5f489073ac8d5ac33b11eadee218/coverage-7.7.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bb356e7ae7c2da13f404bf8f75be90f743c6df8d4607022e759f5d7d89fe83f8", size = 242114 }, + { url = "https://files.pythonhosted.org/packages/ba/68/42b13b849d40af1581830ff06c60f4ec84649764f4a58d5c6e20ae11cbd4/coverage-7.7.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bce730d484038e97f27ea2dbe5d392ec5c2261f28c319a3bb266f6b213650135", size = 244371 }, + { url = "https://files.pythonhosted.org/packages/68/66/ab7c3b9fdbeb8bdd322f5b67b1886463834dba2014a534caba60fb0075ea/coverage-7.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aa4dff57fc21a575672176d5ab0ef15a927199e775c5e8a3d75162ab2b0c7705", size = 244134 }, + { url = "https://files.pythonhosted.org/packages/01/74/b833d299a479681957d6b238e16a0725586e1d56ec1e43658f3184550bb0/coverage-7.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b667b91f4f714b17af2a18e220015c941d1cf8b07c17f2160033dbe1e64149f0", size = 242353 }, + { url = "https://files.pythonhosted.org/packages/f9/c5/0ed656d65da39bbab8e8fc367dc3d465a7501fea0f2b1caccfb4f6361c9f/coverage-7.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:693d921621a0c8043bfdc61f7d4df5ea6d22165fe8b807cac21eb80dd94e4bbd", size = 243543 }, + { url = "https://files.pythonhosted.org/packages/87/b5/142bcff3828e4cce5d4c9ddc9222de1664464263acca09638e4eb0dbda7c/coverage-7.7.0-cp312-cp312-win32.whl", hash = "sha256:52fc89602cde411a4196c8c6894afb384f2125f34c031774f82a4f2608c59d7d", size = 213543 }, + { url = "https://files.pythonhosted.org/packages/29/74/99d226985def03284bad6a9aff27a1079a8881ec7523b5980b00a5260527/coverage-7.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:0ce8cf59e09d31a4915ff4c3b94c6514af4c84b22c4cc8ad7c3c546a86150a92", size = 214344 }, + { url = "https://files.pythonhosted.org/packages/45/2f/df6235ec963b9eb6b6b2f3c24f70448f1ffa13b9a481c155a6caff176395/coverage-7.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4545485fef7a8a2d8f30e6f79ce719eb154aab7e44217eb444c1d38239af2072", size = 210934 }, + { url = "https://files.pythonhosted.org/packages/f3/85/ff19510bf642e334845318ddb73a550d2b17082831fa9ae053ce72288be7/coverage-7.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1393e5aa9441dafb0162c36c8506c648b89aea9565b31f6bfa351e66c11bcd82", size = 211212 }, + { url = "https://files.pythonhosted.org/packages/2d/6a/af6582a419550d35eacc3e1bf9f4a936dda0ae559632a0bc4e3aef694ac8/coverage-7.7.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:316f29cc3392fa3912493ee4c83afa4a0e2db04ff69600711f8c03997c39baaa", size = 244727 }, + { url = "https://files.pythonhosted.org/packages/55/62/7c49526111c91f3d7d27e111c22c8d08722f5b661c3f031b625b4d7bc4d9/coverage-7.7.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1ffde1d6bc2a92f9c9207d1ad808550873748ac2d4d923c815b866baa343b3f", size = 241768 }, + { url = "https://files.pythonhosted.org/packages/62/4b/2dc27700782be9795cbbbe98394dd19ef74815d78d5027ed894972cd1b4a/coverage-7.7.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:416e2a8845eaff288f97eaf76ab40367deafb9073ffc47bf2a583f26b05e5265", size = 243790 }, + { url = "https://files.pythonhosted.org/packages/d3/11/9cc1ae56d3015edca69437f3121c2b44de309f6828980b29e4cc9b13246d/coverage-7.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5efdeff5f353ed3352c04e6b318ab05c6ce9249c25ed3c2090c6e9cadda1e3b2", size = 243861 }, + { url = "https://files.pythonhosted.org/packages/db/e4/2398ed93edcf42ff43002d91c37be11514d825cec382606654fd44f4b8fa/coverage-7.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:57f3bd0d29bf2bd9325c0ff9cc532a175110c4bf8f412c05b2405fd35745266d", size = 241942 }, + { url = "https://files.pythonhosted.org/packages/ec/fe/b6bd35b17a2b8d26bdb21d5ea4351a837ec01edf552655e833629af05b90/coverage-7.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ab7090f04b12dc6469882ce81244572779d3a4b67eea1c96fb9ecc8c607ef39", size = 243228 }, + { url = "https://files.pythonhosted.org/packages/6d/06/d8701bae1e5d865edeb00a6c2a71bd7659ca6af349789271c6fd16a57909/coverage-7.7.0-cp313-cp313-win32.whl", hash = "sha256:180e3fc68ee4dc5af8b33b6ca4e3bb8aa1abe25eedcb958ba5cff7123071af68", size = 213572 }, + { url = "https://files.pythonhosted.org/packages/d7/c1/7e67780bfcaed6bed20100c9e1b2645e3414577b4bdad169578325249045/coverage-7.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:55143aa13c49491f5606f05b49ed88663446dce3a4d3c5d77baa4e36a16d3573", size = 214372 }, + { url = "https://files.pythonhosted.org/packages/ed/25/50b0447442a415ad3da33093c589d9ef945dd6933225f1ce0ac97476397e/coverage-7.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:cc41374d2f27d81d6558f8a24e5c114580ffefc197fd43eabd7058182f743322", size = 211774 }, + { url = "https://files.pythonhosted.org/packages/13/cc/3daddc707e934d3c0aafaa4a9b217f53fcf4133d4e40cc6ae63aa51243b8/coverage-7.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:89078312f06237417adda7c021c33f80f7a6d2db8572a5f6c330d89b080061ce", size = 211995 }, + { url = "https://files.pythonhosted.org/packages/98/99/c92f43355d3d67f6bf8c946a350f2174e18f9ea7c8a1e36c9eb84ab7d20b/coverage-7.7.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b2f144444879363ea8834cd7b6869d79ac796cb8f864b0cfdde50296cd95816", size = 256226 }, + { url = "https://files.pythonhosted.org/packages/25/62/65f0f33c08e0a1632f1e487b9c2d252e8bad6a77a942836043972b0ba6d2/coverage-7.7.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:60e6347d1ed882b1159ffea172cb8466ee46c665af4ca397edbf10ff53e9ffaf", size = 251937 }, + { url = "https://files.pythonhosted.org/packages/b2/10/99a9565aaeb159aade178c6509c8324a9c9e825b01f02242a37c2a8869f8/coverage-7.7.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb203c0afffaf1a8f5b9659a013f8f16a1b2cad3a80a8733ceedc968c0cf4c57", size = 254276 }, + { url = "https://files.pythonhosted.org/packages/a7/12/206196edbf0b82250b11bf5c252fe25ebaa2b7c8d66edb0c194e7b3403fe/coverage-7.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ad0edaa97cb983d9f2ff48cadddc3e1fb09f24aa558abeb4dc9a0dbacd12cbb4", size = 255366 }, + { url = "https://files.pythonhosted.org/packages/a5/82/a2abb8d4cdd99c6a443ab6682c0eee5797490a2113a45ffaa8b6b31c5dcc/coverage-7.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:c5f8a5364fc37b2f172c26a038bc7ec4885f429de4a05fc10fdcb53fb5834c5c", size = 253536 }, + { url = "https://files.pythonhosted.org/packages/4d/7d/3747e000e60ad5dd8157bd978f99979967d56cb35c55235980c85305db86/coverage-7.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4e09534037933bf6eb31d804e72c52ec23219b32c1730f9152feabbd7499463", size = 254344 }, + { url = "https://files.pythonhosted.org/packages/45/56/7c33f8a6de1b3b079374d2ae490ccf76fb7c094a23f72d10f071989fc3ef/coverage-7.7.0-cp313-cp313t-win32.whl", hash = "sha256:1b336d06af14f8da5b1f391e8dec03634daf54dfcb4d1c4fb6d04c09d83cef90", size = 214284 }, + { url = "https://files.pythonhosted.org/packages/95/ab/657bfa6171800a67bd1c005402f06d6b78610820ef1364ea4f85b04bbb5b/coverage-7.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b54a1ee4c6f1905a436cbaa04b26626d27925a41cbc3a337e2d3ff7038187f07", size = 215445 }, + { url = "https://files.pythonhosted.org/packages/cb/69/6a5eac32d2e8721274ef75df1b9fd6a8f7e8231e41ff7bc5501f19835f25/coverage-7.7.0-pp39.pp310.pp311-none-any.whl", hash = "sha256:3b0e6e54591ae0d7427def8a4d40fca99df6b899d10354bab73cd5609807261c", size = 202813 }, + { url = "https://files.pythonhosted.org/packages/2a/ac/60f409a448e5b0e9b8539716f683568aa5848c1be903cdbbc805a552cdf8/coverage-7.7.0-py3-none-any.whl", hash = "sha256:708f0a1105ef2b11c79ed54ed31f17e6325ac936501fc373f24be3e6a578146a", size = 202803 }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11'" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 }, +] + +[[package]] +name = "debugpy" +version = "1.8.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/d4/f35f539e11c9344652f362c22413ec5078f677ac71229dc9b4f6f85ccaa3/debugpy-1.8.13.tar.gz", hash = "sha256:837e7bef95bdefba426ae38b9a94821ebdc5bea55627879cd48165c90b9e50ce", size = 1641193 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/32/901c7204cceb3262fdf38f4c25c9a46372c11661e8490e9ea702bc4ff448/debugpy-1.8.13-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:06859f68e817966723ffe046b896b1bd75c665996a77313370336ee9e1de3e90", size = 2076250 }, + { url = "https://files.pythonhosted.org/packages/95/10/77fe746851c8d84838a807da60c7bd0ac8627a6107d6917dd3293bf8628c/debugpy-1.8.13-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb56c2db69fb8df3168bc857d7b7d2494fed295dfdbde9a45f27b4b152f37520", size = 3560883 }, + { url = "https://files.pythonhosted.org/packages/a1/ef/28f8db2070e453dda0e49b356e339d0b4e1d38058d4c4ea9e88cdc8ee8e7/debugpy-1.8.13-cp310-cp310-win32.whl", hash = "sha256:46abe0b821cad751fc1fb9f860fb2e68d75e2c5d360986d0136cd1db8cad4428", size = 5180149 }, + { url = "https://files.pythonhosted.org/packages/89/16/1d53a80caf5862627d3eaffb217d4079d7e4a1df6729a2d5153733661efd/debugpy-1.8.13-cp310-cp310-win_amd64.whl", hash = "sha256:dc7b77f5d32674686a5f06955e4b18c0e41fb5a605f5b33cf225790f114cfeec", size = 5212540 }, + { url = "https://files.pythonhosted.org/packages/31/90/dd2fcad8364f0964f476537481985198ce6e879760281ad1cec289f1aa71/debugpy-1.8.13-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:eee02b2ed52a563126c97bf04194af48f2fe1f68bb522a312b05935798e922ff", size = 2174802 }, + { url = "https://files.pythonhosted.org/packages/5c/c9/06ff65f15eb30dbdafd45d1575770b842ce3869ad5580a77f4e5590f1be7/debugpy-1.8.13-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4caca674206e97c85c034c1efab4483f33971d4e02e73081265ecb612af65377", size = 3133620 }, + { url = "https://files.pythonhosted.org/packages/3b/49/798a4092bde16a4650f17ac5f2301d4d37e1972d65462fb25c80a83b4790/debugpy-1.8.13-cp311-cp311-win32.whl", hash = "sha256:7d9a05efc6973b5aaf076d779cf3a6bbb1199e059a17738a2aa9d27a53bcc888", size = 5104764 }, + { url = "https://files.pythonhosted.org/packages/cd/d5/3684d7561c8ba2797305cf8259619acccb8d6ebe2117bb33a6897c235eee/debugpy-1.8.13-cp311-cp311-win_amd64.whl", hash = "sha256:62f9b4a861c256f37e163ada8cf5a81f4c8d5148fc17ee31fb46813bd658cdcc", size = 5129670 }, + { url = "https://files.pythonhosted.org/packages/79/ad/dff929b6b5403feaab0af0e5bb460fd723f9c62538b718a9af819b8fff20/debugpy-1.8.13-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:2b8de94c5c78aa0d0ed79023eb27c7c56a64c68217d881bee2ffbcb13951d0c1", size = 2501004 }, + { url = "https://files.pythonhosted.org/packages/d6/4f/b7d42e6679f0bb525888c278b0c0d2b6dff26ed42795230bb46eaae4f9b3/debugpy-1.8.13-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:887d54276cefbe7290a754424b077e41efa405a3e07122d8897de54709dbe522", size = 4222346 }, + { url = "https://files.pythonhosted.org/packages/ec/18/d9b3e88e85d41f68f77235112adc31012a784e45a3fcdbb039777d570a0f/debugpy-1.8.13-cp312-cp312-win32.whl", hash = "sha256:3872ce5453b17837ef47fb9f3edc25085ff998ce63543f45ba7af41e7f7d370f", size = 5226639 }, + { url = "https://files.pythonhosted.org/packages/c9/f7/0df18a4f530ed3cc06f0060f548efe9e3316102101e311739d906f5650be/debugpy-1.8.13-cp312-cp312-win_amd64.whl", hash = "sha256:63ca7670563c320503fea26ac688988d9d6b9c6a12abc8a8cf2e7dd8e5f6b6ea", size = 5268735 }, + { url = "https://files.pythonhosted.org/packages/b1/db/ae7cd645c1826aae557cebccbc448f0cc9a818d364efb88f8d80e7a03f41/debugpy-1.8.13-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:31abc9618be4edad0b3e3a85277bc9ab51a2d9f708ead0d99ffb5bb750e18503", size = 2485416 }, + { url = "https://files.pythonhosted.org/packages/ec/ed/db4b10ff3b5bb30fe41d9e86444a08bb6448e4d8265e7768450b8408dd36/debugpy-1.8.13-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0bd87557f97bced5513a74088af0b84982b6ccb2e254b9312e29e8a5c4270eb", size = 4218784 }, + { url = "https://files.pythonhosted.org/packages/82/82/ed81852a8d94086f51664d032d83c7f87cd2b087c6ea70dabec7c1ba813d/debugpy-1.8.13-cp313-cp313-win32.whl", hash = "sha256:5268ae7fdca75f526d04465931cb0bd24577477ff50e8bb03dab90983f4ebd02", size = 5226270 }, + { url = "https://files.pythonhosted.org/packages/15/63/aa92fb341a78ec40f1c414ec7a7885c2ee17032eee00d12cee0cdc502af4/debugpy-1.8.13-cp313-cp313-win_amd64.whl", hash = "sha256:79ce4ed40966c4c1631d0131606b055a5a2f8e430e3f7bf8fd3744b09943e8e8", size = 5268621 }, + { url = "https://files.pythonhosted.org/packages/37/4f/0b65410a08b6452bfd3f7ed6f3610f1a31fb127f46836e82d31797065dcb/debugpy-1.8.13-py2.py3-none-any.whl", hash = "sha256:d4ba115cdd0e3a70942bd562adba9ec8c651fe69ddde2298a1be296fc331906f", size = 5229306 }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604 }, +] + +[[package]] +name = "docutils" +version = "0.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408 }, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, +] + +[[package]] +name = "executing" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924 }, +] + +[[package]] +name = "fonttools" +version = "4.56.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/8c/9ffa2a555af0e5e5d0e2ed7fdd8c9bef474ed676995bb4c57c9cd0014248/fonttools-4.56.0.tar.gz", hash = "sha256:a114d1567e1a1586b7e9e7fc2ff686ca542a82769a296cef131e4c4af51e58f4", size = 3462892 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/5e/6ac30c2cc6a29454260f13c9c6422fc509b7982c13cd4597041260d8f482/fonttools-4.56.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:331954d002dbf5e704c7f3756028e21db07097c19722569983ba4d74df014000", size = 2752190 }, + { url = "https://files.pythonhosted.org/packages/92/3a/ac382a8396d1b420ee45eeb0f65b614a9ca7abbb23a1b17524054f0f2200/fonttools-4.56.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8d1613abd5af2f93c05867b3a3759a56e8bf97eb79b1da76b2bc10892f96ff16", size = 2280624 }, + { url = "https://files.pythonhosted.org/packages/8a/ae/00b58bfe20e9ff7fbc3dda38f5d127913942b5e252288ea9583099a31bf5/fonttools-4.56.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:705837eae384fe21cee5e5746fd4f4b2f06f87544fa60f60740007e0aa600311", size = 4562074 }, + { url = "https://files.pythonhosted.org/packages/46/d0/0004ca8f6a200252e5bd6982ed99b5fe58c4c59efaf5f516621c4cd8f703/fonttools-4.56.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc871904a53a9d4d908673c6faa15689874af1c7c5ac403a8e12d967ebd0c0dc", size = 4604747 }, + { url = "https://files.pythonhosted.org/packages/45/ea/c8862bd3e09d143ef8ed8268ec8a7d477828f960954889e65288ac050b08/fonttools-4.56.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:38b947de71748bab150259ee05a775e8a0635891568e9fdb3cdd7d0e0004e62f", size = 4559025 }, + { url = "https://files.pythonhosted.org/packages/8f/75/bb88a9552ec1de31a414066257bfd9f40f4ada00074f7a3799ea39b5741f/fonttools-4.56.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:86b2a1013ef7a64d2e94606632683f07712045ed86d937c11ef4dde97319c086", size = 4728482 }, + { url = "https://files.pythonhosted.org/packages/2a/5f/80a2b640df1e1bb7d459d62c8b3f37fe83fd413897e549106d4ebe6371f5/fonttools-4.56.0-cp310-cp310-win32.whl", hash = "sha256:133bedb9a5c6376ad43e6518b7e2cd2f866a05b1998f14842631d5feb36b5786", size = 2155557 }, + { url = "https://files.pythonhosted.org/packages/8f/85/0904f9dbe51ac70d878d3242a8583b9453a09105c3ed19c6301247fd0d3a/fonttools-4.56.0-cp310-cp310-win_amd64.whl", hash = "sha256:17f39313b649037f6c800209984a11fc256a6137cbe5487091c6c7187cae4685", size = 2200017 }, + { url = "https://files.pythonhosted.org/packages/35/56/a2f3e777d48fcae7ecd29de4d96352d84e5ea9871e5f3fc88241521572cf/fonttools-4.56.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ef04bc7827adb7532be3d14462390dd71287644516af3f1e67f1e6ff9c6d6df", size = 2753325 }, + { url = "https://files.pythonhosted.org/packages/71/85/d483e9c4e5ed586b183bf037a353e8d766366b54fd15519b30e6178a6a6e/fonttools-4.56.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ffda9b8cd9cb8b301cae2602ec62375b59e2e2108a117746f12215145e3f786c", size = 2281554 }, + { url = "https://files.pythonhosted.org/packages/09/67/060473b832b2fade03c127019794df6dc02d9bc66fa4210b8e0d8a99d1e5/fonttools-4.56.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e993e8db36306cc3f1734edc8ea67906c55f98683d6fd34c3fc5593fdbba4c", size = 4869260 }, + { url = "https://files.pythonhosted.org/packages/28/e9/47c02d5a7027e8ed841ab6a10ca00c93dadd5f16742f1af1fa3f9978adf4/fonttools-4.56.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:003548eadd674175510773f73fb2060bb46adb77c94854af3e0cc5bc70260049", size = 4898508 }, + { url = "https://files.pythonhosted.org/packages/bf/8a/221d456d1afb8ca043cfd078f59f187ee5d0a580f4b49351b9ce95121f57/fonttools-4.56.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd9825822e7bb243f285013e653f6741954d8147427aaa0324a862cdbf4cbf62", size = 4877700 }, + { url = "https://files.pythonhosted.org/packages/a4/8c/e503863adf7a6aeff7b960e2f66fa44dd0c29a7a8b79765b2821950d7b05/fonttools-4.56.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b23d30a2c0b992fb1c4f8ac9bfde44b5586d23457759b6cf9a787f1a35179ee0", size = 5045817 }, + { url = "https://files.pythonhosted.org/packages/2b/50/79ba3b7e42f4eaa70b82b9e79155f0f6797858dc8a97862428b6852c6aee/fonttools-4.56.0-cp311-cp311-win32.whl", hash = "sha256:47b5e4680002ae1756d3ae3b6114e20aaee6cc5c69d1e5911f5ffffd3ee46c6b", size = 2154426 }, + { url = "https://files.pythonhosted.org/packages/3b/90/4926e653041c4116ecd43e50e3c79f5daae6dcafc58ceb64bc4f71dd4924/fonttools-4.56.0-cp311-cp311-win_amd64.whl", hash = "sha256:14a3e3e6b211660db54ca1ef7006401e4a694e53ffd4553ab9bc87ead01d0f05", size = 2200937 }, + { url = "https://files.pythonhosted.org/packages/39/32/71cfd6877999576a11824a7fe7bc0bb57c5c72b1f4536fa56a3e39552643/fonttools-4.56.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6f195c14c01bd057bc9b4f70756b510e009c83c5ea67b25ced3e2c38e6ee6e9", size = 2747757 }, + { url = "https://files.pythonhosted.org/packages/15/52/d9f716b072c5061a0b915dd4c387f74bef44c68c069e2195c753905bd9b7/fonttools-4.56.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa760e5fe8b50cbc2d71884a1eff2ed2b95a005f02dda2fa431560db0ddd927f", size = 2279007 }, + { url = "https://files.pythonhosted.org/packages/d1/97/f1b3a8afa9a0d814a092a25cd42f59ccb98a0bb7a295e6e02fc9ba744214/fonttools-4.56.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d54a45d30251f1d729e69e5b675f9a08b7da413391a1227781e2a297fa37f6d2", size = 4783991 }, + { url = "https://files.pythonhosted.org/packages/95/70/2a781bedc1c45a0c61d29c56425609b22ed7f971da5d7e5df2679488741b/fonttools-4.56.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:661a8995d11e6e4914a44ca7d52d1286e2d9b154f685a4d1f69add8418961563", size = 4855109 }, + { url = "https://files.pythonhosted.org/packages/0c/02/a2597858e61a5e3fb6a14d5f6be9e6eb4eaf090da56ad70cedcbdd201685/fonttools-4.56.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9d94449ad0a5f2a8bf5d2f8d71d65088aee48adbe45f3c5f8e00e3ad861ed81a", size = 4762496 }, + { url = "https://files.pythonhosted.org/packages/f2/00/aaf00100d6078fdc73f7352b44589804af9dc12b182a2540b16002152ba4/fonttools-4.56.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f59746f7953f69cc3290ce2f971ab01056e55ddd0fb8b792c31a8acd7fee2d28", size = 4990094 }, + { url = "https://files.pythonhosted.org/packages/bf/dc/3ff1db522460db60cf3adaf1b64e0c72b43406717d139786d3fa1eb20709/fonttools-4.56.0-cp312-cp312-win32.whl", hash = "sha256:bce60f9a977c9d3d51de475af3f3581d9b36952e1f8fc19a1f2254f1dda7ce9c", size = 2142888 }, + { url = "https://files.pythonhosted.org/packages/6f/e3/5a181a85777f7809076e51f7422e0dc77eb04676c40ec8bf6a49d390d1ff/fonttools-4.56.0-cp312-cp312-win_amd64.whl", hash = "sha256:300c310bb725b2bdb4f5fc7e148e190bd69f01925c7ab437b9c0ca3e1c7cd9ba", size = 2189734 }, + { url = "https://files.pythonhosted.org/packages/a5/55/f06b48d48e0b4ec3a3489efafe9bd4d81b6e0802ac51026e3ee4634e89ba/fonttools-4.56.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f20e2c0dfab82983a90f3d00703ac0960412036153e5023eed2b4641d7d5e692", size = 2735127 }, + { url = "https://files.pythonhosted.org/packages/59/db/d2c7c9b6dd5cbd46f183e650a47403ffb88fca17484eb7c4b1cd88f9e513/fonttools-4.56.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f36a0868f47b7566237640c026c65a86d09a3d9ca5df1cd039e30a1da73098a0", size = 2272519 }, + { url = "https://files.pythonhosted.org/packages/4d/a2/da62d779c34a0e0c06415f02eab7fa3466de5d46df459c0275a255cefc65/fonttools-4.56.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62b4c6802fa28e14dba010e75190e0e6228513573f1eeae57b11aa1a39b7e5b1", size = 4762423 }, + { url = "https://files.pythonhosted.org/packages/be/6a/fd4018e0448c8a5e12138906411282c5eab51a598493f080a9f0960e658f/fonttools-4.56.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a05d1f07eb0a7d755fbe01fee1fd255c3a4d3730130cf1bfefb682d18fd2fcea", size = 4834442 }, + { url = "https://files.pythonhosted.org/packages/6d/63/fa1dec8efb35bc11ef9c39b2d74754b45d48a3ccb2cf78c0109c0af639e8/fonttools-4.56.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0073b62c3438cf0058488c002ea90489e8801d3a7af5ce5f7c05c105bee815c3", size = 4742800 }, + { url = "https://files.pythonhosted.org/packages/dd/f4/963247ae8c73ccc4cf2929e7162f595c81dbe17997d1d0ea77da24a217c9/fonttools-4.56.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e2cad98c94833465bcf28f51c248aaf07ca022efc6a3eba750ad9c1e0256d278", size = 4963746 }, + { url = "https://files.pythonhosted.org/packages/ea/e0/46f9600c39c644b54e4420f941f75fa200d9288c9ae171e5d80918b8cbb9/fonttools-4.56.0-cp313-cp313-win32.whl", hash = "sha256:d0cb73ccf7f6d7ca8d0bc7ea8ac0a5b84969a41c56ac3ac3422a24df2680546f", size = 2140927 }, + { url = "https://files.pythonhosted.org/packages/27/6d/3edda54f98a550a0473f032d8050315fbc8f1b76a0d9f3879b72ebb2cdd6/fonttools-4.56.0-cp313-cp313-win_amd64.whl", hash = "sha256:62cc1253827d1e500fde9dbe981219fea4eb000fd63402283472d38e7d8aa1c6", size = 2186709 }, + { url = "https://files.pythonhosted.org/packages/bf/ff/44934a031ce5a39125415eb405b9efb76fe7f9586b75291d66ae5cbfc4e6/fonttools-4.56.0-py3-none-any.whl", hash = "sha256:1088182f68c303b50ca4dc0c82d42083d176cba37af1937e1a976a31149d4d14", size = 1089800 }, +] + +[[package]] +name = "griffe" +version = "1.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/f2/b00eb72b853ecb5bf31dd47857cdf6767e380ca24ec2910d43b3fa7cc500/griffe-1.6.2.tar.gz", hash = "sha256:3a46fa7bd83280909b63c12b9a975732a927dd97809efe5b7972290b606c5d91", size = 392836 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/bc/bd8b7de5e748e078b6be648e76b47189a9182b1ac1eb7791ff7969f39f27/griffe-1.6.2-py3-none-any.whl", hash = "sha256:6399f7e663150e4278a312a8e8a14d2f3d7bd86e2ef2f8056a1058e38579c2ee", size = 128638 }, +] + +[[package]] +name = "hypothesis" +version = "6.129.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "sortedcontainers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/98/0051e770d36f7e0a55bcfa3590790448d57ed2f355da9adbb957b1f545d9/hypothesis-6.129.4.tar.gz", hash = "sha256:e9fd66c25b8f0aa6395ce6728360892c3af22529cc16cae7512a4672776d4781", size = 425235 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/7c/7266143385cbd19c839f9b61cc660d74c5ce2626fea41d8b215ccc5cfba3/hypothesis-6.129.4-py3-none-any.whl", hash = "sha256:45a31fe2b936688b2954f375c7f87e9dfefa4f2cddfa31cdeba15d77600e1286", size = 489542 }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769 }, +] + +[[package]] +name = "importlib-metadata" +version = "8.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 }, +] + +[[package]] +name = "importlib-resources" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461 }, +] + +[[package]] +name = "iniconfig" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 }, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython", version = "8.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/5c/67594cb0c7055dc50814b21731c22a601101ea3b1b50a9a1b090e11f5d0f/ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215", size = 163367 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/5c/368ae6c01c7628438358e6d337c19b05425727fbb221d2a3c4303c372f42/ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5", size = 117173 }, +] + +[[package]] +name = "ipython" +version = "8.34.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version < '3.11'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "jedi", marker = "python_full_version < '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version < '3.11'" }, + { name = "pexpect", marker = "python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version < '3.11'" }, + { name = "pygments", marker = "python_full_version < '3.11'" }, + { name = "stack-data", marker = "python_full_version < '3.11'" }, + { name = "traitlets", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/13/18/1a60aa62e9d272fcd7e658a89e1c148da10e1a5d38edcbcd834b52ca7492/ipython-8.34.0.tar.gz", hash = "sha256:c31d658e754673ecc6514583e7dda8069e47136eb62458816b7d1e6625948b5a", size = 5508477 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/78/45615356bb973904856808183ae2a5fba1f360e9d682314d79766f4b88f2/ipython-8.34.0-py3-none-any.whl", hash = "sha256:0419883fa46e0baa182c5d50ebb8d6b49df1889fdb70750ad6d8cfe678eda6e3", size = 826731 }, +] + +[[package]] +name = "ipython" +version = "9.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version >= '3.11'" }, + { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" }, + { name = "jedi", marker = "python_full_version >= '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version >= '3.11'" }, + { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version >= '3.11'" }, + { name = "pygments", marker = "python_full_version >= '3.11'" }, + { name = "stack-data", marker = "python_full_version >= '3.11'" }, + { name = "traitlets", marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions", marker = "python_full_version == '3.11.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/ce/012a0f40ca58a966f87a6e894d6828e2817657cbdf522b02a5d3a87d92ce/ipython-9.0.2.tar.gz", hash = "sha256:ec7b479e3e5656bf4f58c652c120494df1820f4f28f522fb7ca09e213c2aab52", size = 4366102 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/3a/917cb9e72f4e1a4ea13c862533205ae1319bd664119189ee5cc9e4e95ebf/ipython-9.0.2-py3-none-any.whl", hash = "sha256:143ef3ea6fb1e1bffb4c74b114051de653ffb7737a3f7ab1670e657ca6ae8c44", size = 600524 }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074 }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 }, +] + +[[package]] +name = "jsonschema" +version = "4.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4", size = 325778 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462 }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2024.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/10/db/58f950c996c793472e336ff3655b13fbcf1e3b359dcf52dcf3ed3b52c352/jsonschema_specifications-2024.10.1.tar.gz", hash = "sha256:0f38b83639958ce1152d02a7f062902c41c8fd20d558b0c34344292d417ae272", size = 15561 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/0f/8910b19ac0670a0f80ce1008e5e751c4a57e14d2c4c13a482aa6079fa9d6/jsonschema_specifications-2024.10.1-py3-none-any.whl", hash = "sha256:a09a0680616357d9a0ecf05c12ad234479f549239d0f5b55f3deea67475da9bf", size = 18459 }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105 }, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/11/b56381fa6c3f4cc5d2cf54a7dbf98ad9aa0b339ef7a601d6053538b079a7/jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9", size = 87629 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/fb/108ecd1fe961941959ad0ee4e12ee7b8b1477247f30b1fdfd83ceaf017f0/jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409", size = 28965 }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884 }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/5f/4d8e9e852d98ecd26cdf8eaf7ed8bc33174033bba5e07001b289f07308fd/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db", size = 124623 }, + { url = "https://files.pythonhosted.org/packages/1d/70/7f5af2a18a76fe92ea14675f8bd88ce53ee79e37900fa5f1a1d8e0b42998/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b", size = 66720 }, + { url = "https://files.pythonhosted.org/packages/c6/13/e15f804a142353aefd089fadc8f1d985561a15358c97aca27b0979cb0785/kiwisolver-1.4.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce2cf1e5688edcb727fdf7cd1bbd0b6416758996826a8be1d958f91880d0809d", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/ce/6d/67d36c4d2054e83fb875c6b59d0809d5c530de8148846b1370475eeeece9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c8bf637892dc6e6aad2bc6d4d69d08764166e5e3f69d469e55427b6ac001b19d", size = 1650826 }, + { url = "https://files.pythonhosted.org/packages/de/c6/7b9bb8044e150d4d1558423a1568e4f227193662a02231064e3824f37e0a/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:034d2c891f76bd3edbdb3ea11140d8510dca675443da7304205a2eaa45d8334c", size = 1628231 }, + { url = "https://files.pythonhosted.org/packages/b6/38/ad10d437563063eaaedbe2c3540a71101fc7fb07a7e71f855e93ea4de605/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47b28d1dfe0793d5e96bce90835e17edf9a499b53969b03c6c47ea5985844c3", size = 1408938 }, + { url = "https://files.pythonhosted.org/packages/52/ce/c0106b3bd7f9e665c5f5bc1e07cc95b5dabd4e08e3dad42dbe2faad467e7/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb158fe28ca0c29f2260cca8c43005329ad58452c36f0edf298204de32a9a3ed", size = 1422799 }, + { url = "https://files.pythonhosted.org/packages/d0/87/efb704b1d75dc9758087ba374c0f23d3254505edaedd09cf9d247f7878b9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5536185fce131780ebd809f8e623bf4030ce1b161353166c49a3c74c287897f", size = 1354362 }, + { url = "https://files.pythonhosted.org/packages/eb/b3/fd760dc214ec9a8f208b99e42e8f0130ff4b384eca8b29dd0efc62052176/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:369b75d40abedc1da2c1f4de13f3482cb99e3237b38726710f4a793432b1c5ff", size = 2222695 }, + { url = "https://files.pythonhosted.org/packages/a2/09/a27fb36cca3fc01700687cc45dae7a6a5f8eeb5f657b9f710f788748e10d/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:641f2ddf9358c80faa22e22eb4c9f54bd3f0e442e038728f500e3b978d00aa7d", size = 2370802 }, + { url = "https://files.pythonhosted.org/packages/3d/c3/ba0a0346db35fe4dc1f2f2cf8b99362fbb922d7562e5f911f7ce7a7b60fa/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d561d2d8883e0819445cfe58d7ddd673e4015c3c57261d7bdcd3710d0d14005c", size = 2334646 }, + { url = "https://files.pythonhosted.org/packages/41/52/942cf69e562f5ed253ac67d5c92a693745f0bed3c81f49fc0cbebe4d6b00/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1732e065704b47c9afca7ffa272f845300a4eb959276bf6970dc07265e73b605", size = 2467260 }, + { url = "https://files.pythonhosted.org/packages/32/26/2d9668f30d8a494b0411d4d7d4ea1345ba12deb6a75274d58dd6ea01e951/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bcb1ebc3547619c3b58a39e2448af089ea2ef44b37988caf432447374941574e", size = 2288633 }, + { url = "https://files.pythonhosted.org/packages/98/99/0dd05071654aa44fe5d5e350729961e7bb535372935a45ac89a8924316e6/kiwisolver-1.4.8-cp310-cp310-win_amd64.whl", hash = "sha256:89c107041f7b27844179ea9c85d6da275aa55ecf28413e87624d033cf1f6b751", size = 71885 }, + { url = "https://files.pythonhosted.org/packages/6c/fc/822e532262a97442989335394d441cd1d0448c2e46d26d3e04efca84df22/kiwisolver-1.4.8-cp310-cp310-win_arm64.whl", hash = "sha256:b5773efa2be9eb9fcf5415ea3ab70fc785d598729fd6057bea38d539ead28271", size = 65175 }, + { url = "https://files.pythonhosted.org/packages/da/ed/c913ee28936c371418cb167b128066ffb20bbf37771eecc2c97edf8a6e4c/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a4d3601908c560bdf880f07d94f31d734afd1bb71e96585cace0e38ef44c6d84", size = 124635 }, + { url = "https://files.pythonhosted.org/packages/4c/45/4a7f896f7467aaf5f56ef093d1f329346f3b594e77c6a3c327b2d415f521/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:856b269c4d28a5c0d5e6c1955ec36ebfd1651ac00e1ce0afa3e28da95293b561", size = 66717 }, + { url = "https://files.pythonhosted.org/packages/5f/b4/c12b3ac0852a3a68f94598d4c8d569f55361beef6159dce4e7b624160da2/kiwisolver-1.4.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2b9a96e0f326205af81a15718a9073328df1173a2619a68553decb7097fd5d7", size = 65413 }, + { url = "https://files.pythonhosted.org/packages/a9/98/1df4089b1ed23d83d410adfdc5947245c753bddfbe06541c4aae330e9e70/kiwisolver-1.4.8-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5020c83e8553f770cb3b5fc13faac40f17e0b205bd237aebd21d53d733adb03", size = 1343994 }, + { url = "https://files.pythonhosted.org/packages/8d/bf/b4b169b050c8421a7c53ea1ea74e4ef9c335ee9013216c558a047f162d20/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dace81d28c787956bfbfbbfd72fdcef014f37d9b48830829e488fdb32b49d954", size = 1434804 }, + { url = "https://files.pythonhosted.org/packages/66/5a/e13bd341fbcf73325ea60fdc8af752addf75c5079867af2e04cc41f34434/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11e1022b524bd48ae56c9b4f9296bce77e15a2e42a502cceba602f804b32bb79", size = 1450690 }, + { url = "https://files.pythonhosted.org/packages/9b/4f/5955dcb376ba4a830384cc6fab7d7547bd6759fe75a09564910e9e3bb8ea/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b9b4d2892fefc886f30301cdd80debd8bb01ecdf165a449eb6e78f79f0fabd6", size = 1376839 }, + { url = "https://files.pythonhosted.org/packages/3a/97/5edbed69a9d0caa2e4aa616ae7df8127e10f6586940aa683a496c2c280b9/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a96c0e790ee875d65e340ab383700e2b4891677b7fcd30a699146f9384a2bb0", size = 1435109 }, + { url = "https://files.pythonhosted.org/packages/13/fc/e756382cb64e556af6c1809a1bbb22c141bbc2445049f2da06b420fe52bf/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23454ff084b07ac54ca8be535f4174170c1094a4cff78fbae4f73a4bcc0d4dab", size = 2245269 }, + { url = "https://files.pythonhosted.org/packages/76/15/e59e45829d7f41c776d138245cabae6515cb4eb44b418f6d4109c478b481/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:87b287251ad6488e95b4f0b4a79a6d04d3ea35fde6340eb38fbd1ca9cd35bbbc", size = 2393468 }, + { url = "https://files.pythonhosted.org/packages/e9/39/483558c2a913ab8384d6e4b66a932406f87c95a6080112433da5ed668559/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b21dbe165081142b1232a240fc6383fd32cdd877ca6cc89eab93e5f5883e1c25", size = 2355394 }, + { url = "https://files.pythonhosted.org/packages/01/aa/efad1fbca6570a161d29224f14b082960c7e08268a133fe5dc0f6906820e/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:768cade2c2df13db52475bd28d3a3fac8c9eff04b0e9e2fda0f3760f20b3f7fc", size = 2490901 }, + { url = "https://files.pythonhosted.org/packages/c9/4f/15988966ba46bcd5ab9d0c8296914436720dd67fca689ae1a75b4ec1c72f/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d47cfb2650f0e103d4bf68b0b5804c68da97272c84bb12850d877a95c056bd67", size = 2312306 }, + { url = "https://files.pythonhosted.org/packages/2d/27/bdf1c769c83f74d98cbc34483a972f221440703054894a37d174fba8aa68/kiwisolver-1.4.8-cp311-cp311-win_amd64.whl", hash = "sha256:ed33ca2002a779a2e20eeb06aea7721b6e47f2d4b8a8ece979d8ba9e2a167e34", size = 71966 }, + { url = "https://files.pythonhosted.org/packages/4a/c9/9642ea855604aeb2968a8e145fc662edf61db7632ad2e4fb92424be6b6c0/kiwisolver-1.4.8-cp311-cp311-win_arm64.whl", hash = "sha256:16523b40aab60426ffdebe33ac374457cf62863e330a90a0383639ce14bf44b2", size = 65311 }, + { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152 }, + { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067 }, + { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443 }, + { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728 }, + { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388 }, + { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849 }, + { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533 }, + { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898 }, + { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605 }, + { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801 }, + { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077 }, + { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410 }, + { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853 }, + { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424 }, + { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156 }, + { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555 }, + { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071 }, + { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053 }, + { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278 }, + { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139 }, + { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517 }, + { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952 }, + { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132 }, + { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997 }, + { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060 }, + { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471 }, + { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793 }, + { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855 }, + { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430 }, + { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294 }, + { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736 }, + { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194 }, + { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942 }, + { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341 }, + { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455 }, + { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138 }, + { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857 }, + { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129 }, + { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538 }, + { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661 }, + { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710 }, + { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213 }, + { url = "https://files.pythonhosted.org/packages/1f/f9/ae81c47a43e33b93b0a9819cac6723257f5da2a5a60daf46aa5c7226ea85/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e7a019419b7b510f0f7c9dceff8c5eae2392037eae483a7f9162625233802b0a", size = 60403 }, + { url = "https://files.pythonhosted.org/packages/58/ca/f92b5cb6f4ce0c1ebfcfe3e2e42b96917e16f7090e45b21102941924f18f/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:286b18e86682fd2217a48fc6be6b0f20c1d0ed10958d8dc53453ad58d7be0bf8", size = 58657 }, + { url = "https://files.pythonhosted.org/packages/80/28/ae0240f732f0484d3a4dc885d055653c47144bdf59b670aae0ec3c65a7c8/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4191ee8dfd0be1c3666ccbac178c5a05d5f8d689bbe3fc92f3c4abec817f8fe0", size = 84948 }, + { url = "https://files.pythonhosted.org/packages/5d/eb/78d50346c51db22c7203c1611f9b513075f35c4e0e4877c5dde378d66043/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd2785b9391f2873ad46088ed7599a6a71e762e1ea33e87514b1a441ed1da1c", size = 81186 }, + { url = "https://files.pythonhosted.org/packages/43/f8/7259f18c77adca88d5f64f9a522792e178b2691f3748817a8750c2d216ef/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c07b29089b7ba090b6f1a669f1411f27221c3662b3a1b7010e67b59bb5a6f10b", size = 80279 }, + { url = "https://files.pythonhosted.org/packages/3a/1d/50ad811d1c5dae091e4cf046beba925bcae0a610e79ae4c538f996f63ed5/kiwisolver-1.4.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:65ea09a5a3faadd59c2ce96dc7bf0f364986a315949dc6374f04396b0d60e09b", size = 71762 }, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357 }, + { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393 }, + { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732 }, + { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866 }, + { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964 }, + { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977 }, + { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366 }, + { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091 }, + { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065 }, + { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514 }, + { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353 }, + { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392 }, + { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984 }, + { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120 }, + { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032 }, + { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057 }, + { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359 }, + { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306 }, + { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094 }, + { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521 }, + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 }, +] + +[[package]] +name = "matching" +source = { editable = "." } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, +] + +[package.optional-dependencies] +dev = [ + { name = "hypothesis" }, + { name = "ipython", version = "8.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "matplotlib" }, + { name = "nbsphinx" }, + { name = "nbval" }, + { name = "pandas" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "pytest-randomly" }, + { name = "pytest-sugar" }, + { name = "pyyaml" }, + { name = "quartodoc" }, + { name = "ruff" }, +] +docs = [ + { name = "ipython", version = "8.34.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "matplotlib" }, + { name = "nbsphinx" }, + { name = "pandas" }, + { name = "pyyaml" }, + { name = "quartodoc" }, +] +test = [ + { name = "hypothesis" }, + { name = "nbval" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "pytest-randomly" }, +] + +[package.metadata] +requires-dist = [ + { name = "hypothesis", marker = "extra == 'test'", specifier = ">=6.129.4" }, + { name = "ipython", marker = "extra == 'docs'", specifier = ">=7.34.0" }, + { name = "matching", extras = ["docs", "test"], marker = "extra == 'dev'" }, + { name = "matplotlib", marker = "extra == 'docs'", specifier = ">=3.10.1" }, + { name = "nbsphinx", marker = "extra == 'docs'", specifier = ">=0.9.7" }, + { name = "nbval", marker = "extra == 'test'", specifier = ">=0.11.0" }, + { name = "numpy", specifier = ">=2.2.4" }, + { name = "pandas", marker = "extra == 'docs'", specifier = ">=2.2.3" }, + { name = "pytest", marker = "extra == 'test'", specifier = ">=7.4.4" }, + { name = "pytest-cov", marker = "extra == 'test'", specifier = ">=6.0.0" }, + { name = "pytest-randomly", marker = "extra == 'test'", specifier = ">=3.16.0" }, + { name = "pytest-sugar", marker = "extra == 'dev'", specifier = ">=1.0.0" }, + { name = "pyyaml", marker = "extra == 'docs'", specifier = ">=6.0.1" }, + { name = "quartodoc", marker = "extra == 'docs'", specifier = ">=0.9.1" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.11.1" }, + { name = "scipy", specifier = ">=1.11.3" }, +] +provides-extras = ["test", "docs", "dev"] + +[[package]] +name = "matplotlib" +version = "3.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/08/b89867ecea2e305f408fbb417139a8dd941ecf7b23a2e02157c36da546f0/matplotlib-3.10.1.tar.gz", hash = "sha256:e8d2d0e3881b129268585bf4765ad3ee73a4591d77b9a18c214ac7e3a79fb2ba", size = 36743335 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/b1/f70e27cf1cd76ce2a5e1aa5579d05afe3236052c6d9b9a96325bc823a17e/matplotlib-3.10.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ff2ae14910be903f4a24afdbb6d7d3a6c44da210fc7d42790b87aeac92238a16", size = 8163654 }, + { url = "https://files.pythonhosted.org/packages/26/af/5ec3d4636106718bb62503a03297125d4514f98fe818461bd9e6b9d116e4/matplotlib-3.10.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0721a3fd3d5756ed593220a8b86808a36c5031fce489adb5b31ee6dbb47dd5b2", size = 8037943 }, + { url = "https://files.pythonhosted.org/packages/a1/3d/07f9003a71b698b848c9925d05979ffa94a75cd25d1a587202f0bb58aa81/matplotlib-3.10.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0673b4b8f131890eb3a1ad058d6e065fb3c6e71f160089b65f8515373394698", size = 8449510 }, + { url = "https://files.pythonhosted.org/packages/12/87/9472d4513ff83b7cd864311821793ab72234fa201ab77310ec1b585d27e2/matplotlib-3.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e875b95ac59a7908978fe307ecdbdd9a26af7fa0f33f474a27fcf8c99f64a19", size = 8586585 }, + { url = "https://files.pythonhosted.org/packages/31/9e/fe74d237d2963adae8608faeb21f778cf246dbbf4746cef87cffbc82c4b6/matplotlib-3.10.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2589659ea30726284c6c91037216f64a506a9822f8e50592d48ac16a2f29e044", size = 9397911 }, + { url = "https://files.pythonhosted.org/packages/b6/1b/025d3e59e8a4281ab463162ad7d072575354a1916aba81b6a11507dfc524/matplotlib-3.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:a97ff127f295817bc34517255c9db6e71de8eddaab7f837b7d341dee9f2f587f", size = 8052998 }, + { url = "https://files.pythonhosted.org/packages/a5/14/a1b840075be247bb1834b22c1e1d558740b0f618fe3a823740181ca557a1/matplotlib-3.10.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:057206ff2d6ab82ff3e94ebd94463d084760ca682ed5f150817b859372ec4401", size = 8174669 }, + { url = "https://files.pythonhosted.org/packages/0a/e4/300b08e3e08f9c98b0d5635f42edabf2f7a1d634e64cb0318a71a44ff720/matplotlib-3.10.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a144867dd6bf8ba8cb5fc81a158b645037e11b3e5cf8a50bd5f9917cb863adfe", size = 8047996 }, + { url = "https://files.pythonhosted.org/packages/75/f9/8d99ff5a2498a5f1ccf919fb46fb945109623c6108216f10f96428f388bc/matplotlib-3.10.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56c5d9fcd9879aa8040f196a235e2dcbdf7dd03ab5b07c0696f80bc6cf04bedd", size = 8461612 }, + { url = "https://files.pythonhosted.org/packages/40/b8/53fa08a5eaf78d3a7213fd6da1feec4bae14a81d9805e567013811ff0e85/matplotlib-3.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f69dc9713e4ad2fb21a1c30e37bd445d496524257dfda40ff4a8efb3604ab5c", size = 8602258 }, + { url = "https://files.pythonhosted.org/packages/40/87/4397d2ce808467af86684a622dd112664553e81752ea8bf61bdd89d24a41/matplotlib-3.10.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4c59af3e8aca75d7744b68e8e78a669e91ccbcf1ac35d0102a7b1b46883f1dd7", size = 9408896 }, + { url = "https://files.pythonhosted.org/packages/d7/68/0d03098b3feb786cbd494df0aac15b571effda7f7cbdec267e8a8d398c16/matplotlib-3.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:11b65088c6f3dae784bc72e8d039a2580186285f87448babb9ddb2ad0082993a", size = 8061281 }, + { url = "https://files.pythonhosted.org/packages/7c/1d/5e0dc3b59c034e43de16f94deb68f4ad8a96b3ea00f4b37c160b7474928e/matplotlib-3.10.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:66e907a06e68cb6cfd652c193311d61a12b54f56809cafbed9736ce5ad92f107", size = 8175488 }, + { url = "https://files.pythonhosted.org/packages/7a/81/dae7e14042e74da658c3336ab9799128e09a1ee03964f2d89630b5d12106/matplotlib-3.10.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b4bb156abb8fa5e5b2b460196f7db7264fc6d62678c03457979e7d5254b7be", size = 8046264 }, + { url = "https://files.pythonhosted.org/packages/21/c4/22516775dcde10fc9c9571d155f90710761b028fc44f660508106c363c97/matplotlib-3.10.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1985ad3d97f51307a2cbfc801a930f120def19ba22864182dacef55277102ba6", size = 8452048 }, + { url = "https://files.pythonhosted.org/packages/63/23/c0615001f67ce7c96b3051d856baedc0c818a2ed84570b9bf9bde200f85d/matplotlib-3.10.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c96f2c2f825d1257e437a1482c5a2cf4fee15db4261bd6fc0750f81ba2b4ba3d", size = 8597111 }, + { url = "https://files.pythonhosted.org/packages/ca/c0/a07939a82aed77770514348f4568177d7dadab9787ebc618a616fe3d665e/matplotlib-3.10.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35e87384ee9e488d8dd5a2dd7baf471178d38b90618d8ea147aced4ab59c9bea", size = 9402771 }, + { url = "https://files.pythonhosted.org/packages/a6/b6/a9405484fb40746fdc6ae4502b16a9d6e53282ba5baaf9ebe2da579f68c4/matplotlib-3.10.1-cp312-cp312-win_amd64.whl", hash = "sha256:cfd414bce89cc78a7e1d25202e979b3f1af799e416010a20ab2b5ebb3a02425c", size = 8063742 }, + { url = "https://files.pythonhosted.org/packages/60/73/6770ff5e5523d00f3bc584acb6031e29ee5c8adc2336b16cd1d003675fe0/matplotlib-3.10.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c42eee41e1b60fd83ee3292ed83a97a5f2a8239b10c26715d8a6172226988d7b", size = 8176112 }, + { url = "https://files.pythonhosted.org/packages/08/97/b0ca5da0ed54a3f6599c3ab568bdda65269bc27c21a2c97868c1625e4554/matplotlib-3.10.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4f0647b17b667ae745c13721602b540f7aadb2a32c5b96e924cd4fea5dcb90f1", size = 8046931 }, + { url = "https://files.pythonhosted.org/packages/df/9a/1acbdc3b165d4ce2dcd2b1a6d4ffb46a7220ceee960c922c3d50d8514067/matplotlib-3.10.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa3854b5f9473564ef40a41bc922be978fab217776e9ae1545c9b3a5cf2092a3", size = 8453422 }, + { url = "https://files.pythonhosted.org/packages/51/d0/2bc4368abf766203e548dc7ab57cf7e9c621f1a3c72b516cc7715347b179/matplotlib-3.10.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e496c01441be4c7d5f96d4e40f7fca06e20dcb40e44c8daa2e740e1757ad9e6", size = 8596819 }, + { url = "https://files.pythonhosted.org/packages/ab/1b/8b350f8a1746c37ab69dda7d7528d1fc696efb06db6ade9727b7887be16d/matplotlib-3.10.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5d45d3f5245be5b469843450617dcad9af75ca50568acf59997bed9311131a0b", size = 9402782 }, + { url = "https://files.pythonhosted.org/packages/89/06/f570373d24d93503988ba8d04f213a372fa1ce48381c5eb15da985728498/matplotlib-3.10.1-cp313-cp313-win_amd64.whl", hash = "sha256:8e8e25b1209161d20dfe93037c8a7f7ca796ec9aa326e6e4588d8c4a5dd1e473", size = 8063812 }, + { url = "https://files.pythonhosted.org/packages/fc/e0/8c811a925b5a7ad75135f0e5af46408b78af88bbb02a1df775100ef9bfef/matplotlib-3.10.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:19b06241ad89c3ae9469e07d77efa87041eac65d78df4fcf9cac318028009b01", size = 8214021 }, + { url = "https://files.pythonhosted.org/packages/4a/34/319ec2139f68ba26da9d00fce2ff9f27679fb799a6c8e7358539801fd629/matplotlib-3.10.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01e63101ebb3014e6e9f80d9cf9ee361a8599ddca2c3e166c563628b39305dbb", size = 8090782 }, + { url = "https://files.pythonhosted.org/packages/77/ea/9812124ab9a99df5b2eec1110e9b2edc0b8f77039abf4c56e0a376e84a29/matplotlib-3.10.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f06bad951eea6422ac4e8bdebcf3a70c59ea0a03338c5d2b109f57b64eb3972", size = 8478901 }, + { url = "https://files.pythonhosted.org/packages/c9/db/b05bf463689134789b06dea85828f8ebe506fa1e37593f723b65b86c9582/matplotlib-3.10.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3dfb036f34873b46978f55e240cff7a239f6c4409eac62d8145bad3fc6ba5a3", size = 8613864 }, + { url = "https://files.pythonhosted.org/packages/c2/04/41ccec4409f3023a7576df3b5c025f1a8c8b81fbfe922ecfd837ac36e081/matplotlib-3.10.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dc6ab14a7ab3b4d813b88ba957fc05c79493a037f54e246162033591e770de6f", size = 9409487 }, + { url = "https://files.pythonhosted.org/packages/ac/c2/0d5aae823bdcc42cc99327ecdd4d28585e15ccd5218c453b7bcd827f3421/matplotlib-3.10.1-cp313-cp313t-win_amd64.whl", hash = "sha256:bc411ebd5889a78dabbc457b3fa153203e22248bfa6eedc6797be5df0164dbf9", size = 8134832 }, + { url = "https://files.pythonhosted.org/packages/c8/f6/10adb696d8cbeed2ab4c2e26ecf1c80dd3847bbf3891f4a0c362e0e08a5a/matplotlib-3.10.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:648406f1899f9a818cef8c0231b44dcfc4ff36f167101c3fd1c9151f24220fdc", size = 8158685 }, + { url = "https://files.pythonhosted.org/packages/3f/84/0603d917406072763e7f9bb37747d3d74d7ecd4b943a8c947cc3ae1cf7af/matplotlib-3.10.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:02582304e352f40520727984a5a18f37e8187861f954fea9be7ef06569cf85b4", size = 8035491 }, + { url = "https://files.pythonhosted.org/packages/fd/7d/6a8b31dd07ed856b3eae001c9129670ef75c4698fa1c2a6ac9f00a4a7054/matplotlib-3.10.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3809916157ba871bcdd33d3493acd7fe3037db5daa917ca6e77975a94cef779", size = 8590087 }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, +] + +[[package]] +name = "mistune" +version = "3.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c4/79/bda47f7dd7c3c55770478d6d02c9960c430b0cf1773b72366ff89126ea31/mistune-3.1.3.tar.gz", hash = "sha256:a7035c21782b2becb6be62f8f25d3df81ccb4d6fa477a6525b15af06539f02a0", size = 94347 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/4d/23c4e4f09da849e127e9f123241946c23c1e30f45a88366879e064211815/mistune-3.1.3-py3-none-any.whl", hash = "sha256:1a32314113cff28aa6432e99e522677c8587fd83e3d51c29b82a52409c842bd9", size = 53410 }, +] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 }, +] + +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525 }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454 }, +] + +[[package]] +name = "nbsphinx" +version = "0.9.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "sphinx" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1e/84/b1856b7651ac34e965aa567a158714c7f3bd42a1b1ce76bf423ffb99872c/nbsphinx-0.9.7.tar.gz", hash = "sha256:abd298a686d55fa894ef697c51d44f24e53aa312dadae38e82920f250a5456fe", size = 180479 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/2d/8c8e635bcc6757573d311bb3c5445426382f280da32b8cd6d82d501ef4a4/nbsphinx-0.9.7-py3-none-any.whl", hash = "sha256:7292c3767fea29e405c60743eee5393682a83982ab202ff98f5eb2db02629da8", size = 31660 }, +] + +[[package]] +name = "nbval" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage" }, + { name = "ipykernel" }, + { name = "jupyter-client" }, + { name = "nbformat" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/be/22bd64d09e0cb53258f83b6fc455f05f18a78e3e5c109ccb6af42f1f49a2/nbval-0.11.0.tar.gz", hash = "sha256:77c95797607b0a968babd2597ee3494102d25c3ad37435debbdac0e46e379094", size = 62718 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/5c/eb1e3ce54c4e94c7734b3831756c63f21badb3de91a98d77b9e23c0ca76a/nbval-0.11.0-py2.py3-none-any.whl", hash = "sha256:307aecc866c9a1e8a13bb5bbb008a702bacfda2394dff6fe504a3108a58042a0", size = 24013 }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195 }, +] + +[[package]] +name = "numpy" +version = "2.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/78/31103410a57bc2c2b93a3597340a8119588571f6a4539067546cb9a0bfac/numpy-2.2.4.tar.gz", hash = "sha256:9ba03692a45d3eef66559efe1d1096c4b9b75c0986b5dff5530c378fb8331d4f", size = 20270701 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/89/a79e86e5c1433926ed7d60cb267fb64aa578b6101ab645800fd43b4801de/numpy-2.2.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8146f3550d627252269ac42ae660281d673eb6f8b32f113538e0cc2a9aed42b9", size = 21250661 }, + { url = "https://files.pythonhosted.org/packages/79/c2/f50921beb8afd60ed9589ad880332cfefdb805422210d327fb48f12b7a81/numpy-2.2.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e642d86b8f956098b564a45e6f6ce68a22c2c97a04f5acd3f221f57b8cb850ae", size = 14389926 }, + { url = "https://files.pythonhosted.org/packages/c7/b9/2c4e96130b0b0f97b0ef4a06d6dae3b39d058b21a5e2fa2decd7fd6b1c8f/numpy-2.2.4-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:a84eda42bd12edc36eb5b53bbcc9b406820d3353f1994b6cfe453a33ff101775", size = 5428329 }, + { url = "https://files.pythonhosted.org/packages/7f/a5/3d7094aa898f4fc5c84cdfb26beeae780352d43f5d8bdec966c4393d644c/numpy-2.2.4-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:4ba5054787e89c59c593a4169830ab362ac2bee8a969249dc56e5d7d20ff8df9", size = 6963559 }, + { url = "https://files.pythonhosted.org/packages/4c/22/fb1be710a14434c09080dd4a0acc08939f612ec02efcb04b9e210474782d/numpy-2.2.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7716e4a9b7af82c06a2543c53ca476fa0b57e4d760481273e09da04b74ee6ee2", size = 14368066 }, + { url = "https://files.pythonhosted.org/packages/c2/07/2e5cc71193e3ef3a219ffcf6ca4858e46ea2be09c026ddd480d596b32867/numpy-2.2.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:adf8c1d66f432ce577d0197dceaac2ac00c0759f573f28516246351c58a85020", size = 16417040 }, + { url = "https://files.pythonhosted.org/packages/1a/97/3b1537776ad9a6d1a41813818343745e8dd928a2916d4c9edcd9a8af1dac/numpy-2.2.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:218f061d2faa73621fa23d6359442b0fc658d5b9a70801373625d958259eaca3", size = 15879862 }, + { url = "https://files.pythonhosted.org/packages/b0/b7/4472f603dd45ef36ff3d8e84e84fe02d9467c78f92cc121633dce6da307b/numpy-2.2.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:df2f57871a96bbc1b69733cd4c51dc33bea66146b8c63cacbfed73eec0883017", size = 18206032 }, + { url = "https://files.pythonhosted.org/packages/0d/bd/6a092963fb82e6c5aa0d0440635827bbb2910da229545473bbb58c537ed3/numpy-2.2.4-cp310-cp310-win32.whl", hash = "sha256:a0258ad1f44f138b791327961caedffbf9612bfa504ab9597157806faa95194a", size = 6608517 }, + { url = "https://files.pythonhosted.org/packages/01/e3/cb04627bc2a1638948bc13e818df26495aa18e20d5be1ed95ab2b10b6847/numpy-2.2.4-cp310-cp310-win_amd64.whl", hash = "sha256:0d54974f9cf14acf49c60f0f7f4084b6579d24d439453d5fc5805d46a165b542", size = 12943498 }, + { url = "https://files.pythonhosted.org/packages/16/fb/09e778ee3a8ea0d4dc8329cca0a9c9e65fed847d08e37eba74cb7ed4b252/numpy-2.2.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e9e0a277bb2eb5d8a7407e14688b85fd8ad628ee4e0c7930415687b6564207a4", size = 21254989 }, + { url = "https://files.pythonhosted.org/packages/a2/0a/1212befdbecab5d80eca3cde47d304cad986ad4eec7d85a42e0b6d2cc2ef/numpy-2.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9eeea959168ea555e556b8188da5fa7831e21d91ce031e95ce23747b7609f8a4", size = 14425910 }, + { url = "https://files.pythonhosted.org/packages/2b/3e/e7247c1d4f15086bb106c8d43c925b0b2ea20270224f5186fa48d4fb5cbd/numpy-2.2.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bd3ad3b0a40e713fc68f99ecfd07124195333f1e689387c180813f0e94309d6f", size = 5426490 }, + { url = "https://files.pythonhosted.org/packages/5d/fa/aa7cd6be51419b894c5787a8a93c3302a1ed4f82d35beb0613ec15bdd0e2/numpy-2.2.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cf28633d64294969c019c6df4ff37f5698e8326db68cc2b66576a51fad634880", size = 6967754 }, + { url = "https://files.pythonhosted.org/packages/d5/ee/96457c943265de9fadeb3d2ffdbab003f7fba13d971084a9876affcda095/numpy-2.2.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fa8fa7697ad1646b5c93de1719965844e004fcad23c91228aca1cf0800044a1", size = 14373079 }, + { url = "https://files.pythonhosted.org/packages/c5/5c/ceefca458559f0ccc7a982319f37ed07b0d7b526964ae6cc61f8ad1b6119/numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4162988a360a29af158aeb4a2f4f09ffed6a969c9776f8f3bdee9b06a8ab7e5", size = 16428819 }, + { url = "https://files.pythonhosted.org/packages/22/31/9b2ac8eee99e001eb6add9fa27514ef5e9faf176169057a12860af52704c/numpy-2.2.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:892c10d6a73e0f14935c31229e03325a7b3093fafd6ce0af704be7f894d95687", size = 15881470 }, + { url = "https://files.pythonhosted.org/packages/f0/dc/8569b5f25ff30484b555ad8a3f537e0225d091abec386c9420cf5f7a2976/numpy-2.2.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db1f1c22173ac1c58db249ae48aa7ead29f534b9a948bc56828337aa84a32ed6", size = 18218144 }, + { url = "https://files.pythonhosted.org/packages/5e/05/463c023a39bdeb9bb43a99e7dee2c664cb68d5bb87d14f92482b9f6011cc/numpy-2.2.4-cp311-cp311-win32.whl", hash = "sha256:ea2bb7e2ae9e37d96835b3576a4fa4b3a97592fbea8ef7c3587078b0068b8f09", size = 6606368 }, + { url = "https://files.pythonhosted.org/packages/8b/72/10c1d2d82101c468a28adc35de6c77b308f288cfd0b88e1070f15b98e00c/numpy-2.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:f7de08cbe5551911886d1ab60de58448c6df0f67d9feb7d1fb21e9875ef95e91", size = 12947526 }, + { url = "https://files.pythonhosted.org/packages/a2/30/182db21d4f2a95904cec1a6f779479ea1ac07c0647f064dea454ec650c42/numpy-2.2.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a7b9084668aa0f64e64bd00d27ba5146ef1c3a8835f3bd912e7a9e01326804c4", size = 20947156 }, + { url = "https://files.pythonhosted.org/packages/24/6d/9483566acfbda6c62c6bc74b6e981c777229d2af93c8eb2469b26ac1b7bc/numpy-2.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dbe512c511956b893d2dacd007d955a3f03d555ae05cfa3ff1c1ff6df8851854", size = 14133092 }, + { url = "https://files.pythonhosted.org/packages/27/f6/dba8a258acbf9d2bed2525cdcbb9493ef9bae5199d7a9cb92ee7e9b2aea6/numpy-2.2.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:bb649f8b207ab07caebba230d851b579a3c8711a851d29efe15008e31bb4de24", size = 5163515 }, + { url = "https://files.pythonhosted.org/packages/62/30/82116199d1c249446723c68f2c9da40d7f062551036f50b8c4caa42ae252/numpy-2.2.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:f34dc300df798742b3d06515aa2a0aee20941c13579d7a2f2e10af01ae4901ee", size = 6696558 }, + { url = "https://files.pythonhosted.org/packages/0e/b2/54122b3c6df5df3e87582b2e9430f1bdb63af4023c739ba300164c9ae503/numpy-2.2.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3f7ac96b16955634e223b579a3e5798df59007ca43e8d451a0e6a50f6bfdfba", size = 14084742 }, + { url = "https://files.pythonhosted.org/packages/02/e2/e2cbb8d634151aab9528ef7b8bab52ee4ab10e076509285602c2a3a686e0/numpy-2.2.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f92084defa704deadd4e0a5ab1dc52d8ac9e8a8ef617f3fbb853e79b0ea3592", size = 16134051 }, + { url = "https://files.pythonhosted.org/packages/8e/21/efd47800e4affc993e8be50c1b768de038363dd88865920439ef7b422c60/numpy-2.2.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4e84a6283b36632e2a5b56e121961f6542ab886bc9e12f8f9818b3c266bfbb", size = 15578972 }, + { url = "https://files.pythonhosted.org/packages/04/1e/f8bb88f6157045dd5d9b27ccf433d016981032690969aa5c19e332b138c0/numpy-2.2.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:11c43995255eb4127115956495f43e9343736edb7fcdb0d973defd9de14cd84f", size = 17898106 }, + { url = "https://files.pythonhosted.org/packages/2b/93/df59a5a3897c1f036ae8ff845e45f4081bb06943039ae28a3c1c7c780f22/numpy-2.2.4-cp312-cp312-win32.whl", hash = "sha256:65ef3468b53269eb5fdb3a5c09508c032b793da03251d5f8722b1194f1790c00", size = 6311190 }, + { url = "https://files.pythonhosted.org/packages/46/69/8c4f928741c2a8efa255fdc7e9097527c6dc4e4df147e3cadc5d9357ce85/numpy-2.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:2aad3c17ed2ff455b8eaafe06bcdae0062a1db77cb99f4b9cbb5f4ecb13c5146", size = 12644305 }, + { url = "https://files.pythonhosted.org/packages/2a/d0/bd5ad792e78017f5decfb2ecc947422a3669a34f775679a76317af671ffc/numpy-2.2.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cf4e5c6a278d620dee9ddeb487dc6a860f9b199eadeecc567f777daace1e9e7", size = 20933623 }, + { url = "https://files.pythonhosted.org/packages/c3/bc/2b3545766337b95409868f8e62053135bdc7fa2ce630aba983a2aa60b559/numpy-2.2.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1974afec0b479e50438fc3648974268f972e2d908ddb6d7fb634598cdb8260a0", size = 14148681 }, + { url = "https://files.pythonhosted.org/packages/6a/70/67b24d68a56551d43a6ec9fe8c5f91b526d4c1a46a6387b956bf2d64744e/numpy-2.2.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:79bd5f0a02aa16808fcbc79a9a376a147cc1045f7dfe44c6e7d53fa8b8a79392", size = 5148759 }, + { url = "https://files.pythonhosted.org/packages/1c/8b/e2fc8a75fcb7be12d90b31477c9356c0cbb44abce7ffb36be39a0017afad/numpy-2.2.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:3387dd7232804b341165cedcb90694565a6015433ee076c6754775e85d86f1fc", size = 6683092 }, + { url = "https://files.pythonhosted.org/packages/13/73/41b7b27f169ecf368b52533edb72e56a133f9e86256e809e169362553b49/numpy-2.2.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f527d8fdb0286fd2fd97a2a96c6be17ba4232da346931d967a0630050dfd298", size = 14081422 }, + { url = "https://files.pythonhosted.org/packages/4b/04/e208ff3ae3ddfbafc05910f89546382f15a3f10186b1f56bd99f159689c2/numpy-2.2.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bce43e386c16898b91e162e5baaad90c4b06f9dcbe36282490032cec98dc8ae7", size = 16132202 }, + { url = "https://files.pythonhosted.org/packages/fe/bc/2218160574d862d5e55f803d88ddcad88beff94791f9c5f86d67bd8fbf1c/numpy-2.2.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31504f970f563d99f71a3512d0c01a645b692b12a63630d6aafa0939e52361e6", size = 15573131 }, + { url = "https://files.pythonhosted.org/packages/a5/78/97c775bc4f05abc8a8426436b7cb1be806a02a2994b195945600855e3a25/numpy-2.2.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:81413336ef121a6ba746892fad881a83351ee3e1e4011f52e97fba79233611fd", size = 17894270 }, + { url = "https://files.pythonhosted.org/packages/b9/eb/38c06217a5f6de27dcb41524ca95a44e395e6a1decdc0c99fec0832ce6ae/numpy-2.2.4-cp313-cp313-win32.whl", hash = "sha256:f486038e44caa08dbd97275a9a35a283a8f1d2f0ee60ac260a1790e76660833c", size = 6308141 }, + { url = "https://files.pythonhosted.org/packages/52/17/d0dd10ab6d125c6d11ffb6dfa3423c3571befab8358d4f85cd4471964fcd/numpy-2.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:207a2b8441cc8b6a2a78c9ddc64d00d20c303d79fba08c577752f080c4007ee3", size = 12636885 }, + { url = "https://files.pythonhosted.org/packages/fa/e2/793288ede17a0fdc921172916efb40f3cbc2aa97e76c5c84aba6dc7e8747/numpy-2.2.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8120575cb4882318c791f839a4fd66161a6fa46f3f0a5e613071aae35b5dd8f8", size = 20961829 }, + { url = "https://files.pythonhosted.org/packages/3a/75/bb4573f6c462afd1ea5cbedcc362fe3e9bdbcc57aefd37c681be1155fbaa/numpy-2.2.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a761ba0fa886a7bb33c6c8f6f20213735cb19642c580a931c625ee377ee8bd39", size = 14161419 }, + { url = "https://files.pythonhosted.org/packages/03/68/07b4cd01090ca46c7a336958b413cdbe75002286295f2addea767b7f16c9/numpy-2.2.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:ac0280f1ba4a4bfff363a99a6aceed4f8e123f8a9b234c89140f5e894e452ecd", size = 5196414 }, + { url = "https://files.pythonhosted.org/packages/a5/fd/d4a29478d622fedff5c4b4b4cedfc37a00691079623c0575978d2446db9e/numpy-2.2.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:879cf3a9a2b53a4672a168c21375166171bc3932b7e21f622201811c43cdd3b0", size = 6709379 }, + { url = "https://files.pythonhosted.org/packages/41/78/96dddb75bb9be730b87c72f30ffdd62611aba234e4e460576a068c98eff6/numpy-2.2.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f05d4198c1bacc9124018109c5fba2f3201dbe7ab6e92ff100494f236209c960", size = 14051725 }, + { url = "https://files.pythonhosted.org/packages/00/06/5306b8199bffac2a29d9119c11f457f6c7d41115a335b78d3f86fad4dbe8/numpy-2.2.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2f085ce2e813a50dfd0e01fbfc0c12bbe5d2063d99f8b29da30e544fb6483b8", size = 16101638 }, + { url = "https://files.pythonhosted.org/packages/fa/03/74c5b631ee1ded596945c12027649e6344614144369fd3ec1aaced782882/numpy-2.2.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:92bda934a791c01d6d9d8e038363c50918ef7c40601552a58ac84c9613a665bc", size = 15571717 }, + { url = "https://files.pythonhosted.org/packages/cb/dc/4fc7c0283abe0981e3b89f9b332a134e237dd476b0c018e1e21083310c31/numpy-2.2.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ee4d528022f4c5ff67332469e10efe06a267e32f4067dc76bb7e2cddf3cd25ff", size = 17879998 }, + { url = "https://files.pythonhosted.org/packages/e5/2b/878576190c5cfa29ed896b518cc516aecc7c98a919e20706c12480465f43/numpy-2.2.4-cp313-cp313t-win32.whl", hash = "sha256:05c076d531e9998e7e694c36e8b349969c56eadd2cdcd07242958489d79a7286", size = 6366896 }, + { url = "https://files.pythonhosted.org/packages/3e/05/eb7eec66b95cf697f08c754ef26c3549d03ebd682819f794cb039574a0a6/numpy-2.2.4-cp313-cp313t-win_amd64.whl", hash = "sha256:188dcbca89834cc2e14eb2f106c96d6d46f200fe0200310fc29089657379c58d", size = 12739119 }, + { url = "https://files.pythonhosted.org/packages/b2/5c/f09c33a511aff41a098e6ef3498465d95f6360621034a3d95f47edbc9119/numpy-2.2.4-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7051ee569db5fbac144335e0f3b9c2337e0c8d5c9fee015f259a5bd70772b7e8", size = 21081956 }, + { url = "https://files.pythonhosted.org/packages/ba/30/74c48b3b6494c4b820b7fa1781d441e94d87a08daa5b35d222f06ba41a6f/numpy-2.2.4-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:ab2939cd5bec30a7430cbdb2287b63151b77cf9624de0532d629c9a1c59b1d5c", size = 6827143 }, + { url = "https://files.pythonhosted.org/packages/54/f5/ab0d2f48b490535c7a80e05da4a98902b632369efc04f0e47bb31ca97d8f/numpy-2.2.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0f35b19894a9e08639fd60a1ec1978cb7f5f7f1eace62f38dd36be8aecdef4d", size = 16233350 }, + { url = "https://files.pythonhosted.org/packages/3b/3a/2f6d8c1f8e45d496bca6baaec93208035faeb40d5735c25afac092ec9a12/numpy-2.2.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b4adfbbc64014976d2f91084915ca4e626fbf2057fb81af209c1a6d776d23e3d", size = 12857565 }, +] + +[[package]] +name = "packaging" +version = "24.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, +] + +[[package]] +name = "pandas" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 }, + { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 }, + { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 }, + { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 }, + { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 }, + { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 }, + { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 }, + { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 }, + { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 }, + { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 }, + { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 }, + { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 }, + { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 }, + { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 }, + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663 }, +] + +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, +] + +[[package]] +name = "pillow" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/af/c097e544e7bd278333db77933e535098c259609c4eb3b85381109602fb5b/pillow-11.1.0.tar.gz", hash = "sha256:368da70808b36d73b4b390a8ffac11069f8a5c85f29eff1f1b01bcf3ef5b2a20", size = 46742715 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/1c/2dcea34ac3d7bc96a1fd1bd0a6e06a57c67167fec2cff8d95d88229a8817/pillow-11.1.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:e1abe69aca89514737465752b4bcaf8016de61b3be1397a8fc260ba33321b3a8", size = 3229983 }, + { url = "https://files.pythonhosted.org/packages/14/ca/6bec3df25e4c88432681de94a3531cc738bd85dea6c7aa6ab6f81ad8bd11/pillow-11.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c640e5a06869c75994624551f45e5506e4256562ead981cce820d5ab39ae2192", size = 3101831 }, + { url = "https://files.pythonhosted.org/packages/d4/2c/668e18e5521e46eb9667b09e501d8e07049eb5bfe39d56be0724a43117e6/pillow-11.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a07dba04c5e22824816b2615ad7a7484432d7f540e6fa86af60d2de57b0fcee2", size = 4314074 }, + { url = "https://files.pythonhosted.org/packages/02/80/79f99b714f0fc25f6a8499ecfd1f810df12aec170ea1e32a4f75746051ce/pillow-11.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e267b0ed063341f3e60acd25c05200df4193e15a4a5807075cd71225a2386e26", size = 4394933 }, + { url = "https://files.pythonhosted.org/packages/81/aa/8d4ad25dc11fd10a2001d5b8a80fdc0e564ac33b293bdfe04ed387e0fd95/pillow-11.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:bd165131fd51697e22421d0e467997ad31621b74bfc0b75956608cb2906dda07", size = 4353349 }, + { url = "https://files.pythonhosted.org/packages/84/7a/cd0c3eaf4a28cb2a74bdd19129f7726277a7f30c4f8424cd27a62987d864/pillow-11.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:abc56501c3fd148d60659aae0af6ddc149660469082859fa7b066a298bde9482", size = 4476532 }, + { url = "https://files.pythonhosted.org/packages/8f/8b/a907fdd3ae8f01c7670dfb1499c53c28e217c338b47a813af8d815e7ce97/pillow-11.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:54ce1c9a16a9561b6d6d8cb30089ab1e5eb66918cb47d457bd996ef34182922e", size = 4279789 }, + { url = "https://files.pythonhosted.org/packages/6f/9a/9f139d9e8cccd661c3efbf6898967a9a337eb2e9be2b454ba0a09533100d/pillow-11.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:73ddde795ee9b06257dac5ad42fcb07f3b9b813f8c1f7f870f402f4dc54b5269", size = 4413131 }, + { url = "https://files.pythonhosted.org/packages/a8/68/0d8d461f42a3f37432203c8e6df94da10ac8081b6d35af1c203bf3111088/pillow-11.1.0-cp310-cp310-win32.whl", hash = "sha256:3a5fe20a7b66e8135d7fd617b13272626a28278d0e578c98720d9ba4b2439d49", size = 2291213 }, + { url = "https://files.pythonhosted.org/packages/14/81/d0dff759a74ba87715509af9f6cb21fa21d93b02b3316ed43bda83664db9/pillow-11.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:b6123aa4a59d75f06e9dd3dac5bf8bc9aa383121bb3dd9a7a612e05eabc9961a", size = 2625725 }, + { url = "https://files.pythonhosted.org/packages/ce/1f/8d50c096a1d58ef0584ddc37e6f602828515219e9d2428e14ce50f5ecad1/pillow-11.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:a76da0a31da6fcae4210aa94fd779c65c75786bc9af06289cd1c184451ef7a65", size = 2375213 }, + { url = "https://files.pythonhosted.org/packages/dd/d6/2000bfd8d5414fb70cbbe52c8332f2283ff30ed66a9cde42716c8ecbe22c/pillow-11.1.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e06695e0326d05b06833b40b7ef477e475d0b1ba3a6d27da1bb48c23209bf457", size = 3229968 }, + { url = "https://files.pythonhosted.org/packages/d9/45/3fe487010dd9ce0a06adf9b8ff4f273cc0a44536e234b0fad3532a42c15b/pillow-11.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96f82000e12f23e4f29346e42702b6ed9a2f2fea34a740dd5ffffcc8c539eb35", size = 3101806 }, + { url = "https://files.pythonhosted.org/packages/e3/72/776b3629c47d9d5f1c160113158a7a7ad177688d3a1159cd3b62ded5a33a/pillow-11.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3cd561ded2cf2bbae44d4605837221b987c216cff94f49dfeed63488bb228d2", size = 4322283 }, + { url = "https://files.pythonhosted.org/packages/e4/c2/e25199e7e4e71d64eeb869f5b72c7ddec70e0a87926398785ab944d92375/pillow-11.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f189805c8be5ca5add39e6f899e6ce2ed824e65fb45f3c28cb2841911da19070", size = 4402945 }, + { url = "https://files.pythonhosted.org/packages/c1/ed/51d6136c9d5911f78632b1b86c45241c712c5a80ed7fa7f9120a5dff1eba/pillow-11.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:dd0052e9db3474df30433f83a71b9b23bd9e4ef1de13d92df21a52c0303b8ab6", size = 4361228 }, + { url = "https://files.pythonhosted.org/packages/48/a4/fbfe9d5581d7b111b28f1d8c2762dee92e9821bb209af9fa83c940e507a0/pillow-11.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:837060a8599b8f5d402e97197d4924f05a2e0d68756998345c829c33186217b1", size = 4484021 }, + { url = "https://files.pythonhosted.org/packages/39/db/0b3c1a5018117f3c1d4df671fb8e47d08937f27519e8614bbe86153b65a5/pillow-11.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aa8dd43daa836b9a8128dbe7d923423e5ad86f50a7a14dc688194b7be5c0dea2", size = 4287449 }, + { url = "https://files.pythonhosted.org/packages/d9/58/bc128da7fea8c89fc85e09f773c4901e95b5936000e6f303222490c052f3/pillow-11.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0a2f91f8a8b367e7a57c6e91cd25af510168091fb89ec5146003e424e1558a96", size = 4419972 }, + { url = "https://files.pythonhosted.org/packages/5f/bb/58f34379bde9fe197f51841c5bbe8830c28bbb6d3801f16a83b8f2ad37df/pillow-11.1.0-cp311-cp311-win32.whl", hash = "sha256:c12fc111ef090845de2bb15009372175d76ac99969bdf31e2ce9b42e4b8cd88f", size = 2291201 }, + { url = "https://files.pythonhosted.org/packages/3a/c6/fce9255272bcf0c39e15abd2f8fd8429a954cf344469eaceb9d0d1366913/pillow-11.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbd43429d0d7ed6533b25fc993861b8fd512c42d04514a0dd6337fb3ccf22761", size = 2625686 }, + { url = "https://files.pythonhosted.org/packages/c8/52/8ba066d569d932365509054859f74f2a9abee273edcef5cd75e4bc3e831e/pillow-11.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:f7955ecf5609dee9442cbface754f2c6e541d9e6eda87fad7f7a989b0bdb9d71", size = 2375194 }, + { url = "https://files.pythonhosted.org/packages/95/20/9ce6ed62c91c073fcaa23d216e68289e19d95fb8188b9fb7a63d36771db8/pillow-11.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2062ffb1d36544d42fcaa277b069c88b01bb7298f4efa06731a7fd6cc290b81a", size = 3226818 }, + { url = "https://files.pythonhosted.org/packages/b9/d8/f6004d98579a2596c098d1e30d10b248798cceff82d2b77aa914875bfea1/pillow-11.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a85b653980faad27e88b141348707ceeef8a1186f75ecc600c395dcac19f385b", size = 3101662 }, + { url = "https://files.pythonhosted.org/packages/08/d9/892e705f90051c7a2574d9f24579c9e100c828700d78a63239676f960b74/pillow-11.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9409c080586d1f683df3f184f20e36fb647f2e0bc3988094d4fd8c9f4eb1b3b3", size = 4329317 }, + { url = "https://files.pythonhosted.org/packages/8c/aa/7f29711f26680eab0bcd3ecdd6d23ed6bce180d82e3f6380fb7ae35fcf3b/pillow-11.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fdadc077553621911f27ce206ffcbec7d3f8d7b50e0da39f10997e8e2bb7f6a", size = 4412999 }, + { url = "https://files.pythonhosted.org/packages/c8/c4/8f0fe3b9e0f7196f6d0bbb151f9fba323d72a41da068610c4c960b16632a/pillow-11.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:93a18841d09bcdd774dcdc308e4537e1f867b3dec059c131fde0327899734aa1", size = 4368819 }, + { url = "https://files.pythonhosted.org/packages/38/0d/84200ed6a871ce386ddc82904bfadc0c6b28b0c0ec78176871a4679e40b3/pillow-11.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:9aa9aeddeed452b2f616ff5507459e7bab436916ccb10961c4a382cd3e03f47f", size = 4496081 }, + { url = "https://files.pythonhosted.org/packages/84/9c/9bcd66f714d7e25b64118e3952d52841a4babc6d97b6d28e2261c52045d4/pillow-11.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3cdcdb0b896e981678eee140d882b70092dac83ac1cdf6b3a60e2216a73f2b91", size = 4296513 }, + { url = "https://files.pythonhosted.org/packages/db/61/ada2a226e22da011b45f7104c95ebda1b63dcbb0c378ad0f7c2a710f8fd2/pillow-11.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36ba10b9cb413e7c7dfa3e189aba252deee0602c86c309799da5a74009ac7a1c", size = 4431298 }, + { url = "https://files.pythonhosted.org/packages/e7/c4/fc6e86750523f367923522014b821c11ebc5ad402e659d8c9d09b3c9d70c/pillow-11.1.0-cp312-cp312-win32.whl", hash = "sha256:cfd5cd998c2e36a862d0e27b2df63237e67273f2fc78f47445b14e73a810e7e6", size = 2291630 }, + { url = "https://files.pythonhosted.org/packages/08/5c/2104299949b9d504baf3f4d35f73dbd14ef31bbd1ddc2c1b66a5b7dfda44/pillow-11.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:a697cd8ba0383bba3d2d3ada02b34ed268cb548b369943cd349007730c92bddf", size = 2626369 }, + { url = "https://files.pythonhosted.org/packages/37/f3/9b18362206b244167c958984b57c7f70a0289bfb59a530dd8af5f699b910/pillow-11.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:4dd43a78897793f60766563969442020e90eb7847463eca901e41ba186a7d4a5", size = 2375240 }, + { url = "https://files.pythonhosted.org/packages/b3/31/9ca79cafdce364fd5c980cd3416c20ce1bebd235b470d262f9d24d810184/pillow-11.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ae98e14432d458fc3de11a77ccb3ae65ddce70f730e7c76140653048c71bfcbc", size = 3226640 }, + { url = "https://files.pythonhosted.org/packages/ac/0f/ff07ad45a1f172a497aa393b13a9d81a32e1477ef0e869d030e3c1532521/pillow-11.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cc1331b6d5a6e144aeb5e626f4375f5b7ae9934ba620c0ac6b3e43d5e683a0f0", size = 3101437 }, + { url = "https://files.pythonhosted.org/packages/08/2f/9906fca87a68d29ec4530be1f893149e0cb64a86d1f9f70a7cfcdfe8ae44/pillow-11.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:758e9d4ef15d3560214cddbc97b8ef3ef86ce04d62ddac17ad39ba87e89bd3b1", size = 4326605 }, + { url = "https://files.pythonhosted.org/packages/b0/0f/f3547ee15b145bc5c8b336401b2d4c9d9da67da9dcb572d7c0d4103d2c69/pillow-11.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b523466b1a31d0dcef7c5be1f20b942919b62fd6e9a9be199d035509cbefc0ec", size = 4411173 }, + { url = "https://files.pythonhosted.org/packages/b1/df/bf8176aa5db515c5de584c5e00df9bab0713548fd780c82a86cba2c2fedb/pillow-11.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:9044b5e4f7083f209c4e35aa5dd54b1dd5b112b108648f5c902ad586d4f945c5", size = 4369145 }, + { url = "https://files.pythonhosted.org/packages/de/7c/7433122d1cfadc740f577cb55526fdc39129a648ac65ce64db2eb7209277/pillow-11.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:3764d53e09cdedd91bee65c2527815d315c6b90d7b8b79759cc48d7bf5d4f114", size = 4496340 }, + { url = "https://files.pythonhosted.org/packages/25/46/dd94b93ca6bd555588835f2504bd90c00d5438fe131cf01cfa0c5131a19d/pillow-11.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31eba6bbdd27dde97b0174ddf0297d7a9c3a507a8a1480e1e60ef914fe23d352", size = 4296906 }, + { url = "https://files.pythonhosted.org/packages/a8/28/2f9d32014dfc7753e586db9add35b8a41b7a3b46540e965cb6d6bc607bd2/pillow-11.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b5d658fbd9f0d6eea113aea286b21d3cd4d3fd978157cbf2447a6035916506d3", size = 4431759 }, + { url = "https://files.pythonhosted.org/packages/33/48/19c2cbe7403870fbe8b7737d19eb013f46299cdfe4501573367f6396c775/pillow-11.1.0-cp313-cp313-win32.whl", hash = "sha256:f86d3a7a9af5d826744fabf4afd15b9dfef44fe69a98541f666f66fbb8d3fef9", size = 2291657 }, + { url = "https://files.pythonhosted.org/packages/3b/ad/285c556747d34c399f332ba7c1a595ba245796ef3e22eae190f5364bb62b/pillow-11.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:593c5fd6be85da83656b93ffcccc2312d2d149d251e98588b14fbc288fd8909c", size = 2626304 }, + { url = "https://files.pythonhosted.org/packages/e5/7b/ef35a71163bf36db06e9c8729608f78dedf032fc8313d19bd4be5c2588f3/pillow-11.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:11633d58b6ee5733bde153a8dafd25e505ea3d32e261accd388827ee987baf65", size = 2375117 }, + { url = "https://files.pythonhosted.org/packages/79/30/77f54228401e84d6791354888549b45824ab0ffde659bafa67956303a09f/pillow-11.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:70ca5ef3b3b1c4a0812b5c63c57c23b63e53bc38e758b37a951e5bc466449861", size = 3230060 }, + { url = "https://files.pythonhosted.org/packages/ce/b1/56723b74b07dd64c1010fee011951ea9c35a43d8020acd03111f14298225/pillow-11.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8000376f139d4d38d6851eb149b321a52bb8893a88dae8ee7d95840431977081", size = 3106192 }, + { url = "https://files.pythonhosted.org/packages/e1/cd/7bf7180e08f80a4dcc6b4c3a0aa9e0b0ae57168562726a05dc8aa8fa66b0/pillow-11.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ee85f0696a17dd28fbcfceb59f9510aa71934b483d1f5601d1030c3c8304f3c", size = 4446805 }, + { url = "https://files.pythonhosted.org/packages/97/42/87c856ea30c8ed97e8efbe672b58c8304dee0573f8c7cab62ae9e31db6ae/pillow-11.1.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:dd0e081319328928531df7a0e63621caf67652c8464303fd102141b785ef9547", size = 4530623 }, + { url = "https://files.pythonhosted.org/packages/ff/41/026879e90c84a88e33fb00cc6bd915ac2743c67e87a18f80270dfe3c2041/pillow-11.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e63e4e5081de46517099dc30abe418122f54531a6ae2ebc8680bcd7096860eab", size = 4465191 }, + { url = "https://files.pythonhosted.org/packages/e5/fb/a7960e838bc5df57a2ce23183bfd2290d97c33028b96bde332a9057834d3/pillow-11.1.0-cp313-cp313t-win32.whl", hash = "sha256:dda60aa465b861324e65a78c9f5cf0f4bc713e4309f83bc387be158b077963d9", size = 2295494 }, + { url = "https://files.pythonhosted.org/packages/d7/6c/6ec83ee2f6f0fda8d4cf89045c6be4b0373ebfc363ba8538f8c999f63fcd/pillow-11.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ad5db5781c774ab9a9b2c4302bbf0c1014960a0a7be63278d13ae6fdf88126fe", size = 2631595 }, + { url = "https://files.pythonhosted.org/packages/cf/6c/41c21c6c8af92b9fea313aa47c75de49e2f9a467964ee33eb0135d47eb64/pillow-11.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:67cd427c68926108778a9005f2a04adbd5e67c442ed21d95389fe1d595458756", size = 2377651 }, + { url = "https://files.pythonhosted.org/packages/fa/c5/389961578fb677b8b3244fcd934f720ed25a148b9a5cc81c91bdf59d8588/pillow-11.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8c730dc3a83e5ac137fbc92dfcfe1511ce3b2b5d7578315b63dbbb76f7f51d90", size = 3198345 }, + { url = "https://files.pythonhosted.org/packages/c4/fa/803c0e50ffee74d4b965229e816af55276eac1d5806712de86f9371858fd/pillow-11.1.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:7d33d2fae0e8b170b6a6c57400e077412240f6f5bb2a342cf1ee512a787942bb", size = 3072938 }, + { url = "https://files.pythonhosted.org/packages/dc/67/2a3a5f8012b5d8c63fe53958ba906c1b1d0482ebed5618057ef4d22f8076/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8d65b38173085f24bc07f8b6c505cbb7418009fa1a1fcb111b1f4961814a442", size = 3400049 }, + { url = "https://files.pythonhosted.org/packages/e5/a0/514f0d317446c98c478d1872497eb92e7cde67003fed74f696441e647446/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:015c6e863faa4779251436db398ae75051469f7c903b043a48f078e437656f83", size = 3422431 }, + { url = "https://files.pythonhosted.org/packages/cd/00/20f40a935514037b7d3f87adfc87d2c538430ea625b63b3af8c3f5578e72/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d44ff19eea13ae4acdaaab0179fa68c0c6f2f45d66a4d8ec1eda7d6cecbcc15f", size = 3446208 }, + { url = "https://files.pythonhosted.org/packages/28/3c/7de681727963043e093c72e6c3348411b0185eab3263100d4490234ba2f6/pillow-11.1.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d3d8da4a631471dfaf94c10c85f5277b1f8e42ac42bade1ac67da4b4a7359b73", size = 3509746 }, + { url = "https://files.pythonhosted.org/packages/41/67/936f9814bdd74b2dfd4822f1f7725ab5d8ff4103919a1664eb4874c58b2f/pillow-11.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:4637b88343166249fe8aa94e7c4a62a180c4b3898283bb5d3d2fd5fe10d8e4e0", size = 2626353 }, +] + +[[package]] +name = "platformdirs" +version = "4.3.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/2d/7d512a3913d60623e7eb945c6d1b4f0bddf1d0b7ada5225274c87e5b53d1/platformdirs-4.3.7.tar.gz", hash = "sha256:eb437d586b6a0986388f0d6f74aa0cde27b48d0e3d66843640bfb6bdcdb6e351", size = 21291 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/45/59578566b3275b8fd9157885918fcd0c4d74162928a5310926887b856a51/platformdirs-4.3.7-py3-none-any.whl", hash = "sha256:a03875334331946f13c549dbd8f4bac7a13a50a895a0eb1e8c6a8ace80d40a94", size = 18499 }, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, +] + +[[package]] +name = "plum-dispatch" +version = "2.5.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beartype" }, + { name = "rich" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/46/ab3928e864b0a88a8ae6987b3da3b7ae32fe0a610264f33272139275dab5/plum_dispatch-2.5.7.tar.gz", hash = "sha256:a7908ad5563b93f387e3817eb0412ad40cfbad04bc61d869cf7a76cd58a3895d", size = 35452 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/31/21609a9be48e877bc33b089a7f495c853215def5aeb9564a31c210d9d769/plum_dispatch-2.5.7-py3-none-any.whl", hash = "sha256:06471782eea0b3798c1e79dca2af2165bafcfa5eb595540b514ddd81053b1ede", size = 42612 }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.50" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/e1/bd15cb8ffdcfeeb2bdc215de3c3cffca11408d829e4b8416dcfe71ba8854/prompt_toolkit-3.0.50.tar.gz", hash = "sha256:544748f3860a2623ca5cd6d2795e7a14f3d0e1c3c9728359013f79877fc89bab", size = 429087 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/ea/d836f008d33151c7a1f62caf3d8dd782e4d15f6a43897f64480c2b8de2ad/prompt_toolkit-3.0.50-py3-none-any.whl", hash = "sha256:9b6427eb19e479d98acff65196a307c555eb567989e6d88ebbb1b509d9779198", size = 387816 }, +] + +[[package]] +name = "psutil" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051 }, + { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535 }, + { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004 }, + { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986 }, + { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544 }, + { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053 }, + { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885 }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, +] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 }, +] + +[[package]] +name = "pydantic" +version = "2.10.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696 }, +] + +[[package]] +name = "pydantic-core" +version = "2.27.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/bc/fed5f74b5d802cf9a03e83f60f18864e90e3aed7223adaca5ffb7a8d8d64/pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa", size = 1895938 }, + { url = "https://files.pythonhosted.org/packages/71/2a/185aff24ce844e39abb8dd680f4e959f0006944f4a8a0ea372d9f9ae2e53/pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c", size = 1815684 }, + { url = "https://files.pythonhosted.org/packages/c3/43/fafabd3d94d159d4f1ed62e383e264f146a17dd4d48453319fd782e7979e/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7969e133a6f183be60e9f6f56bfae753585680f3b7307a8e555a948d443cc05a", size = 1829169 }, + { url = "https://files.pythonhosted.org/packages/a2/d1/f2dfe1a2a637ce6800b799aa086d079998959f6f1215eb4497966efd2274/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3de9961f2a346257caf0aa508a4da705467f53778e9ef6fe744c038119737ef5", size = 1867227 }, + { url = "https://files.pythonhosted.org/packages/7d/39/e06fcbcc1c785daa3160ccf6c1c38fea31f5754b756e34b65f74e99780b5/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2bb4d3e5873c37bb3dd58714d4cd0b0e6238cebc4177ac8fe878f8b3aa8e74c", size = 2037695 }, + { url = "https://files.pythonhosted.org/packages/7a/67/61291ee98e07f0650eb756d44998214231f50751ba7e13f4f325d95249ab/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:280d219beebb0752699480fe8f1dc61ab6615c2046d76b7ab7ee38858de0a4e7", size = 2741662 }, + { url = "https://files.pythonhosted.org/packages/32/90/3b15e31b88ca39e9e626630b4c4a1f5a0dfd09076366f4219429e6786076/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a", size = 1993370 }, + { url = "https://files.pythonhosted.org/packages/ff/83/c06d333ee3a67e2e13e07794995c1535565132940715931c1c43bfc85b11/pydantic_core-2.27.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:14d4a5c49d2f009d62a2a7140d3064f686d17a5d1a268bc641954ba181880236", size = 1996813 }, + { url = "https://files.pythonhosted.org/packages/7c/f7/89be1c8deb6e22618a74f0ca0d933fdcb8baa254753b26b25ad3acff8f74/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:337b443af21d488716f8d0b6164de833e788aa6bd7e3a39c005febc1284f4962", size = 2005287 }, + { url = "https://files.pythonhosted.org/packages/b7/7d/8eb3e23206c00ef7feee17b83a4ffa0a623eb1a9d382e56e4aa46fd15ff2/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:03d0f86ea3184a12f41a2d23f7ccb79cdb5a18e06993f8a45baa8dfec746f0e9", size = 2128414 }, + { url = "https://files.pythonhosted.org/packages/4e/99/fe80f3ff8dd71a3ea15763878d464476e6cb0a2db95ff1c5c554133b6b83/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7041c36f5680c6e0f08d922aed302e98b3745d97fe1589db0a3eebf6624523af", size = 2155301 }, + { url = "https://files.pythonhosted.org/packages/2b/a3/e50460b9a5789ca1451b70d4f52546fa9e2b420ba3bfa6100105c0559238/pydantic_core-2.27.2-cp310-cp310-win32.whl", hash = "sha256:50a68f3e3819077be2c98110c1f9dcb3817e93f267ba80a2c05bb4f8799e2ff4", size = 1816685 }, + { url = "https://files.pythonhosted.org/packages/57/4c/a8838731cb0f2c2a39d3535376466de6049034d7b239c0202a64aaa05533/pydantic_core-2.27.2-cp310-cp310-win_amd64.whl", hash = "sha256:e0fd26b16394ead34a424eecf8a31a1f5137094cabe84a1bcb10fa6ba39d3d31", size = 1982876 }, + { url = "https://files.pythonhosted.org/packages/c2/89/f3450af9d09d44eea1f2c369f49e8f181d742f28220f88cc4dfaae91ea6e/pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc", size = 1893421 }, + { url = "https://files.pythonhosted.org/packages/9e/e3/71fe85af2021f3f386da42d291412e5baf6ce7716bd7101ea49c810eda90/pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7", size = 1814998 }, + { url = "https://files.pythonhosted.org/packages/a6/3c/724039e0d848fd69dbf5806894e26479577316c6f0f112bacaf67aa889ac/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15", size = 1826167 }, + { url = "https://files.pythonhosted.org/packages/2b/5b/1b29e8c1fb5f3199a9a57c1452004ff39f494bbe9bdbe9a81e18172e40d3/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306", size = 1865071 }, + { url = "https://files.pythonhosted.org/packages/89/6c/3985203863d76bb7d7266e36970d7e3b6385148c18a68cc8915fd8c84d57/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99", size = 2036244 }, + { url = "https://files.pythonhosted.org/packages/0e/41/f15316858a246b5d723f7d7f599f79e37493b2e84bfc789e58d88c209f8a/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459", size = 2737470 }, + { url = "https://files.pythonhosted.org/packages/a8/7c/b860618c25678bbd6d1d99dbdfdf0510ccb50790099b963ff78a124b754f/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048", size = 1992291 }, + { url = "https://files.pythonhosted.org/packages/bf/73/42c3742a391eccbeab39f15213ecda3104ae8682ba3c0c28069fbcb8c10d/pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d", size = 1994613 }, + { url = "https://files.pythonhosted.org/packages/94/7a/941e89096d1175d56f59340f3a8ebaf20762fef222c298ea96d36a6328c5/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b", size = 2002355 }, + { url = "https://files.pythonhosted.org/packages/6e/95/2359937a73d49e336a5a19848713555605d4d8d6940c3ec6c6c0ca4dcf25/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474", size = 2126661 }, + { url = "https://files.pythonhosted.org/packages/2b/4c/ca02b7bdb6012a1adef21a50625b14f43ed4d11f1fc237f9d7490aa5078c/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6", size = 2153261 }, + { url = "https://files.pythonhosted.org/packages/72/9d/a241db83f973049a1092a079272ffe2e3e82e98561ef6214ab53fe53b1c7/pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c", size = 1812361 }, + { url = "https://files.pythonhosted.org/packages/e8/ef/013f07248041b74abd48a385e2110aa3a9bbfef0fbd97d4e6d07d2f5b89a/pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc", size = 1982484 }, + { url = "https://files.pythonhosted.org/packages/10/1c/16b3a3e3398fd29dca77cea0a1d998d6bde3902fa2706985191e2313cc76/pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4", size = 1867102 }, + { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 }, + { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 }, + { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 }, + { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 }, + { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 }, + { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 }, + { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 }, + { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 }, + { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 }, + { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 }, + { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 }, + { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064 }, + { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046 }, + { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092 }, + { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709 }, + { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273 }, + { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027 }, + { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888 }, + { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738 }, + { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138 }, + { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025 }, + { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633 }, + { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404 }, + { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130 }, + { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946 }, + { url = "https://files.pythonhosted.org/packages/a4/99/bddde3ddde76c03b65dfd5a66ab436c4e58ffc42927d4ff1198ffbf96f5f/pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130", size = 1834387 }, + { url = "https://files.pythonhosted.org/packages/71/47/82b5e846e01b26ac6f1893d3c5f9f3a2eb6ba79be26eef0b759b4fe72946/pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee", size = 1990453 }, + { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186 }, + { url = "https://files.pythonhosted.org/packages/46/72/af70981a341500419e67d5cb45abe552a7c74b66326ac8877588488da1ac/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2bf14caea37e91198329b828eae1618c068dfb8ef17bb33287a7ad4b61ac314e", size = 1891159 }, + { url = "https://files.pythonhosted.org/packages/ad/3d/c5913cccdef93e0a6a95c2d057d2c2cba347815c845cda79ddd3c0f5e17d/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8", size = 1768331 }, + { url = "https://files.pythonhosted.org/packages/f6/f0/a3ae8fbee269e4934f14e2e0e00928f9346c5943174f2811193113e58252/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:688d3fd9fcb71f41c4c015c023d12a79d1c4c0732ec9eb35d96e3388a120dcf3", size = 1822467 }, + { url = "https://files.pythonhosted.org/packages/d7/7a/7bbf241a04e9f9ea24cd5874354a83526d639b02674648af3f350554276c/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f", size = 1979797 }, + { url = "https://files.pythonhosted.org/packages/4f/5f/4784c6107731f89e0005a92ecb8a2efeafdb55eb992b8e9d0a2be5199335/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82f986faf4e644ffc189a7f1aafc86e46ef70372bb153e7001e8afccc6e54133", size = 1987839 }, + { url = "https://files.pythonhosted.org/packages/6d/a7/61246562b651dff00de86a5f01b6e4befb518df314c54dec187a78d81c84/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:bec317a27290e2537f922639cafd54990551725fc844249e64c523301d0822fc", size = 1998861 }, + { url = "https://files.pythonhosted.org/packages/86/aa/837821ecf0c022bbb74ca132e117c358321e72e7f9702d1b6a03758545e2/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:0296abcb83a797db256b773f45773da397da75a08f5fcaef41f2044adec05f50", size = 2116582 }, + { url = "https://files.pythonhosted.org/packages/81/b0/5e74656e95623cbaa0a6278d16cf15e10a51f6002e3ec126541e95c29ea3/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0d75070718e369e452075a6017fbf187f788e17ed67a3abd47fa934d001863d9", size = 2151985 }, + { url = "https://files.pythonhosted.org/packages/63/37/3e32eeb2a451fddaa3898e2163746b0cffbbdbb4740d38372db0490d67f3/pydantic_core-2.27.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7e17b560be3c98a8e3aa66ce828bdebb9e9ac6ad5466fba92eb74c4c95cb1151", size = 2004715 }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, +] + +[[package]] +name = "pyparsing" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/1a/3544f4f299a47911c2ab3710f534e52fea62a633c96806995da5d25be4b2/pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a", size = 1067694 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/a7/c8a2d361bf89c0d9577c934ebb7421b25dc84bf3a8e3ac0a40aed9acc547/pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1", size = 107716 }, +] + +[[package]] +name = "pytest" +version = "8.3.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 }, +] + +[[package]] +name = "pytest-cov" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", extra = ["toml"] }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/be/45/9b538de8cef30e17c7b45ef42f538a94889ed6a16f2387a6c89e73220651/pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0", size = 66945 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/3b/48e79f2cd6a61dbbd4807b4ed46cb564b4fd50a76166b1c4ea5c1d9e2371/pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35", size = 22949 }, +] + +[[package]] +name = "pytest-randomly" +version = "3.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/68/d221ed7f4a2a49a664da721b8e87b52af6dd317af2a6cb51549cf17ac4b8/pytest_randomly-3.16.0.tar.gz", hash = "sha256:11bf4d23a26484de7860d82f726c0629837cf4064b79157bd18ec9d41d7feb26", size = 13367 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/70/b31577d7c46d8e2f9baccfed5067dd8475262a2331ffb0bfdf19361c9bde/pytest_randomly-3.16.0-py3-none-any.whl", hash = "sha256:8633d332635a1a0983d3bba19342196807f6afb17c3eef78e02c2f85dade45d6", size = 8396 }, +] + +[[package]] +name = "pytest-sugar" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "pytest" }, + { name = "termcolor" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/ac/5754f5edd6d508bc6493bc37d74b928f102a5fff82d9a80347e180998f08/pytest-sugar-1.0.0.tar.gz", hash = "sha256:6422e83258f5b0c04ce7c632176c7732cab5fdb909cb39cca5c9139f81276c0a", size = 14992 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/fb/889f1b69da2f13691de09a111c16c4766a433382d44aa0ecf221deded44a/pytest_sugar-1.0.0-py3-none-any.whl", hash = "sha256:70ebcd8fc5795dc457ff8b69d266a4e2e8a74ae0c3edc749381c64b5246c8dfd", size = 10171 }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, +] + +[[package]] +name = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225 }, +] + +[[package]] +name = "pywin32" +version = "310" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/da/a5f38fffbba2fb99aa4aa905480ac4b8e83ca486659ac8c95bce47fb5276/pywin32-310-cp310-cp310-win32.whl", hash = "sha256:6dd97011efc8bf51d6793a82292419eba2c71cf8e7250cfac03bba284454abc1", size = 8848240 }, + { url = "https://files.pythonhosted.org/packages/aa/fe/d873a773324fa565619ba555a82c9dabd677301720f3660a731a5d07e49a/pywin32-310-cp310-cp310-win_amd64.whl", hash = "sha256:c3e78706e4229b915a0821941a84e7ef420bf2b77e08c9dae3c76fd03fd2ae3d", size = 9601854 }, + { url = "https://files.pythonhosted.org/packages/3c/84/1a8e3d7a15490d28a5d816efa229ecb4999cdc51a7c30dd8914f669093b8/pywin32-310-cp310-cp310-win_arm64.whl", hash = "sha256:33babed0cf0c92a6f94cc6cc13546ab24ee13e3e800e61ed87609ab91e4c8213", size = 8522963 }, + { url = "https://files.pythonhosted.org/packages/f7/b1/68aa2986129fb1011dabbe95f0136f44509afaf072b12b8f815905a39f33/pywin32-310-cp311-cp311-win32.whl", hash = "sha256:1e765f9564e83011a63321bb9d27ec456a0ed90d3732c4b2e312b855365ed8bd", size = 8784284 }, + { url = "https://files.pythonhosted.org/packages/b3/bd/d1592635992dd8db5bb8ace0551bc3a769de1ac8850200cfa517e72739fb/pywin32-310-cp311-cp311-win_amd64.whl", hash = "sha256:126298077a9d7c95c53823934f000599f66ec9296b09167810eb24875f32689c", size = 9520748 }, + { url = "https://files.pythonhosted.org/packages/90/b1/ac8b1ffce6603849eb45a91cf126c0fa5431f186c2e768bf56889c46f51c/pywin32-310-cp311-cp311-win_arm64.whl", hash = "sha256:19ec5fc9b1d51c4350be7bb00760ffce46e6c95eaf2f0b2f1150657b1a43c582", size = 8455941 }, + { url = "https://files.pythonhosted.org/packages/6b/ec/4fdbe47932f671d6e348474ea35ed94227fb5df56a7c30cbbb42cd396ed0/pywin32-310-cp312-cp312-win32.whl", hash = "sha256:8a75a5cc3893e83a108c05d82198880704c44bbaee4d06e442e471d3c9ea4f3d", size = 8796239 }, + { url = "https://files.pythonhosted.org/packages/e3/e5/b0627f8bb84e06991bea89ad8153a9e50ace40b2e1195d68e9dff6b03d0f/pywin32-310-cp312-cp312-win_amd64.whl", hash = "sha256:bf5c397c9a9a19a6f62f3fb821fbf36cac08f03770056711f765ec1503972060", size = 9503839 }, + { url = "https://files.pythonhosted.org/packages/1f/32/9ccf53748df72301a89713936645a664ec001abd35ecc8578beda593d37d/pywin32-310-cp312-cp312-win_arm64.whl", hash = "sha256:2349cc906eae872d0663d4d6290d13b90621eaf78964bb1578632ff20e152966", size = 8459470 }, + { url = "https://files.pythonhosted.org/packages/1c/09/9c1b978ffc4ae53999e89c19c77ba882d9fce476729f23ef55211ea1c034/pywin32-310-cp313-cp313-win32.whl", hash = "sha256:5d241a659c496ada3253cd01cfaa779b048e90ce4b2b38cd44168ad555ce74ab", size = 8794384 }, + { url = "https://files.pythonhosted.org/packages/45/3c/b4640f740ffebadd5d34df35fecba0e1cfef8fde9f3e594df91c28ad9b50/pywin32-310-cp313-cp313-win_amd64.whl", hash = "sha256:667827eb3a90208ddbdcc9e860c81bde63a135710e21e4cb3348968e4bd5249e", size = 9503039 }, + { url = "https://files.pythonhosted.org/packages/b4/f4/f785020090fb050e7fb6d34b780f2231f302609dc964672f72bfaeb59a28/pywin32-310-cp313-cp313-win_arm64.whl", hash = "sha256:e308f831de771482b7cf692a1f308f8fca701b2d8f9dde6cc440c7da17e47b33", size = 8458152 }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, +] + +[[package]] +name = "pyzmq" +version = "26.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/ed/c3876f3b3e8beba336214ce44e1efa1792dd537027cef24192ac2b077d7c/pyzmq-26.3.0.tar.gz", hash = "sha256:f1cd68b8236faab78138a8fc703f7ca0ad431b17a3fcac696358600d4e6243b3", size = 276733 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/a8/cc21dcd6f0f96dbd636fcaab345f9664cd54e6577a21a74694202479d3fa/pyzmq-26.3.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:1586944f4736515af5c6d3a5b150c7e8ca2a2d6e46b23057320584d6f2438f4a", size = 1345312 }, + { url = "https://files.pythonhosted.org/packages/0b/6d/7e0e52798697536d572a105849c4ab621ca00511674b6ce694cb05e437fc/pyzmq-26.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa7efc695d1fc9f72d91bf9b6c6fe2d7e1b4193836ec530a98faf7d7a7577a58", size = 678336 }, + { url = "https://files.pythonhosted.org/packages/91/86/8914875e2341a40da460feaa9cace727e50a6b640a20ac36186686bde7d9/pyzmq-26.3.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd84441e4021cec6e4dd040550386cd9c9ea1d9418ea1a8002dbb7b576026b2b", size = 916965 }, + { url = "https://files.pythonhosted.org/packages/9a/59/72b390b31ed0cc825881435f21baaae9d57e263aba526fa833863b90d667/pyzmq-26.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9176856f36c34a8aa5c0b35ddf52a5d5cd8abeece57c2cd904cfddae3fd9acd3", size = 874003 }, + { url = "https://files.pythonhosted.org/packages/97/d4/4dd152dbbaac35d4e1fe8e8fd26d73640fcd84ec9c3915b545692df1ffb7/pyzmq-26.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:49334faa749d55b77f084389a80654bf2e68ab5191c0235066f0140c1b670d64", size = 867989 }, + { url = "https://files.pythonhosted.org/packages/a4/22/1c5dc761dff13981d27d8225aedb19e70ce9149d16cf0c97c7547570e986/pyzmq-26.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:fd30fc80fe96efb06bea21667c5793bbd65c0dc793187feb39b8f96990680b00", size = 1207989 }, + { url = "https://files.pythonhosted.org/packages/03/89/227ffb9e30b3fbe8196e7c97704345feb750b468e852ab64b0d19fa89e1a/pyzmq-26.3.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:b2eddfbbfb473a62c3a251bb737a6d58d91907f6e1d95791431ebe556f47d916", size = 1520523 }, + { url = "https://files.pythonhosted.org/packages/29/d3/e9b99b8404b6a470762cb947bc342e462a853a22ce0b0f2982c65a9b698f/pyzmq-26.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:70b3acb9ad729a53d4e751dace35404a024f188aad406013454216aba5485b4e", size = 1419912 }, + { url = "https://files.pythonhosted.org/packages/bb/69/074e2cde8135cae9452778e644ea5c91493bc536367d956005fe83072f63/pyzmq-26.3.0-cp310-cp310-win32.whl", hash = "sha256:c1bd75d692cd7c6d862a98013bfdf06702783b75cffbf5dae06d718fecefe8f2", size = 583733 }, + { url = "https://files.pythonhosted.org/packages/00/f0/55e57d40f6e21877e96507c0c2dd7e32afffc37b0dde7b834df1170cd749/pyzmq-26.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:d7165bcda0dbf203e5ad04d79955d223d84b2263df4db92f525ba370b03a12ab", size = 647229 }, + { url = "https://files.pythonhosted.org/packages/38/1d/6e935b5f06d674c931540b29932a0dd5e1b9d29d047c2764a9c8c6f3ce08/pyzmq-26.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:e34a63f71d2ecffb3c643909ad2d488251afeb5ef3635602b3448e609611a7ed", size = 561038 }, + { url = "https://files.pythonhosted.org/packages/22/75/774e9a4a4291864dd37a03a7bfaf46a82d61cd36c16edd33a5739ad49be3/pyzmq-26.3.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:2833602d9d42c94b9d0d2a44d2b382d3d3a4485be018ba19dddc401a464c617a", size = 1345893 }, + { url = "https://files.pythonhosted.org/packages/ca/51/d3eedd2bd46ef851bea528d8a2688a5091183b27fc238801fcac70e80dbb/pyzmq-26.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8270d104ec7caa0bdac246d31d48d94472033ceab5ba142881704350b28159c", size = 678261 }, + { url = "https://files.pythonhosted.org/packages/de/5e/521d7c6613769dcc3ed5e44e7082938b6dab27fffe02755784e54e98e17b/pyzmq-26.3.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c208a977843d18d3bd185f323e4eaa912eb4869cb230947dc6edd8a27a4e558a", size = 915311 }, + { url = "https://files.pythonhosted.org/packages/78/db/3be86dd82adc638a2eb07c3028c1747ead49a71d7d334980b007f593fd9f/pyzmq-26.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eddc2be28a379c218e0d92e4a432805dcb0ca5870156a90b54c03cd9799f9f8a", size = 873193 }, + { url = "https://files.pythonhosted.org/packages/63/1a/81a31920d5113113ccd50271649dd2d0cfcfe46925d8f8a196fe560ed0e6/pyzmq-26.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:c0b519fa2159c42272f8a244354a0e110d65175647e5185b04008ec00df9f079", size = 867648 }, + { url = "https://files.pythonhosted.org/packages/55/79/bbf57979ff2d89b5465d7205db08de7222d2560edc11272eb054c5a68cb5/pyzmq-26.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1595533de3a80bf8363372c20bafa963ec4bf9f2b8f539b1d9a5017f430b84c9", size = 1208475 }, + { url = "https://files.pythonhosted.org/packages/50/fc/1246dfc4b165e7ff97ac3c4117bdd3747e03ebb62269f71f65e216bfac8b/pyzmq-26.3.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bbef99eb8d18ba9a40f00e8836b8040cdcf0f2fa649684cf7a66339599919d21", size = 1519428 }, + { url = "https://files.pythonhosted.org/packages/5f/9a/143aacb6b372b0e2d812aec73a06fc5df3e169a361d4302226f8563954c6/pyzmq-26.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:979486d444ca3c469cd1c7f6a619ce48ff08b3b595d451937db543754bfacb65", size = 1419530 }, + { url = "https://files.pythonhosted.org/packages/47/f7/b437e77d496089e17e77866eb126dd97ea47041b58e53892f57e82869198/pyzmq-26.3.0-cp311-cp311-win32.whl", hash = "sha256:4b127cfe10b4c56e4285b69fd4b38ea1d368099ea4273d8fb349163fce3cd598", size = 582538 }, + { url = "https://files.pythonhosted.org/packages/a1/2c/99a01a2d7865aaf44e47c2182cbdbc15da1f2e4cfee92dc8e1fb5114f993/pyzmq-26.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:cf736cc1298ef15280d9fcf7a25c09b05af016656856dc6fe5626fd8912658dd", size = 647989 }, + { url = "https://files.pythonhosted.org/packages/60/b3/36ac1cb8fafeadff09935f4bdc1232e511af8f8893d6cebc7ceb93c6753a/pyzmq-26.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:2dc46ec09f5d36f606ac8393303149e69d17121beee13c8dac25e2a2078e31c4", size = 561533 }, + { url = "https://files.pythonhosted.org/packages/7b/03/7170c3814bb9106c1bca67700c731aaf1cd990fd2f0097c754acb600330e/pyzmq-26.3.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:c80653332c6136da7f4d4e143975e74ac0fa14f851f716d90583bc19e8945cea", size = 1348354 }, + { url = "https://files.pythonhosted.org/packages/74/f3/908b17f9111cdc764aef1de3d36026a2984c46ed90c3c2c85f28b66142f0/pyzmq-26.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e317ee1d4528a03506cb1c282cd9db73660a35b3564096de37de7350e7d87a7", size = 671056 }, + { url = "https://files.pythonhosted.org/packages/02/ad/afcb8484b65ceacd1609f709c2caeed31bd6c49261a7507cd5c175cc105f/pyzmq-26.3.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:943a22ebb3daacb45f76a9bcca9a7b74e7d94608c0c0505da30af900b998ca8d", size = 908597 }, + { url = "https://files.pythonhosted.org/packages/a1/b5/4eeeae0aaaa6ef0c74cfa8b2273b53382bd858df6d99485f2fc8211e7002/pyzmq-26.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fc9e71490d989144981ea21ef4fdfaa7b6aa84aff9632d91c736441ce2f6b00", size = 865260 }, + { url = "https://files.pythonhosted.org/packages/74/6a/63db856e93e3a3c3dc98a1de28a902cf1b21c7b0d3856cd5931d7cfd30af/pyzmq-26.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e281a8071a06888575a4eb523c4deeefdcd2f5fe4a2d47e02ac8bf3a5b49f695", size = 859916 }, + { url = "https://files.pythonhosted.org/packages/e1/ce/d522c9b46ee3746d4b98c81969c568c2c6296e931a65f2c87104b645654c/pyzmq-26.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:be77efd735bb1064605be8dec6e721141c1421ef0b115ef54e493a64e50e9a52", size = 1201368 }, + { url = "https://files.pythonhosted.org/packages/5a/56/29dcd3647a39e933eb489fda261a1e2700a59d4a9432889a85166e15651c/pyzmq-26.3.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:7a4ac2ffa34f1212dd586af90f4ba894e424f0cabb3a49cdcff944925640f6ac", size = 1512663 }, + { url = "https://files.pythonhosted.org/packages/6b/36/7c570698127a43398ed1b1832dada59496e633115016addbce5eda9938a6/pyzmq-26.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ba698c7c252af83b6bba9775035263f0df5f807f0404019916d4b71af8161f66", size = 1411693 }, + { url = "https://files.pythonhosted.org/packages/de/54/51d39bef85a7cdbca36227f7defdbfcdc5011b8361a3bfc0e8df431f5a5d/pyzmq-26.3.0-cp312-cp312-win32.whl", hash = "sha256:214038aaa88e801e54c2ef0cfdb2e6df27eb05f67b477380a452b595c5ecfa37", size = 581244 }, + { url = "https://files.pythonhosted.org/packages/f2/6a/9512b11a1d0c5648534f03d5ab0c3222f55dc9c192029c1cb00a0ca044e2/pyzmq-26.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:bad7fe0372e505442482ca3ccbc0d6f38dae81b1650f57a0aa6bbee18e7df495", size = 643559 }, + { url = "https://files.pythonhosted.org/packages/27/9f/faf5c9cf91b61eeb82a5e919d024d3ac28a795c92cce817be264ccd757d3/pyzmq-26.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:b7b578d604e79e99aa39495becea013fd043fa9f36e4b490efa951f3d847a24d", size = 557664 }, + { url = "https://files.pythonhosted.org/packages/37/16/97b8c5107bfccb39120e611671a452c9ff6e8626fb3f8d4c15afd652b6ae/pyzmq-26.3.0-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:fa85953df84beb7b8b73cb3ec3f5d92b62687a09a8e71525c6734e020edf56fd", size = 1345691 }, + { url = "https://files.pythonhosted.org/packages/a5/61/d5572d95040c0bb5b31eed5b23f3f0f992d94e4e0de0cea62e3c7f3a85c1/pyzmq-26.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:209d09f0ab6ddbcebe64630d1e6ca940687e736f443c265ae15bc4bfad833597", size = 670622 }, + { url = "https://files.pythonhosted.org/packages/1c/0c/f0235d27388aacf4ed8bcc1d574f6f2f629da0a20610faa0a8e9d363c2b0/pyzmq-26.3.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d35cc1086f1d4f907df85c6cceb2245cb39a04f69c3f375993363216134d76d4", size = 908683 }, + { url = "https://files.pythonhosted.org/packages/cb/52/664828f9586c396b857eec088d208230463e3dc991a24df6adbad98fbaa3/pyzmq-26.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b380e9087078ba91e45fb18cdd0c25275ffaa045cf63c947be0ddae6186bc9d9", size = 865212 }, + { url = "https://files.pythonhosted.org/packages/2b/14/213b2967030b7d7aecc32dd453830f98799b3cbf2b10a40232e9f22a6520/pyzmq-26.3.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6d64e74143587efe7c9522bb74d1448128fdf9897cc9b6d8b9927490922fd558", size = 860068 }, + { url = "https://files.pythonhosted.org/packages/aa/e5/ff50c8fade69d1c0469652832c626d1910668697642c10cb0e1b6183ef9a/pyzmq-26.3.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:efba4f53ac7752eea6d8ca38a4ddac579e6e742fba78d1e99c12c95cd2acfc64", size = 1201303 }, + { url = "https://files.pythonhosted.org/packages/9a/e2/fff5e483be95ccc11a05781323e001e63ec15daec1d0f6f08de72ca534db/pyzmq-26.3.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:9b0137a1c40da3b7989839f9b78a44de642cdd1ce20dcef341de174c8d04aa53", size = 1512892 }, + { url = "https://files.pythonhosted.org/packages/21/75/cc44d276e43136e5692e487c3c019f816e11ed445261e434217c28cc98c4/pyzmq-26.3.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a995404bd3982c089e57b428c74edd5bfc3b0616b3dbcd6a8e270f1ee2110f36", size = 1411736 }, + { url = "https://files.pythonhosted.org/packages/ee/1c/d070cbc9a7961fe772641c51bb3798d88cb1f8e20ca718407363462624cf/pyzmq-26.3.0-cp313-cp313-win32.whl", hash = "sha256:240b1634b9e530ef6a277d95cbca1a6922f44dfddc5f0a3cd6c722a8de867f14", size = 581214 }, + { url = "https://files.pythonhosted.org/packages/38/d3/91082f1151ff5b54e0bed40eb1a26f418530ab07ecaec4dbb83e3d9fa9a9/pyzmq-26.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:fe67291775ea4c2883764ba467eb389c29c308c56b86c1e19e49c9e1ed0cbeca", size = 643412 }, + { url = "https://files.pythonhosted.org/packages/e0/cf/dabe68dfdf3e67bea6152eeec4b251cf899ee5b853cfb5c97e4719f9e6e9/pyzmq-26.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:73ca9ae9a9011b714cf7650450cd9c8b61a135180b708904f1f0a05004543dce", size = 557444 }, + { url = "https://files.pythonhosted.org/packages/c0/56/e7576ac71c1566da4f4ec586351462a2bb202143fb074bf56df8fe85dcc3/pyzmq-26.3.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:fea7efbd7e49af9d7e5ed6c506dfc7de3d1a628790bd3a35fd0e3c904dc7d464", size = 1340288 }, + { url = "https://files.pythonhosted.org/packages/f1/ab/0bca97e94d420b5908968bc479e51c3686a9f80d8893450eefcd673b1b1d/pyzmq-26.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4430c7cba23bb0e2ee203eee7851c1654167d956fc6d4b3a87909ccaf3c5825", size = 662462 }, + { url = "https://files.pythonhosted.org/packages/ee/be/99e89b55863808da322ac3ab52d8e135dcf2241094aaa468bfe2923d5194/pyzmq-26.3.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:016d89bee8c7d566fad75516b4e53ec7c81018c062d4c51cd061badf9539be52", size = 896464 }, + { url = "https://files.pythonhosted.org/packages/38/d4/a4be06a313c8d6a5fe1d92975db30aca85f502e867fca392532e06a28c3c/pyzmq-26.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04bfe59852d76d56736bfd10ac1d49d421ab8ed11030b4a0332900691507f557", size = 853432 }, + { url = "https://files.pythonhosted.org/packages/12/e6/e608b4c34106bbf5b3b382662ea90a43b2e23df0aa9c1f0fd4e21168d523/pyzmq-26.3.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:1fe05bd0d633a0f672bb28cb8b4743358d196792e1caf04973b7898a0d70b046", size = 845884 }, + { url = "https://files.pythonhosted.org/packages/c3/a9/d5e6355308ba529d9cd3576ee8bb3b2e2b726571748f515fbb8559401f5b/pyzmq-26.3.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:2aa1a9f236d5b835fb8642f27de95f9edcfd276c4bc1b6ffc84f27c6fb2e2981", size = 1191454 }, + { url = "https://files.pythonhosted.org/packages/6a/9a/a21dc6c73ac242e425709c1e0049368d8f5db5de7c1102a45f93f5c492b3/pyzmq-26.3.0-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:21399b31753bf321043ea60c360ed5052cc7be20739785b1dff1820f819e35b3", size = 1500397 }, + { url = "https://files.pythonhosted.org/packages/87/88/0236056156da0278c9ca2e2562463643597808b5bbd6c34009ba217e7e92/pyzmq-26.3.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d015efcd96aca8882057e7e6f06224f79eecd22cad193d3e6a0a91ec67590d1f", size = 1398401 }, + { url = "https://files.pythonhosted.org/packages/7e/ec/2e02dde6b1a436b02a6c0e3cb64c779bf6e76cc41c12131f29d9b10a088f/pyzmq-26.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ad03f4252d9041b0635c37528dfa3f44b39f46024ae28c8567f7423676ee409b", size = 835672 }, + { url = "https://files.pythonhosted.org/packages/22/ee/30c2c3f162912cff31af2b9d87295533d16f867e7621bd6f9ed62d9cc807/pyzmq-26.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f3dfb68cf7bf4cfdf34283a75848e077c5defa4907506327282afe92780084d", size = 570837 }, + { url = "https://files.pythonhosted.org/packages/51/a5/5aead624f5f1033dab9bdaf3e2bc692a8042fcb59355c919a2c042061780/pyzmq-26.3.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:356ec0e39c5a9cda872b65aca1fd8a5d296ffdadf8e2442b70ff32e73ef597b1", size = 799508 }, + { url = "https://files.pythonhosted.org/packages/ca/8a/dcc0a24cfed80cc004abcba710077147ec9178a12865914e73a60a70cb62/pyzmq-26.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:749d671b0eec8e738bbf0b361168369d8c682b94fcd458c20741dc4d69ef5278", size = 758001 }, + { url = "https://files.pythonhosted.org/packages/1a/74/f18e63540340f5c740396eb6408d154a84e9f0e9e1ae931b192bf2aa7425/pyzmq-26.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f950f17ae608e0786298340163cac25a4c5543ef25362dd5ddb6dcb10b547be9", size = 556425 }, + { url = "https://files.pythonhosted.org/packages/f4/c6/e36b2a2ff6534cb1d1f6b3fb37901ac54675caf7b2e1239613aa40d1d217/pyzmq-26.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b4fc9903a73c25be9d5fe45c87faababcf3879445efa16140146b08fccfac017", size = 835670 }, + { url = "https://files.pythonhosted.org/packages/1d/b9/8059c5af94b245068e7f7379c08c7e409ec854139d6021aecf2c111d8547/pyzmq-26.3.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c15b69af22030960ac63567e98ad8221cddf5d720d9cf03d85021dfd452324ef", size = 570838 }, + { url = "https://files.pythonhosted.org/packages/80/a4/f0a4266ff2d94a87f7c32895b1716f9ac0edc0471d518462beeb0a9a94b5/pyzmq-26.3.0-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2cf9ab0dff4dbaa2e893eb608373c97eb908e53b7d9793ad00ccbd082c0ee12f", size = 799507 }, + { url = "https://files.pythonhosted.org/packages/78/14/3d7d459f496fab8e487b23423ccba57abf7153a4fde0c3e000500fa02ff8/pyzmq-26.3.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ec332675f6a138db57aad93ae6387953763f85419bdbd18e914cb279ee1c451", size = 758002 }, + { url = "https://files.pythonhosted.org/packages/22/65/cc1f0e1db1290770285430e36d51767e620487523e6a04094be637e55698/pyzmq-26.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:eb96568a22fe070590942cd4780950e2172e00fb033a8b76e47692583b1bd97c", size = 556425 }, +] + +[[package]] +name = "quartodoc" +version = "0.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "black" }, + { name = "click" }, + { name = "griffe" }, + { name = "importlib-metadata" }, + { name = "importlib-resources" }, + { name = "plum-dispatch" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "sphobjinv" }, + { name = "tabulate" }, + { name = "typing-extensions" }, + { name = "watchdog" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/ad/1bdc6745d0d0527da0a2f30a235850873e98442a2c1afdd67ac7e164e0c4/quartodoc-0.9.1.tar.gz", hash = "sha256:418d9ff0f2d4481a87e926e3a3e5bc31efbe556c7f36912aa0a3f716c0eafa9c", size = 772465 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/47/de4c28e2002653226de3e34c9a3e989619796e5f0fe771284c570a016cec/quartodoc-0.9.1-py3-none-any.whl", hash = "sha256:78345002f75f086be6e1b1ccf3b4e3ada2fa3affb8a8fc0dbdb37890a5da03fa", size = 84275 }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775 }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, +] + +[[package]] +name = "rich" +version = "13.9.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 }, +] + +[[package]] +name = "rpds-py" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/79/2ce611b18c4fd83d9e3aecb5cba93e1917c050f556db39842889fa69b79f/rpds_py-0.23.1.tar.gz", hash = "sha256:7f3240dcfa14d198dba24b8b9cb3b108c06b68d45b7babd9eefc1038fdf7e707", size = 26806 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/fe/e5326459863bd525122f4e9c80ac8d7c6cfa171b7518d04cc27c12c209b0/rpds_py-0.23.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2a54027554ce9b129fc3d633c92fa33b30de9f08bc61b32c053dc9b537266fed", size = 372123 }, + { url = "https://files.pythonhosted.org/packages/f9/db/f10a3795f7a89fb27594934012d21c61019bbeb516c5bdcfbbe9e9e617a7/rpds_py-0.23.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b5ef909a37e9738d146519657a1aab4584018746a18f71c692f2f22168ece40c", size = 356778 }, + { url = "https://files.pythonhosted.org/packages/21/27/0d3678ad7f432fa86f8fac5f5fc6496a4d2da85682a710d605219be20063/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ee9d6f0b38efb22ad94c3b68ffebe4c47865cdf4b17f6806d6c674e1feb4246", size = 385775 }, + { url = "https://files.pythonhosted.org/packages/99/a0/1786defa125b2ad228027f22dff26312ce7d1fee3c7c3c2682f403db2062/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f7356a6da0562190558c4fcc14f0281db191cdf4cb96e7604c06acfcee96df15", size = 391181 }, + { url = "https://files.pythonhosted.org/packages/f1/5c/1240934050a7ffd020a915486d0cc4c7f6e7a2442a77aedf13664db55d36/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9441af1d25aed96901f97ad83d5c3e35e6cd21a25ca5e4916c82d7dd0490a4fa", size = 444607 }, + { url = "https://files.pythonhosted.org/packages/b7/1b/cee6905b47817fd0a377716dbe4df35295de46df46ee2ff704538cc371b0/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d8abf7896a91fb97e7977d1aadfcc2c80415d6dc2f1d0fca5b8d0df247248f3", size = 445550 }, + { url = "https://files.pythonhosted.org/packages/54/f7/f0821ca34032892d7a67fcd5042f50074ff2de64e771e10df01085c88d47/rpds_py-0.23.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b08027489ba8fedde72ddd233a5ea411b85a6ed78175f40285bd401bde7466d", size = 386148 }, + { url = "https://files.pythonhosted.org/packages/eb/ef/2afe53bc857c4bcba336acfd2629883a5746e7291023e017ac7fc98d85aa/rpds_py-0.23.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fee513135b5a58f3bb6d89e48326cd5aa308e4bcdf2f7d59f67c861ada482bf8", size = 416780 }, + { url = "https://files.pythonhosted.org/packages/ae/9a/38d2236cf669789b8a3e1a014c9b6a8d7b8925b952c92e7839ae2749f9ac/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:35d5631ce0af26318dba0ae0ac941c534453e42f569011585cb323b7774502a5", size = 558265 }, + { url = "https://files.pythonhosted.org/packages/e6/0a/f2705530c42578f20ed0b5b90135eecb30eef6e2ba73e7ba69087fad2dba/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a20cb698c4a59c534c6701b1c24a968ff2768b18ea2991f886bd8985ce17a89f", size = 585270 }, + { url = "https://files.pythonhosted.org/packages/29/4e/3b597dc84ed82c3d757ac9aa620de224a94e06d2e102069795ae7e81c015/rpds_py-0.23.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e9c206a1abc27e0588cf8b7c8246e51f1a16a103734f7750830a1ccb63f557a", size = 553850 }, + { url = "https://files.pythonhosted.org/packages/00/cc/6498b6f79e4375e6737247661e52a2d18f6accf4910e0c8da978674b4241/rpds_py-0.23.1-cp310-cp310-win32.whl", hash = "sha256:d9f75a06ecc68f159d5d7603b734e1ff6daa9497a929150f794013aa9f6e3f12", size = 220660 }, + { url = "https://files.pythonhosted.org/packages/17/2b/08db023d23e8c7032c99d8d2a70d32e450a868ab73d16e3ff5290308a665/rpds_py-0.23.1-cp310-cp310-win_amd64.whl", hash = "sha256:f35eff113ad430b5272bbfc18ba111c66ff525828f24898b4e146eb479a2cdda", size = 232551 }, + { url = "https://files.pythonhosted.org/packages/1c/67/6e5d4234bb9dee062ffca2a5f3c7cd38716317d6760ec235b175eed4de2c/rpds_py-0.23.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b79f5ced71efd70414a9a80bbbfaa7160da307723166f09b69773153bf17c590", size = 372264 }, + { url = "https://files.pythonhosted.org/packages/a7/0a/3dedb2daee8e783622427f5064e2d112751d8276ee73aa5409f000a132f4/rpds_py-0.23.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c9e799dac1ffbe7b10c1fd42fe4cd51371a549c6e108249bde9cd1200e8f59b4", size = 356883 }, + { url = "https://files.pythonhosted.org/packages/ed/fc/e1acef44f9c24b05fe5434b235f165a63a52959ac655e3f7a55726cee1a4/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721f9c4011b443b6e84505fc00cc7aadc9d1743f1c988e4c89353e19c4a968ee", size = 385624 }, + { url = "https://files.pythonhosted.org/packages/97/0a/a05951f6465d01622720c03ef6ef31adfbe865653e05ed7c45837492f25e/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f88626e3f5e57432e6191cd0c5d6d6b319b635e70b40be2ffba713053e5147dd", size = 391500 }, + { url = "https://files.pythonhosted.org/packages/ea/2e/cca0583ec0690ea441dceae23c0673b99755710ea22f40bccf1e78f41481/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:285019078537949cecd0190f3690a0b0125ff743d6a53dfeb7a4e6787af154f5", size = 444869 }, + { url = "https://files.pythonhosted.org/packages/cc/e6/95cda68b33a6d814d1e96b0e406d231ed16629101460d1740e92f03365e6/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b92f5654157de1379c509b15acec9d12ecf6e3bc1996571b6cb82a4302060447", size = 444930 }, + { url = "https://files.pythonhosted.org/packages/5f/a7/e94cdb73411ae9c11414d3c7c9a6ad75d22ad4a8d094fb45a345ba9e3018/rpds_py-0.23.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e768267cbe051dd8d1c5305ba690bb153204a09bf2e3de3ae530de955f5b5580", size = 386254 }, + { url = "https://files.pythonhosted.org/packages/dd/c5/a4a943d90a39e85efd1e04b1ad5129936786f9a9aa27bb7be8fc5d9d50c9/rpds_py-0.23.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c5334a71f7dc1160382d45997e29f2637c02f8a26af41073189d79b95d3321f1", size = 417090 }, + { url = "https://files.pythonhosted.org/packages/0c/a0/80d0013b12428d1fce0ab4e71829400b0a32caec12733c79e6109f843342/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6adb81564af0cd428910f83fa7da46ce9ad47c56c0b22b50872bc4515d91966", size = 557639 }, + { url = "https://files.pythonhosted.org/packages/a6/92/ec2e6980afb964a2cd7a99cbdef1f6c01116abe94b42cbe336ac93dd11c2/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:cafa48f2133d4daa028473ede7d81cd1b9f9e6925e9e4003ebdf77010ee02f35", size = 584572 }, + { url = "https://files.pythonhosted.org/packages/3d/ce/75b6054db34a390789a82523790717b27c1bd735e453abb429a87c4f0f26/rpds_py-0.23.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0fced9fd4a07a1ded1bac7e961ddd9753dd5d8b755ba8e05acba54a21f5f1522", size = 553028 }, + { url = "https://files.pythonhosted.org/packages/cc/24/f45abe0418c06a5cba0f846e967aa27bac765acd927aabd857c21319b8cc/rpds_py-0.23.1-cp311-cp311-win32.whl", hash = "sha256:243241c95174b5fb7204c04595852fe3943cc41f47aa14c3828bc18cd9d3b2d6", size = 220862 }, + { url = "https://files.pythonhosted.org/packages/2d/a6/3c0880e8bbfc36451ef30dc416266f6d2934705e468db5d21c8ba0ab6400/rpds_py-0.23.1-cp311-cp311-win_amd64.whl", hash = "sha256:11dd60b2ffddba85715d8a66bb39b95ddbe389ad2cfcf42c833f1bcde0878eaf", size = 232953 }, + { url = "https://files.pythonhosted.org/packages/f3/8c/d17efccb9f5b9137ddea706664aebae694384ae1d5997c0202093e37185a/rpds_py-0.23.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3902df19540e9af4cc0c3ae75974c65d2c156b9257e91f5101a51f99136d834c", size = 364369 }, + { url = "https://files.pythonhosted.org/packages/6e/c0/ab030f696b5c573107115a88d8d73d80f03309e60952b64c584c70c659af/rpds_py-0.23.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:66f8d2a17e5838dd6fb9be6baaba8e75ae2f5fa6b6b755d597184bfcd3cb0eba", size = 349965 }, + { url = "https://files.pythonhosted.org/packages/b3/55/b40170f5a079c4fb0b6a82b299689e66e744edca3c3375a8b160fb797660/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:112b8774b0b4ee22368fec42749b94366bd9b536f8f74c3d4175d4395f5cbd31", size = 389064 }, + { url = "https://files.pythonhosted.org/packages/ab/1c/b03a912c59ec7c1e16b26e587b9dfa8ddff3b07851e781e8c46e908a365a/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0df046f2266e8586cf09d00588302a32923eb6386ced0ca5c9deade6af9a149", size = 397741 }, + { url = "https://files.pythonhosted.org/packages/52/6f/151b90792b62fb6f87099bcc9044c626881fdd54e31bf98541f830b15cea/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f3288930b947cbebe767f84cf618d2cbe0b13be476e749da0e6a009f986248c", size = 448784 }, + { url = "https://files.pythonhosted.org/packages/71/2a/6de67c0c97ec7857e0e9e5cd7c52405af931b303eb1e5b9eff6c50fd9a2e/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce473a2351c018b06dd8d30d5da8ab5a0831056cc53b2006e2a8028172c37ce5", size = 440203 }, + { url = "https://files.pythonhosted.org/packages/db/5e/e759cd1c276d98a4b1f464b17a9bf66c65d29f8f85754e27e1467feaa7c3/rpds_py-0.23.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d550d7e9e7d8676b183b37d65b5cd8de13676a738973d330b59dc8312df9c5dc", size = 391611 }, + { url = "https://files.pythonhosted.org/packages/1c/1e/2900358efcc0d9408c7289769cba4c0974d9db314aa884028ed7f7364f61/rpds_py-0.23.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e14f86b871ea74c3fddc9a40e947d6a5d09def5adc2076ee61fb910a9014fb35", size = 423306 }, + { url = "https://files.pythonhosted.org/packages/23/07/6c177e6d059f5d39689352d6c69a926ee4805ffdb6f06203570234d3d8f7/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf5be5ba34e19be579ae873da515a2836a2166d8d7ee43be6ff909eda42b72b", size = 562323 }, + { url = "https://files.pythonhosted.org/packages/70/e4/f9097fd1c02b516fff9850792161eb9fc20a2fd54762f3c69eae0bdb67cb/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d7031d493c4465dbc8d40bd6cafefef4bd472b17db0ab94c53e7909ee781b9ef", size = 588351 }, + { url = "https://files.pythonhosted.org/packages/87/39/5db3c6f326bfbe4576ae2af6435bd7555867d20ae690c786ff33659f293b/rpds_py-0.23.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:55ff4151cfd4bc635e51cfb1c59ac9f7196b256b12e3a57deb9e5742e65941ad", size = 557252 }, + { url = "https://files.pythonhosted.org/packages/fd/14/2d5ad292f144fa79bafb78d2eb5b8a3a91c358b6065443cb9c49b5d1fedf/rpds_py-0.23.1-cp312-cp312-win32.whl", hash = "sha256:a9d3b728f5a5873d84cba997b9d617c6090ca5721caaa691f3b1a78c60adc057", size = 222181 }, + { url = "https://files.pythonhosted.org/packages/a3/4f/0fce63e0f5cdd658e71e21abd17ac1bc9312741ebb8b3f74eeed2ebdf771/rpds_py-0.23.1-cp312-cp312-win_amd64.whl", hash = "sha256:b03a8d50b137ee758e4c73638b10747b7c39988eb8e6cd11abb7084266455165", size = 237426 }, + { url = "https://files.pythonhosted.org/packages/13/9d/b8b2c0edffb0bed15be17b6d5ab06216f2f47f9ee49259c7e96a3ad4ca42/rpds_py-0.23.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:4caafd1a22e5eaa3732acb7672a497123354bef79a9d7ceed43387d25025e935", size = 363672 }, + { url = "https://files.pythonhosted.org/packages/bd/c2/5056fa29e6894144d7ba4c938b9b0445f75836b87d2dd00ed4999dc45a8c/rpds_py-0.23.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:178f8a60fc24511c0eb756af741c476b87b610dba83270fce1e5a430204566a4", size = 349602 }, + { url = "https://files.pythonhosted.org/packages/b0/bc/33779a1bb0ee32d8d706b173825aab75c628521d23ce72a7c1e6a6852f86/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c632419c3870507ca20a37c8f8f5352317aca097639e524ad129f58c125c61c6", size = 388746 }, + { url = "https://files.pythonhosted.org/packages/62/0b/71db3e36b7780a619698ec82a9c87ab44ad7ca7f5480913e8a59ff76f050/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:698a79d295626ee292d1730bc2ef6e70a3ab135b1d79ada8fde3ed0047b65a10", size = 397076 }, + { url = "https://files.pythonhosted.org/packages/bb/2e/494398f613edf77ba10a916b1ddea2acce42ab0e3b62e2c70ffc0757ce00/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:271fa2184cf28bdded86bb6217c8e08d3a169fe0bbe9be5e8d96e8476b707122", size = 448399 }, + { url = "https://files.pythonhosted.org/packages/dd/53/4bd7f5779b1f463243ee5fdc83da04dd58a08f86e639dbffa7a35f969a84/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b91cceb5add79ee563bd1f70b30896bd63bc5f78a11c1f00a1e931729ca4f1f4", size = 439764 }, + { url = "https://files.pythonhosted.org/packages/f6/55/b3c18c04a460d951bf8e91f2abf46ce5b6426fb69784166a6a25827cb90a/rpds_py-0.23.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a6cb95074777f1ecda2ca4fa7717caa9ee6e534f42b7575a8f0d4cb0c24013", size = 390662 }, + { url = "https://files.pythonhosted.org/packages/2a/65/cc463044a3cbd616029b2aa87a651cdee8288d2fdd7780b2244845e934c1/rpds_py-0.23.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:50fb62f8d8364978478b12d5f03bf028c6bc2af04082479299139dc26edf4c64", size = 422680 }, + { url = "https://files.pythonhosted.org/packages/fa/8e/1fa52990c7836d72e8d70cd7753f2362c72fbb0a49c1462e8c60e7176d0b/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8f7e90b948dc9dcfff8003f1ea3af08b29c062f681c05fd798e36daa3f7e3e8", size = 561792 }, + { url = "https://files.pythonhosted.org/packages/57/b8/fe3b612979b1a29d0c77f8585903d8b3a292604b26d4b300e228b8ac6360/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5b98b6c953e5c2bda51ab4d5b4f172617d462eebc7f4bfdc7c7e6b423f6da957", size = 588127 }, + { url = "https://files.pythonhosted.org/packages/44/2d/fde474de516bbc4b9b230f43c98e7f8acc5da7fc50ceed8e7af27553d346/rpds_py-0.23.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2893d778d4671ee627bac4037a075168b2673c57186fb1a57e993465dbd79a93", size = 556981 }, + { url = "https://files.pythonhosted.org/packages/18/57/767deeb27b81370bbab8f74ef6e68d26c4ea99018f3c71a570e506fede85/rpds_py-0.23.1-cp313-cp313-win32.whl", hash = "sha256:2cfa07c346a7ad07019c33fb9a63cf3acb1f5363c33bc73014e20d9fe8b01cdd", size = 221936 }, + { url = "https://files.pythonhosted.org/packages/7d/6c/3474cfdd3cafe243f97ab8474ea8949236eb2a1a341ca55e75ce00cd03da/rpds_py-0.23.1-cp313-cp313-win_amd64.whl", hash = "sha256:3aaf141d39f45322e44fc2c742e4b8b4098ead5317e5f884770c8df0c332da70", size = 237145 }, + { url = "https://files.pythonhosted.org/packages/ec/77/e985064c624230f61efa0423759bb066da56ebe40c654f8b5ba225bd5d63/rpds_py-0.23.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:759462b2d0aa5a04be5b3e37fb8183615f47014ae6b116e17036b131985cb731", size = 359623 }, + { url = "https://files.pythonhosted.org/packages/62/d9/a33dcbf62b29e40559e012d525bae7d516757cf042cc9234bd34ca4b6aeb/rpds_py-0.23.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3e9212f52074fc9d72cf242a84063787ab8e21e0950d4d6709886fb62bcb91d5", size = 345900 }, + { url = "https://files.pythonhosted.org/packages/92/eb/f81a4be6397861adb2cb868bb6a28a33292c2dcac567d1dc575226055e55/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9e9f3a3ac919406bc0414bbbd76c6af99253c507150191ea79fab42fdb35982a", size = 386426 }, + { url = "https://files.pythonhosted.org/packages/09/47/1f810c9b5e83be005341201b5389f1d240dfa440346ea7189f9b3fd6961d/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c04ca91dda8a61584165825907f5c967ca09e9c65fe8966ee753a3f2b019fe1e", size = 392314 }, + { url = "https://files.pythonhosted.org/packages/83/bd/bc95831432fd6c46ed8001f01af26de0763a059d6d7e6d69e3c5bf02917a/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ab923167cfd945abb9b51a407407cf19f5bee35001221f2911dc85ffd35ff4f", size = 447706 }, + { url = "https://files.pythonhosted.org/packages/19/3e/567c04c226b1802dc6dc82cad3d53e1fa0a773258571c74ac5d8fbde97ed/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed6f011bedca8585787e5082cce081bac3d30f54520097b2411351b3574e1219", size = 437060 }, + { url = "https://files.pythonhosted.org/packages/fe/77/a77d2c6afe27ae7d0d55fc32f6841502648070dc8d549fcc1e6d47ff8975/rpds_py-0.23.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6959bb9928c5c999aba4a3f5a6799d571ddc2c59ff49917ecf55be2bbb4e3722", size = 389347 }, + { url = "https://files.pythonhosted.org/packages/3f/47/6b256ff20a74cfebeac790ab05586e0ac91f88e331125d4740a6c86fc26f/rpds_py-0.23.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1ed7de3c86721b4e83ac440751329ec6a1102229aa18163f84c75b06b525ad7e", size = 415554 }, + { url = "https://files.pythonhosted.org/packages/fc/29/d4572469a245bc9fc81e35166dca19fc5298d5c43e1a6dd64bf145045193/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5fb89edee2fa237584e532fbf78f0ddd1e49a47c7c8cfa153ab4849dc72a35e6", size = 557418 }, + { url = "https://files.pythonhosted.org/packages/9c/0a/68cf7228895b1a3f6f39f51b15830e62456795e61193d2c8b87fd48c60db/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7e5413d2e2d86025e73f05510ad23dad5950ab8417b7fc6beaad99be8077138b", size = 583033 }, + { url = "https://files.pythonhosted.org/packages/14/18/017ab41dcd6649ad5db7d00155b4c212b31ab05bd857d5ba73a1617984eb/rpds_py-0.23.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d31ed4987d72aabdf521eddfb6a72988703c091cfc0064330b9e5f8d6a042ff5", size = 554880 }, + { url = "https://files.pythonhosted.org/packages/2e/dd/17de89431268da8819d8d51ce67beac28d9b22fccf437bc5d6d2bcd1acdb/rpds_py-0.23.1-cp313-cp313t-win32.whl", hash = "sha256:f3429fb8e15b20961efca8c8b21432623d85db2228cc73fe22756c6637aa39e7", size = 219743 }, + { url = "https://files.pythonhosted.org/packages/68/15/6d22d07e063ce5e9bfbd96db9ec2fbb4693591b4503e3a76996639474d02/rpds_py-0.23.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d6f6512a90bd5cd9030a6237f5346f046c6f0e40af98657568fa45695d4de59d", size = 235415 }, + { url = "https://files.pythonhosted.org/packages/95/a9/6fafd35fc6bac05f59bcbc800b57cef877911ff1c015397c519fec888642/rpds_py-0.23.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c1f8afa346ccd59e4e5630d5abb67aba6a9812fddf764fd7eb11f382a345f8cc", size = 373463 }, + { url = "https://files.pythonhosted.org/packages/5b/ac/44f00029b8fbe0903a19e9a87a9b86063bf8700df2cc58868373d378418c/rpds_py-0.23.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fad784a31869747df4ac968a351e070c06ca377549e4ace94775aaa3ab33ee06", size = 358400 }, + { url = "https://files.pythonhosted.org/packages/5e/9c/3da199346c68d785f10dccab123b74c8c5f73be3f742c9e33d1116e07931/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5a96fcac2f18e5a0a23a75cd27ce2656c66c11c127b0318e508aab436b77428", size = 386815 }, + { url = "https://files.pythonhosted.org/packages/d3/45/8f6533c33c0d33da8c2c8b2fb8f2ee90b23c05c679b86b0ac6aee4653749/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3e77febf227a1dc3220159355dba68faa13f8dca9335d97504abf428469fb18b", size = 392974 }, + { url = "https://files.pythonhosted.org/packages/ca/56/6a9ac1bf0455ba07385d8fe98c571c519b4f2000cff6581487bf9fab9272/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:26bb3e8de93443d55e2e748e9fd87deb5f8075ca7bc0502cfc8be8687d69a2ec", size = 446019 }, + { url = "https://files.pythonhosted.org/packages/f4/83/5d9a3f9731cdccf49088bcc4ce821a5cf50bd1737cdad83e9959a7b9054d/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:db7707dde9143a67b8812c7e66aeb2d843fe33cc8e374170f4d2c50bd8f2472d", size = 445811 }, + { url = "https://files.pythonhosted.org/packages/44/50/f2e0a98c62fc1fe68b176caca587714dc5c8bb2c3d1dd1eeb2bd4cc787ac/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1eedaaccc9bb66581d4ae7c50e15856e335e57ef2734dbc5fd8ba3e2a4ab3cb6", size = 388070 }, + { url = "https://files.pythonhosted.org/packages/f2/d0/4981878f8f157e6dbea01d95e0119bf3d6b4c2c884fe64a9e6987f941104/rpds_py-0.23.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28358c54fffadf0ae893f6c1050e8f8853e45df22483b7fff2f6ab6152f5d8bf", size = 419173 }, + { url = "https://files.pythonhosted.org/packages/ce/13/fc971c470da96b270d2f64fedee987351bd935dc3016932a5cdcb1a88a2a/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:633462ef7e61d839171bf206551d5ab42b30b71cac8f10a64a662536e057fdef", size = 559048 }, + { url = "https://files.pythonhosted.org/packages/42/02/be91e1de139ec8b4f9fec4192fd779ba48af281cfc762c0ca4c15b945484/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a98f510d86f689fcb486dc59e6e363af04151e5260ad1bdddb5625c10f1e95f8", size = 584773 }, + { url = "https://files.pythonhosted.org/packages/27/28/3af8a1956df3edc41d884267d766dc096496dafc83f02f764a475eca0b4a/rpds_py-0.23.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e0397dd0b3955c61ef9b22838144aa4bef6f0796ba5cc8edfc64d468b93798b4", size = 555153 }, + { url = "https://files.pythonhosted.org/packages/5e/bb/e45f51c4e1327dea3c72b846c6de129eebacb7a6cb309af7af35d0578c80/rpds_py-0.23.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:75307599f0d25bf6937248e5ac4e3bde5ea72ae6618623b86146ccc7845ed00b", size = 233827 }, +] + +[[package]] +name = "ruff" +version = "0.11.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a0/ab/be73f46695c350147ffbfd98d42f34bfe370e6b4146bb0bfdc5b3c636fc7/ruff-0.11.1.tar.gz", hash = "sha256:f2e209a283c9fa423e268cad015ec4fb249178608f755fb67491ff175ecbffbf", size = 3850423 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/09/fa72b32fb7a1f670c8d3cb925910447c496117850c6aa1601365ad11cd00/ruff-0.11.1-py3-none-linux_armv6l.whl", hash = "sha256:9c833671aaefcbe280aa54da387264402ffbb1e513ff3420c9c7265ea56d6c5c", size = 10114855 }, + { url = "https://files.pythonhosted.org/packages/fa/c2/544da7ee0bf0a28117218065ccac69683d8d7a885544e6c84076cf72351b/ruff-0.11.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a5a57cd457764228c73066b832040728b02a3837c53c8a781a960b68129c4e0b", size = 10870287 }, + { url = "https://files.pythonhosted.org/packages/ee/56/0d1c0a3f3ab644e813f365c7eee5d0f9b75e755c5642400cd6ad7070f730/ruff-0.11.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:da91da0d42e70cd8bda8e6687fab2afd28513a3cc9434539f4149610e63baf8f", size = 10223642 }, + { url = "https://files.pythonhosted.org/packages/d6/7c/88f06c23018ca02b8b0f78b62e4c701faa2ef6413d9f5e82277bc094d2e9/ruff-0.11.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:429a2e533e3a0dba2ba7e0608a736e728150aa9b6d179245aa11a1339baa968b", size = 10384382 }, + { url = "https://files.pythonhosted.org/packages/67/55/15d2a355e4c64a712938df4c650d7239128865981eb8314a49782a53ef45/ruff-0.11.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6bbcc2984a4d5cbc0f7b10409e74a00a043be45d813e5e81eb58e707455df7f1", size = 9965192 }, + { url = "https://files.pythonhosted.org/packages/39/e8/4312a514fac213e90e5b45120339dbaa95a396f4cf3ab740e757fed4fa35/ruff-0.11.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88d9c283ebc88faa5bc23fa33f399b6d47a93f5980c92edcddf1f2127aa376b3", size = 11563312 }, + { url = "https://files.pythonhosted.org/packages/69/ff/4da09bea58e1d784f45169fd281643422727a1c0776802cd6d4b42a0037d/ruff-0.11.1-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1f2b03d504516d6b22065ce7fac2564dac15d79a6a776452dabfdd7673a45b07", size = 12223815 }, + { url = "https://files.pythonhosted.org/packages/ec/ba/7e3550f1478a53c4f7efcb0c31a03256eb032a871026da61324ad06dcd0b/ruff-0.11.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:52b95a9071f5ad8552af890bd814c6a04daf5b27297ac1054e3667016f3ab739", size = 11662551 }, + { url = "https://files.pythonhosted.org/packages/7d/69/7e2f1c8a0c76de18f9c054382d31c6d5f9b55a3e476b2630fefe289d31a6/ruff-0.11.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28e2d89e7ba8a1525cdb50bc86c07aba35e7bbeef86dad93781b14ad94dc732c", size = 13792940 }, + { url = "https://files.pythonhosted.org/packages/02/4b/14f54bbf8f8dd03cb9a8a0294e7de1dc41f3be1806af07b8a104761db597/ruff-0.11.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e76be5a98dc6c29d85dfa72eb419e8d9276ee96ccf5c33f2b6828001907dcb17", size = 11328700 }, + { url = "https://files.pythonhosted.org/packages/f5/0c/40c1ba7e9a8c2c7325267c214746b80da1b54fb7e70a9265608213f4b2fb/ruff-0.11.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:441f94c44fe250691c92382ef84f40acef290766fb3e819a9035e83eadd4dbbe", size = 10272650 }, + { url = "https://files.pythonhosted.org/packages/a3/27/f86b786e0153c5b52768370f395086c4523dee1af37757a8ef73779b9fbd/ruff-0.11.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:62882a4cc7c0a48c2f34189bd4c7ba45f3d0efb990e02413eeb180aa042a39ca", size = 9973454 }, + { url = "https://files.pythonhosted.org/packages/ab/46/47bf0c7ee80b0476226865d724ee7682323a2cb20aa5d134b8a665f58793/ruff-0.11.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:111dbad1706d8200a7138237b4766b45ba7ee45cc8299c02102f4327624f86a2", size = 10975303 }, + { url = "https://files.pythonhosted.org/packages/9d/9d/deea8ece99f31aef07f378f83b5571baca74dff0d28fec720e54b171b862/ruff-0.11.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e2df41763d7a9fd438b6b7bde7b75eb3a92ef2f4682ed2d8e4b997b5f0c76ca9", size = 11402605 }, + { url = "https://files.pythonhosted.org/packages/b8/8c/f11e21f4a5ce0858c35745d43e9a5abd870ed33e151ada23c124bf433e71/ruff-0.11.1-py3-none-win32.whl", hash = "sha256:e17b85919d461583aa7e0171bb4f419a6545b261ca080984db49b1f8dced1d4b", size = 10335500 }, + { url = "https://files.pythonhosted.org/packages/21/c9/ac2784bad48c7a8702d2f13851b69b2a08534b59657ee2b724f42aaaf861/ruff-0.11.1-py3-none-win_amd64.whl", hash = "sha256:caa872941b876f7ad73abc60144f9a7f6efb575e4f91c4fc1517f0339bcea01e", size = 11365097 }, + { url = "https://files.pythonhosted.org/packages/9e/7d/f37251c102cf155cdf664322f1f362f4fd8fe1eb6870e9154255d3cbf0d8/ruff-0.11.1-py3-none-win_arm64.whl", hash = "sha256:7aa939fa57ef6770d18bd5cf0d6de77198dd762a559bd0d4a8763bdae4c8cc16", size = 10510306 }, +] + +[[package]] +name = "scipy" +version = "1.15.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/b9/31ba9cd990e626574baf93fbc1ac61cf9ed54faafd04c479117517661637/scipy-1.15.2.tar.gz", hash = "sha256:cd58a314d92838f7e6f755c8a2167ead4f27e1fd5c1251fd54289569ef3495ec", size = 59417316 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/df/ef233fff6838fe6f7840d69b5ef9f20d2b5c912a8727b21ebf876cb15d54/scipy-1.15.2-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a2ec871edaa863e8213ea5df811cd600734f6400b4af272e1c011e69401218e9", size = 38692502 }, + { url = "https://files.pythonhosted.org/packages/5c/20/acdd4efb8a68b842968f7bc5611b1aeb819794508771ad104de418701422/scipy-1.15.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:6f223753c6ea76983af380787611ae1291e3ceb23917393079dcc746ba60cfb5", size = 30085508 }, + { url = "https://files.pythonhosted.org/packages/42/55/39cf96ca7126f1e78ee72a6344ebdc6702fc47d037319ad93221063e6cf4/scipy-1.15.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:ecf797d2d798cf7c838c6d98321061eb3e72a74710e6c40540f0e8087e3b499e", size = 22359166 }, + { url = "https://files.pythonhosted.org/packages/51/48/708d26a4ab8a1441536bf2dfcad1df0ca14a69f010fba3ccbdfc02df7185/scipy-1.15.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:9b18aa747da280664642997e65aab1dd19d0c3d17068a04b3fe34e2559196cb9", size = 25112047 }, + { url = "https://files.pythonhosted.org/packages/dd/65/f9c5755b995ad892020381b8ae11f16d18616208e388621dfacc11df6de6/scipy-1.15.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87994da02e73549dfecaed9e09a4f9d58a045a053865679aeb8d6d43747d4df3", size = 35536214 }, + { url = "https://files.pythonhosted.org/packages/de/3c/c96d904b9892beec978562f64d8cc43f9cca0842e65bd3cd1b7f7389b0ba/scipy-1.15.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69ea6e56d00977f355c0f84eba69877b6df084516c602d93a33812aa04d90a3d", size = 37646981 }, + { url = "https://files.pythonhosted.org/packages/3d/74/c2d8a24d18acdeae69ed02e132b9bc1bb67b7bee90feee1afe05a68f9d67/scipy-1.15.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:888307125ea0c4466287191e5606a2c910963405ce9671448ff9c81c53f85f58", size = 37230048 }, + { url = "https://files.pythonhosted.org/packages/42/19/0aa4ce80eca82d487987eff0bc754f014dec10d20de2f66754fa4ea70204/scipy-1.15.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9412f5e408b397ff5641080ed1e798623dbe1ec0d78e72c9eca8992976fa65aa", size = 40010322 }, + { url = "https://files.pythonhosted.org/packages/d0/d2/f0683b7e992be44d1475cc144d1f1eeae63c73a14f862974b4db64af635e/scipy-1.15.2-cp310-cp310-win_amd64.whl", hash = "sha256:b5e025e903b4f166ea03b109bb241355b9c42c279ea694d8864d033727205e65", size = 41233385 }, + { url = "https://files.pythonhosted.org/packages/40/1f/bf0a5f338bda7c35c08b4ed0df797e7bafe8a78a97275e9f439aceb46193/scipy-1.15.2-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:92233b2df6938147be6fa8824b8136f29a18f016ecde986666be5f4d686a91a4", size = 38703651 }, + { url = "https://files.pythonhosted.org/packages/de/54/db126aad3874601048c2c20ae3d8a433dbfd7ba8381551e6f62606d9bd8e/scipy-1.15.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:62ca1ff3eb513e09ed17a5736929429189adf16d2d740f44e53270cc800ecff1", size = 30102038 }, + { url = "https://files.pythonhosted.org/packages/61/d8/84da3fffefb6c7d5a16968fe5b9f24c98606b165bb801bb0b8bc3985200f/scipy-1.15.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4c6676490ad76d1c2894d77f976144b41bd1a4052107902238047fb6a473e971", size = 22375518 }, + { url = "https://files.pythonhosted.org/packages/44/78/25535a6e63d3b9c4c90147371aedb5d04c72f3aee3a34451f2dc27c0c07f/scipy-1.15.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:a8bf5cb4a25046ac61d38f8d3c3426ec11ebc350246a4642f2f315fe95bda655", size = 25142523 }, + { url = "https://files.pythonhosted.org/packages/e0/22/4b4a26fe1cd9ed0bc2b2cb87b17d57e32ab72c346949eaf9288001f8aa8e/scipy-1.15.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a8e34cf4c188b6dd004654f88586d78f95639e48a25dfae9c5e34a6dc34547e", size = 35491547 }, + { url = "https://files.pythonhosted.org/packages/32/ea/564bacc26b676c06a00266a3f25fdfe91a9d9a2532ccea7ce6dd394541bc/scipy-1.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28a0d2c2075946346e4408b211240764759e0fabaeb08d871639b5f3b1aca8a0", size = 37634077 }, + { url = "https://files.pythonhosted.org/packages/43/c2/bfd4e60668897a303b0ffb7191e965a5da4056f0d98acfb6ba529678f0fb/scipy-1.15.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:42dabaaa798e987c425ed76062794e93a243be8f0f20fff6e7a89f4d61cb3d40", size = 37231657 }, + { url = "https://files.pythonhosted.org/packages/4a/75/5f13050bf4f84c931bcab4f4e83c212a36876c3c2244475db34e4b5fe1a6/scipy-1.15.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6f5e296ec63c5da6ba6fa0343ea73fd51b8b3e1a300b0a8cae3ed4b1122c7462", size = 40035857 }, + { url = "https://files.pythonhosted.org/packages/b9/8b/7ec1832b09dbc88f3db411f8cdd47db04505c4b72c99b11c920a8f0479c3/scipy-1.15.2-cp311-cp311-win_amd64.whl", hash = "sha256:597a0c7008b21c035831c39927406c6181bcf8f60a73f36219b69d010aa04737", size = 41217654 }, + { url = "https://files.pythonhosted.org/packages/4b/5d/3c78815cbab499610f26b5bae6aed33e227225a9fa5290008a733a64f6fc/scipy-1.15.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c4697a10da8f8765bb7c83e24a470da5797e37041edfd77fd95ba3811a47c4fd", size = 38756184 }, + { url = "https://files.pythonhosted.org/packages/37/20/3d04eb066b471b6e171827548b9ddb3c21c6bbea72a4d84fc5989933910b/scipy-1.15.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:869269b767d5ee7ea6991ed7e22b3ca1f22de73ab9a49c44bad338b725603301", size = 30163558 }, + { url = "https://files.pythonhosted.org/packages/a4/98/e5c964526c929ef1f795d4c343b2ff98634ad2051bd2bbadfef9e772e413/scipy-1.15.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:bad78d580270a4d32470563ea86c6590b465cb98f83d760ff5b0990cb5518a93", size = 22437211 }, + { url = "https://files.pythonhosted.org/packages/1d/cd/1dc7371e29195ecbf5222f9afeedb210e0a75057d8afbd942aa6cf8c8eca/scipy-1.15.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:b09ae80010f52efddb15551025f9016c910296cf70adbf03ce2a8704f3a5ad20", size = 25232260 }, + { url = "https://files.pythonhosted.org/packages/f0/24/1a181a9e5050090e0b5138c5f496fee33293c342b788d02586bc410c6477/scipy-1.15.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5a6fd6eac1ce74a9f77a7fc724080d507c5812d61e72bd5e4c489b042455865e", size = 35198095 }, + { url = "https://files.pythonhosted.org/packages/c0/53/eaada1a414c026673eb983f8b4a55fe5eb172725d33d62c1b21f63ff6ca4/scipy-1.15.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b871df1fe1a3ba85d90e22742b93584f8d2b8e6124f8372ab15c71b73e428b8", size = 37297371 }, + { url = "https://files.pythonhosted.org/packages/e9/06/0449b744892ed22b7e7b9a1994a866e64895363572677a316a9042af1fe5/scipy-1.15.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:03205d57a28e18dfd39f0377d5002725bf1f19a46f444108c29bdb246b6c8a11", size = 36872390 }, + { url = "https://files.pythonhosted.org/packages/6a/6f/a8ac3cfd9505ec695c1bc35edc034d13afbd2fc1882a7c6b473e280397bb/scipy-1.15.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:601881dfb761311045b03114c5fe718a12634e5608c3b403737ae463c9885d53", size = 39700276 }, + { url = "https://files.pythonhosted.org/packages/f5/6f/e6e5aff77ea2a48dd96808bb51d7450875af154ee7cbe72188afb0b37929/scipy-1.15.2-cp312-cp312-win_amd64.whl", hash = "sha256:e7c68b6a43259ba0aab737237876e5c2c549a031ddb7abc28c7b47f22e202ded", size = 40942317 }, + { url = "https://files.pythonhosted.org/packages/53/40/09319f6e0f276ea2754196185f95cd191cb852288440ce035d5c3a931ea2/scipy-1.15.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01edfac9f0798ad6b46d9c4c9ca0e0ad23dbf0b1eb70e96adb9fa7f525eff0bf", size = 38717587 }, + { url = "https://files.pythonhosted.org/packages/fe/c3/2854f40ecd19585d65afaef601e5e1f8dbf6758b2f95b5ea93d38655a2c6/scipy-1.15.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:08b57a9336b8e79b305a143c3655cc5bdbe6d5ece3378578888d2afbb51c4e37", size = 30100266 }, + { url = "https://files.pythonhosted.org/packages/dd/b1/f9fe6e3c828cb5930b5fe74cb479de5f3d66d682fa8adb77249acaf545b8/scipy-1.15.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:54c462098484e7466362a9f1672d20888f724911a74c22ae35b61f9c5919183d", size = 22373768 }, + { url = "https://files.pythonhosted.org/packages/15/9d/a60db8c795700414c3f681908a2b911e031e024d93214f2d23c6dae174ab/scipy-1.15.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:cf72ff559a53a6a6d77bd8eefd12a17995ffa44ad86c77a5df96f533d4e6c6bb", size = 25154719 }, + { url = "https://files.pythonhosted.org/packages/37/3b/9bda92a85cd93f19f9ed90ade84aa1e51657e29988317fabdd44544f1dd4/scipy-1.15.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9de9d1416b3d9e7df9923ab23cd2fe714244af10b763975bea9e4f2e81cebd27", size = 35163195 }, + { url = "https://files.pythonhosted.org/packages/03/5a/fc34bf1aa14dc7c0e701691fa8685f3faec80e57d816615e3625f28feb43/scipy-1.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb530e4794fc8ea76a4a21ccb67dea33e5e0e60f07fc38a49e821e1eae3b71a0", size = 37255404 }, + { url = "https://files.pythonhosted.org/packages/4a/71/472eac45440cee134c8a180dbe4c01b3ec247e0338b7c759e6cd71f199a7/scipy-1.15.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5ea7ed46d437fc52350b028b1d44e002646e28f3e8ddc714011aaf87330f2f32", size = 36860011 }, + { url = "https://files.pythonhosted.org/packages/01/b3/21f890f4f42daf20e4d3aaa18182dddb9192771cd47445aaae2e318f6738/scipy-1.15.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:11e7ad32cf184b74380f43d3c0a706f49358b904fa7d5345f16ddf993609184d", size = 39657406 }, + { url = "https://files.pythonhosted.org/packages/0d/76/77cf2ac1f2a9cc00c073d49e1e16244e389dd88e2490c91d84e1e3e4d126/scipy-1.15.2-cp313-cp313-win_amd64.whl", hash = "sha256:a5080a79dfb9b78b768cebf3c9dcbc7b665c5875793569f48bf0e2b1d7f68f6f", size = 40961243 }, + { url = "https://files.pythonhosted.org/packages/4c/4b/a57f8ddcf48e129e6054fa9899a2a86d1fc6b07a0e15c7eebff7ca94533f/scipy-1.15.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:447ce30cee6a9d5d1379087c9e474628dab3db4a67484be1b7dc3196bfb2fac9", size = 38870286 }, + { url = "https://files.pythonhosted.org/packages/0c/43/c304d69a56c91ad5f188c0714f6a97b9c1fed93128c691148621274a3a68/scipy-1.15.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:c90ebe8aaa4397eaefa8455a8182b164a6cc1d59ad53f79943f266d99f68687f", size = 30141634 }, + { url = "https://files.pythonhosted.org/packages/44/1a/6c21b45d2548eb73be9b9bff421aaaa7e85e22c1f9b3bc44b23485dfce0a/scipy-1.15.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:def751dd08243934c884a3221156d63e15234a3155cf25978b0a668409d45eb6", size = 22415179 }, + { url = "https://files.pythonhosted.org/packages/74/4b/aefac4bba80ef815b64f55da06f62f92be5d03b467f2ce3668071799429a/scipy-1.15.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:302093e7dfb120e55515936cb55618ee0b895f8bcaf18ff81eca086c17bd80af", size = 25126412 }, + { url = "https://files.pythonhosted.org/packages/b1/53/1cbb148e6e8f1660aacd9f0a9dfa2b05e9ff1cb54b4386fe868477972ac2/scipy-1.15.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd5b77413e1855351cdde594eca99c1f4a588c2d63711388b6a1f1c01f62274", size = 34952867 }, + { url = "https://files.pythonhosted.org/packages/2c/23/e0eb7f31a9c13cf2dca083828b97992dd22f8184c6ce4fec5deec0c81fcf/scipy-1.15.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d0194c37037707b2afa7a2f2a924cf7bac3dc292d51b6a925e5fcb89bc5c776", size = 36890009 }, + { url = "https://files.pythonhosted.org/packages/03/f3/e699e19cabe96bbac5189c04aaa970718f0105cff03d458dc5e2b6bd1e8c/scipy-1.15.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:bae43364d600fdc3ac327db99659dcb79e6e7ecd279a75fe1266669d9a652828", size = 36545159 }, + { url = "https://files.pythonhosted.org/packages/af/f5/ab3838e56fe5cc22383d6fcf2336e48c8fe33e944b9037fbf6cbdf5a11f8/scipy-1.15.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f031846580d9acccd0044efd1a90e6f4df3a6e12b4b6bd694a7bc03a89892b28", size = 39136566 }, + { url = "https://files.pythonhosted.org/packages/0a/c8/b3f566db71461cabd4b2d5b39bcc24a7e1c119535c8361f81426be39bb47/scipy-1.15.2-cp313-cp313t-win_amd64.whl", hash = "sha256:fe8a9eb875d430d81755472c5ba75e84acc980e4a8f6204d402849234d3017db", size = 40477705 }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/7b/af302bebf22c749c56c9c3e8ae13190b5b5db37a33d9068652e8f73b7089/snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1", size = 86699 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", size = 93002 }, +] + +[[package]] +name = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 }, +] + +[[package]] +name = "soupsieve" +version = "2.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186 }, +] + +[[package]] +name = "sphinx" +version = "8.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "alabaster" }, + { name = "babel" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "docutils" }, + { name = "imagesize" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "requests" }, + { name = "snowballstemmer" }, + { name = "sphinxcontrib-applehelp" }, + { name = "sphinxcontrib-devhelp" }, + { name = "sphinxcontrib-htmlhelp" }, + { name = "sphinxcontrib-jsmath" }, + { name = "sphinxcontrib-qthelp" }, + { name = "sphinxcontrib-serializinghtml" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125 }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300 }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530 }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705 }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071 }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743 }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072 }, +] + +[[package]] +name = "sphobjinv" +version = "2.3.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "certifi" }, + { name = "jsonschema" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8c/5e/cf2c54fcc6cc999f64d3a34edeee1ca69d6e1f8aee40772c5f3f036296dc/sphobjinv-2.3.1.2.tar.gz", hash = "sha256:1c874a368460851352d45c92afa172b5c42653b47e2e70d78d61dac93308aa9d", size = 268026 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/4d/103e541e2533df159e1070cd4372b447a0b689e08a49d271b7b950e21f92/sphobjinv-2.3.1.2-py3-none-any.whl", hash = "sha256:66478d1787d28ef3ebeeedad57c592fdea04cf10eeed0df56307c85ab4eee789", size = 50820 }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, +] + +[[package]] +name = "tabulate" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252 }, +] + +[[package]] +name = "termcolor" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/37/72/88311445fd44c455c7d553e61f95412cf89054308a1aa2434ab835075fc5/termcolor-2.5.0.tar.gz", hash = "sha256:998d8d27da6d48442e8e1f016119076b690d962507531df4890fcd2db2ef8a6f", size = 13057 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/be/df630c387a0a054815d60be6a97eb4e8f17385d5d6fe660e1c02750062b4/termcolor-2.5.0-py3-none-any.whl", hash = "sha256:37b17b5fc1e604945c2642c872a3764b5d547a48009871aea3edd3afa180afb8", size = 7755 }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 }, +] + +[[package]] +name = "tomli" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, + { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, + { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, + { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, + { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, + { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, + { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, + { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, + { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, + { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, + { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, + { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, + { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, + { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, + { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, + { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, + { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, + { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, + { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, + { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, + { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, + { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, + { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, + { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, + { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, + { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, + { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, + { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, + { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, + { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, + { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, +] + +[[package]] +name = "tornado" +version = "6.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/45/a0daf161f7d6f36c3ea5fc0c2de619746cc3dd4c76402e9db545bd920f63/tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b", size = 501135 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/7e/71f604d8cea1b58f82ba3590290b66da1e72d840aeb37e0d5f7291bd30db/tornado-6.4.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e828cce1123e9e44ae2a50a9de3055497ab1d0aeb440c5ac23064d9e44880da1", size = 436299 }, + { url = "https://files.pythonhosted.org/packages/96/44/87543a3b99016d0bf54fdaab30d24bf0af2e848f1d13d34a3a5380aabe16/tornado-6.4.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:072ce12ada169c5b00b7d92a99ba089447ccc993ea2143c9ede887e0937aa803", size = 434253 }, + { url = "https://files.pythonhosted.org/packages/cb/fb/fdf679b4ce51bcb7210801ef4f11fdac96e9885daa402861751353beea6e/tornado-6.4.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a017d239bd1bb0919f72af256a970624241f070496635784d9bf0db640d3fec", size = 437602 }, + { url = "https://files.pythonhosted.org/packages/4f/3b/e31aeffffc22b475a64dbeb273026a21b5b566f74dee48742817626c47dc/tornado-6.4.2-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c36e62ce8f63409301537222faffcef7dfc5284f27eec227389f2ad11b09d946", size = 436972 }, + { url = "https://files.pythonhosted.org/packages/22/55/b78a464de78051a30599ceb6983b01d8f732e6f69bf37b4ed07f642ac0fc/tornado-6.4.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca9eb02196e789c9cb5c3c7c0f04fb447dc2adffd95265b2c7223a8a615ccbf", size = 437173 }, + { url = "https://files.pythonhosted.org/packages/79/5e/be4fb0d1684eb822c9a62fb18a3e44a06188f78aa466b2ad991d2ee31104/tornado-6.4.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:304463bd0772442ff4d0f5149c6f1c2135a1fae045adf070821c6cdc76980634", size = 437892 }, + { url = "https://files.pythonhosted.org/packages/f5/33/4f91fdd94ea36e1d796147003b490fe60a0215ac5737b6f9c65e160d4fe0/tornado-6.4.2-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:c82c46813ba483a385ab2a99caeaedf92585a1f90defb5693351fa7e4ea0bf73", size = 437334 }, + { url = "https://files.pythonhosted.org/packages/2b/ae/c1b22d4524b0e10da2f29a176fb2890386f7bd1f63aacf186444873a88a0/tornado-6.4.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:932d195ca9015956fa502c6b56af9eb06106140d844a335590c1ec7f5277d10c", size = 437261 }, + { url = "https://files.pythonhosted.org/packages/b5/25/36dbd49ab6d179bcfc4c6c093a51795a4f3bed380543a8242ac3517a1751/tornado-6.4.2-cp38-abi3-win32.whl", hash = "sha256:2876cef82e6c5978fde1e0d5b1f919d756968d5b4282418f3146b79b58556482", size = 438463 }, + { url = "https://files.pythonhosted.org/packages/61/cc/58b1adeb1bb46228442081e746fcdbc4540905c87e8add7c277540934edb/tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38", size = 438907 }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, +] + +[[package]] +name = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 }, +] + +[[package]] +name = "urllib3" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 }, +] + +[[package]] +name = "watchdog" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390 }, + { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389 }, + { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020 }, + { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393 }, + { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392 }, + { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019 }, + { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471 }, + { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449 }, + { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054 }, + { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480 }, + { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451 }, + { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057 }, + { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902 }, + { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380 }, + { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079 }, + { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076 }, + { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065 }, + { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070 }, + { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067 }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 }, +] + +[[package]] +name = "zipp" +version = "3.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 }, +]