diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ca158596..955fc7d9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,39 +14,35 @@ 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", "3.13"]
 
     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
+      - 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 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
+          uv run python -m doctest README.md
+          uv run pytest docs --nbval --nbval-current-env -p no:randomly
 
-      - name: Install and run linters (3.11-ubuntu only)
-        if: |
-          matrix.python-version == '3.11' &&
-          matrix.os == 'ubuntu-latest'
+      - name: Run unit tests
         run: |
-          python -m pip install ".[lint]"
-          python -m black --check .
-          python -m ruff 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 b2fc4a8f..8d19341a 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -13,19 +13,25 @@ jobs:
         steps:
             - name: Check out repository
               uses: actions/checkout@v3
+
             - name: Set up Quarto
               uses: quarto-dev/quarto-actions/setup@v2
-            - name: Install Python and dependencies
-              uses: actions/setup-python@v4
-              with:
-                python-version: "3.9"
-                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:
                 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..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
@@ -76,67 +76,49 @@ 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)
-<class 'matching.matchings.SingleMatching'>
+<class 'matching.matchings.SMMatching'>
+>>> isinstance(matching, dict)
+True
+>>> matching
+SMMatching({'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))
-<class 'matching.players.player.Player'>
-<class 'matching.players.player.Player'>
-<class 'matching.players.player.Player'>
+>>> 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
 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
@@ -145,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/_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/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 c8db482e..5747d0bc 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}"
+       "SMMatching({'Y': 'C', 'Z': 'B', 'X': 'A'}, keys=\"reviewers\", values=\"suitors\")"
       ]
      },
      "execution_count": 2,
@@ -56,9 +56,7 @@
     }
    ],
    "source": [
-    "game = StableMarriage.create_from_dictionaries(\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": [
-       "{A: Y, B: Z, C: X}"
+       "SMMatching({'Y': 'A', 'Z': 'B', 'X': 'C'}, keys=\"reviewers\", values=\"suitors\")"
       ]
      },
      "execution_count": 3,
@@ -80,9 +78,7 @@
     }
    ],
    "source": [
-    "game = StableMarriage.create_from_dictionaries(\n",
-    "    suitor_preferences, reviewer_preferences\n",
-    ")\n",
+    "game = StableMarriage.from_preferences(suitor_preferences, reviewer_preferences)\n",
     "\n",
     "game.solve(optimal=\"reviewer\")"
    ]
@@ -90,9 +86,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "matching-docs",
+   "display_name": ".venv",
    "language": "python",
-   "name": "matching-docs"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -104,7 +100,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/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/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..25af594e 100644
--- a/docs/tutorials/hospital_resident.ipynb
+++ b/docs/tutorials/hospital_resident.ipynb
@@ -41,11 +41,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "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,21 +221,12 @@
     "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"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -245,9 +240,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "matching-docs",
+   "display_name": ".venv",
    "language": "python",
-   "name": "matching-docs"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -259,7 +254,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.16"
+   "version": "3.13.1"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/stable_marriage.ipynb b/docs/tutorials/stable_marriage.ipynb
index a172ca2c..94d73366 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}"
+       "SMMatching({'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": ".venv",
    "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.13.1"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/stable_roommates.ipynb b/docs/tutorials/stable_roommates.ipynb
index 1f07d940..e4704038 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": ".venv",
    "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.13.1"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/student_allocation.ipynb b/docs/tutorials/student_allocation.ipynb
index 2a8fb77e..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": [
        "<Figure size 2400x1200 with 1 Axes>"
       ]
@@ -1117,7 +1099,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fda4126fca0>"
+       "<matplotlib.legend.Legend at 0x7f43827a8830>"
       ]
      },
      "execution_count": 27,
@@ -1126,7 +1108,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2400x1200 with 1 Axes>"
       ]
@@ -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": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2400x1200 with 1 Axes>"
       ]
@@ -1235,7 +1213,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fda715f64f0>"
+       "<matplotlib.legend.Legend at 0x7f437fdf6c10>"
       ]
      },
      "execution_count": 30,
@@ -1244,7 +1222,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2400x1200 with 1 Axes>"
       ]
@@ -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": [
        "<Figure size 2400x1200 with 1 Axes>"
       ]
@@ -1618,7 +1592,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fda20a271c0>"
+       "<matplotlib.legend.Legend at 0x7f437fd02490>"
       ]
      },
      "execution_count": 36,
@@ -1627,7 +1601,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2400x1200 with 1 Axes>"
       ]
@@ -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,9 +1861,9 @@
  "metadata": {
   "celltoolbar": "Tags",
   "kernelspec": {
-   "display_name": "matching-docs",
+   "display_name": ".venv",
    "language": "python",
-   "name": "matching-docs"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1905,7 +1875,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.16"
+   "version": "3.13.1"
   }
  },
  "nbformat": 4,
diff --git a/pyproject.toml b/pyproject.toml
index 09d9972a..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 = [
@@ -10,8 +6,8 @@ authors = [
 ]
 description = "A package for solving matching games"
 readme = "README.md"
-requires-python = ">=3.7"
-license = {text = "MIT License"}
+requires-python = ">=3.10"
+license = {text = "MIT Licence"}
 keywords = [
     "game-theory",
     "gale-shapley",
@@ -29,32 +25,35 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Information Analysis",
 ]
 dependencies = [
-    "numpy>=1.19.2"
+    "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'",
-]
-lint = [
-    "black[jupyter]>=22.6.0,<23",
-    "ruff>=0.1.1",
+    "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,lint,test]",
+    "matching[docs,test]",
+    "pytest-sugar>=1.0.0",
+    "ruff>=0.11.1",
 ]
 
 [project.urls]
@@ -65,26 +64,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]
+line-length = 99
 extend-include = ["*.ipynb"]
+
+[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"
+
+[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/__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/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/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/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/convert.py b/src/matching/convert.py
new file mode 100644
index 00000000..80220591
--- /dev/null
+++ b/src/matching/convert.py
@@ -0,0 +1,25 @@
+"""A module for converting between different data structures."""
+
+import numpy as np
+from scipy.stats import rankdata
+
+
+def preference_to_rank(preferences, others):
+    """Convert a preference list dictionary to a rank array."""
+
+    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 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")
+
+    return rank - 1
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 a24e3ece..2bfcc86a 100644
--- a/src/matching/games/stable_marriage.py
+++ b/src/matching/games/stable_marriage.py
@@ -1,192 +1,294 @@
 """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, matchings
 
-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()
+
+        self.num_suitors = len(suitor_ranks)
+        self.num_reviewers = len(reviewer_ranks)
+        self.matching = None
+        self._preference_lookup = None
 
-        super().__init__()
-        self.check_inputs()
+        self.check_input_validity()
 
     @classmethod
-    def create_from_dictionaries(cls, suitor_prefs, reviewer_prefs):
-        """Create an instance of SM from two preference dictionaries."""
+    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
+        -------
+        StableMarriage
+            An instance of SM with utilities resolved as rank matrices.
+        """
 
-        suitors, reviewers = _make_players(suitor_prefs, reviewer_prefs)
-        game = cls(suitors, reviewers)
+        suitor_ranks = convert.utility_to_rank(suitor_utils)
+        reviewer_ranks = convert.utility_to_rank(reviewer_utils)
 
-        return game
+        return cls(suitor_ranks, reviewer_ranks)
 
-    def solve(self, optimal="suitor"):
-        """Solve the instance of SM. Return the matching.
-
-        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
+        -------
+        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_input_validity(self):
+        """
+        Determine whether this game instance is valid or not.
 
-    def check_stability(self):
-        """Check for the existence of any blocking pairs."""
+        Invalid games can still be solved, but the matching will not be
+        truly stable in the absence of blocking pairs.
 
-        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))
+        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.blocking_pairs = blocking_pairs
-        return not any(blocking_pairs)
+        self._check_number_of_players()
 
-    def _check_for_unmatched_players(self):
-        """Check everyone has a match."""
+        for suitor, ranks in enumerate(self.suitor_ranks):
+            self._check_player_ranks(suitor, ranks, "suitor")
 
-        issues = []
-        for player in self.suitors + self.reviewers:
-            issue = player.check_if_match_is_unacceptable(unmatched_okay=False)
-            if issue:
-                issues.append(issue)
+        for reviewer, ranks in enumerate(self.reviewer_ranks):
+            self._check_player_ranks(reviewer, ranks, "reviewer")
 
-        return issues
+    def _check_number_of_players(self):
+        """
+        Check whether the player sets are the same size.
 
-    def _check_for_players_not_in_matching(self):
-        """Check that everyone appears in the matching."""
+        Warns
+        -----
+        UserWarning
+            If the sizes of the player sets do not match.
+        """
 
-        players_in_matching = set(self.matching.keys()) | set(
-            self.matching.values()
-        )
+        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,
+            )
 
-        issues = []
-        for player in self.suitors + self.reviewers:
-            if player not in players_in_matching:
-                issues.append(f"{player} does not appear in matching.")
+    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.
+        """
 
-        return issues
+        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,
+            )
 
-    def _check_for_inconsistent_matches(self):
-        """Check the matching is consistent with the players'."""
+    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.
+
+        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.
+        """
 
-        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}."
-                )
+        if optimal not in ("suitor", "reviewer"):
+            raise ValueError(
+                f'Invalid choice for `optimal`. Must be "suitor" or "reviewer", not "{optimal}".'
+            )
 
-        return issues
+        keys, values = "reviewers", "suitors"
 
-    def check_inputs(self):
-        """Raise an error if any of the game's rules do not hold."""
+        if optimal == "reviewer":
+            self._invert_player_sets()
+            keys, values = values, keys
 
-        self._check_num_players()
-        for suitor in self.suitors:
-            self._check_player_ranks(suitor)
-        for reviewer in self.reviewers:
-            self._check_player_ranks(reviewer)
+        matching = matchings.SMMatching(self._stable_marriage(), keys=keys, values=values)
 
-    def _check_num_players(self):
-        """Check that the number of suitors and reviewers are equal."""
+        if optimal == "reviewer":
+            matching = matching.invert()
+            self._invert_player_sets()
 
-        if len(self.suitors) != len(self.reviewers):
-            raise ValueError(
-                "There must be an equal number of suitors and reviewers."
-            )
+        self.matching = matching
+        if self._preference_lookup:
+            self._convert_matching_to_preferences()
 
-        return True
+        return self.matching
 
-    def _check_player_ranks(self, player):
-        """Check that a player has ranked all of the other group."""
+    def _invert_player_sets(self):
+        """
+        Invert the attributes associated with each set of players.
 
-        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}"
-            )
+        That is, `suitor_ranks` and `reviewer_ranks` switch. As do
+        `num_suitors` and `num_reviewers`.
+        """
+
+        self.suitor_ranks, self.reviewer_ranks = (
+            self.reviewer_ranks,
+            self.suitor_ranks,
+        )
+        self.num_suitors, self.num_reviewers = (
+            self.num_reviewers,
+            self.num_suitors,
+        )
 
-        return True
+    def _stable_marriage(self):
+        """
+        Execute the algorithm for SM given some rankings.
 
+        Returns
+        -------
+        dict
+            Solution to the game instance.
+        """
 
-def _make_players(suitor_prefs, reviewer_prefs):
-    """Make a set of suitors and reviewers from two dictionaries."""
+        matching = {}
+        suitor_ranks, reviewer_ranks = self.suitor_ranks, self.reviewer_ranks
+        free_suitors = list(range(self.num_suitors))
 
-    suitor_dict, reviewer_dict = _make_instances(suitor_prefs, reviewer_prefs)
+        while free_suitors:
+            suitor = free_suitors.pop()
+            reviewer = suitor_ranks[suitor].argmin()
+            reviewer_rank = reviewer_ranks[reviewer]
 
-    for suitor_name, suitor in suitor_dict.items():
-        prefs = [reviewer_dict[name] for name in suitor_prefs[suitor_name]]
-        suitor.set_prefs(prefs)
+            current = matching.get(reviewer)
+            if current is not None and (suitor_ranks[current] < self.num_reviewers).any():
+                free_suitors.append(current)
 
-    for reviewer_name, reviewer in reviewer_dict.items():
-        prefs = [suitor_dict[name] for name in reviewer_prefs[reviewer_name]]
-        reviewer.set_prefs(prefs)
+            matching[reviewer] = suitor
 
-    suitors = list(suitor_dict.values())
-    reviewers = list(reviewer_dict.values())
+            successors = np.where(reviewer_rank > reviewer_rank[suitor])
+            suitor_ranks[successors, reviewer] = self.num_reviewers
+            reviewer_rank[successors] = self.num_reviewers
 
-    return suitors, reviewers
+        return matching
 
+    def _convert_matching_to_preferences(self):
+        """
+        Replace the rank indices with preference terms in a matching.
 
-def _make_instances(suitor_prefs, reviewer_prefs):
-    """Create ``Player`` instances for the names in each dictionary."""
+        This internal function is included for users who wish to create
+        a matching from a set of preference list dictionaries.
+
+        Attributes
+        ----------
+        SMMatching
+            The converted matching instance.
+        """
 
-    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
+        converted = {}
+        suitors, reviewers = self._preference_lookup.values()
+        for reviewer, suitor in self.matching.items():
+            converted[reviewers[reviewer]] = suitors[suitor]
 
-    return suitor_dict, reviewer_dict
+        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
index 8afc6343..dcaf4b5d 100644
--- a/src/matching/matchings.py
+++ b/src/matching/matchings.py
@@ -1,63 +1,110 @@
-"""A collection of dictionary-like objects for storing matchings."""
+"""Module for the matching object classes."""
 
-from matching import BaseMatching
-from matching.players import Player
+import collections
 
 
-class SingleMatching(BaseMatching):
-    """Matching class for games with singular matches like SM or SR.
+class _BaseMatching(dict):
+    """
+    Dictionary-like object for holding game solutions. For inheritance.
 
     Parameters
     ----------
-    dictionary
-        A dictionary comprised of ``Player, Optional[Player]`` pairs.
+    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 __init__(self, dictionary):
-        super().__init__(dictionary)
-
-    def __setitem__(self, player, new):
-        """Set a player's new match and match them to the player, too.
+    KEYS = "keys"
+    VALUES = "values"
 
-        First check if the player and match are valid and present.
-        """
+    def __init__(self, dictionary=None, *, keys=None, values=None):
+        super().__init__(dictionary or {})
 
-        self._check_player_in_keys(player)
-        self._check_new_valid_type(new, (type(None), Player))
+        self.keys_ = keys or self.KEYS
+        self.values_ = values or self.VALUES
 
-        player.matching = new
-        if isinstance(new, Player):
-            new.matching = player
+    def __repr__(self):
+        name = self.__class__.__name__
+        return f'{name}({super().__repr__()}, keys="{self.keys_}", values="{self.values_}")'
 
-        self._data[player] = new
+    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 MultipleMatching(BaseMatching):
-    """Matching class for games with multiple matches like HR or SA.
+class _SingleMatching(_BaseMatching):
+    """
+    Dictionary-like object for solutions to games with singular matches.
 
     Parameters
     ----------
-    dictionary
-        A dictionary comprised of ``Hospital, List[Player]`` pairs.
+    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.
 
-    def __init__(self, dictionary):
-        super().__init__(dictionary)
+    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 __setitem__(self, player, new):
-        """Set a player's match and match each of them to the player.
+    def invert(self):
+        """
+        Invert the keys and list values in the dictionary.
 
-        First check if the player is present, and that the new match is
-        a valid collection of players.
+        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"
 
-        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
+class HRMatching(_MultipleMatching):
+    """Dictionary-like object for solutions to HR game instances."""
 
-        self._data[player] = new
+    KEYS = "hospitals"
+    VALUES = "residents"
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/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/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 b1c6426a..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.infty
-        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_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
new file mode 100644
index 00000000..a8013bbc
--- /dev/null
+++ b/tests/stable_marriage/strategies.py
@@ -0,0 +1,70 @@
+"""Composite strategies for SM unit tests."""
+
+from hypothesis import strategies as st
+
+from ..common import st_single_ranks, st_single_utilities
+
+
+@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_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..6581f03e 100644
--- a/tests/stable_marriage/test_algorithm.py
+++ b/tests/stable_marriage/test_algorithm.py
@@ -1,41 +1,56 @@
-"""Integration tests for the Stable Marriage Problem algorithm."""
+"""Unit tests for the Stable Marriage algorithm."""
 
-from matching.algorithms import stable_marriage
+import numpy as np
+from hypothesis import given
 
-from .util import STABLE_MARRIAGE, make_players
+from matching.games import StableMarriage
 
+from ..common import mocked_game
+from .strategies import st_ranks
 
-@STABLE_MARRIAGE
-def test_suitor_optimal(player_names, seed):
-    """Test that the suitor-optimal algorithm is suitor-optimal."""
 
-    suitors, reviewers = make_players(player_names, seed)
-    matching = stable_marriage(suitors, reviewers, optimal="suitor")
+def _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks):
+    """Assert that the matching has the right shape and elements."""
 
-    assert set(suitors) == set(matching.keys())
-    assert set(reviewers) == set(matching.values())
+    assert isinstance(matching, dict)
 
-    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)
+    assert (np.sort(list(matching.keys())) == np.unique(suitor_ranks)).all()
+    assert (np.sort(list(matching.values())) == np.unique(reviewer_ranks)).all()
 
 
-@STABLE_MARRIAGE
-def test_reviewer_optimal(player_names, seed):
-    """Test that the reviewer-optimal algorithm is reviewer-optimal."""
+@given(st_ranks())
+def test_stable_marriage_suitor_optimal(ranks):
+    """Test that the SM algorithm is valid and suitor-optimal."""
 
-    suitors, reviewers = make_players(player_names, seed)
-    matching = stable_marriage(suitors, reviewers, optimal="reviewer")
+    suitor_ranks, reviewer_ranks = ranks
+    game = mocked_game(StableMarriage, *ranks)
 
-    assert set(suitors) == set(matching.keys())
-    assert set(reviewers) == set(matching.values())
+    matching = game._stable_marriage()
 
-    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)
+    _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks)
+
+    for reviewer, suitor in matching.items():
+        suitor_rank = game.suitor_ranks[suitor]
+        preferred_reviewers, *_ = np.where(suitor_rank < suitor_rank[reviewer])
+        assert not preferred_reviewers.any()
+
+
+@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(StableMarriage, *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..a9401047 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,54 @@ 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 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 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 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..a6e4f8df
--- /dev/null
+++ b/tests/stable_marriage/test_game.py
@@ -0,0 +1,293 @@
+"""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 SMMatching
+
+from ..common import mocked_game
+from .strategies import (
+    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(StableMarriage, suitor_ranks, reviewer_ranks)
+
+    assert isinstance(game, StableMarriage)
+    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(StableMarriage, *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(StableMarriage, 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(StableMarriage, 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(StableMarriage, 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(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,
+    ):
+        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(StableMarriage, *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(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.SMMatching.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, SMMatching)
+        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(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.SMMatching.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
+
+    with mock.patch.object(StableMarriage, "check_input_validity") as validator:
+        game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs)
+
+    game.matching = SMMatching(matching)
+
+    game._convert_matching_to_preferences()
+    converted = game.matching
+
+    assert isinstance(converted, SMMatching)
+    assert converted.keys_ == "reviewers"
+    assert converted.values_ == "suitors"
+
+    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/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_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/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..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,16 +67,11 @@ 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:
-        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/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
new file mode 100644
index 00000000..eb3c5528
--- /dev/null
+++ b/tests/test_convert.py
@@ -0,0 +1,76 @@
+"""Tests for the `matching.convert` module."""
+
+import numpy as np
+from hypothesis import assume, 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()
+    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 = sorted(set(o for prefs in preference.values() for o in prefs))
+    ranks = convert.preference_to_rank(preference, others)
+
+    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)
+
+    assert ranks[idx, -1] == len(others)
diff --git a/tests/test_matchings.py b/tests/test_matchings.py
deleted file mode 100644
index e93f3526..00000000
--- a/tests/test_matchings.py
+++ /dev/null
@@ -1,98 +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, SingleMatching
-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,
-    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=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."""
-
-    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/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);
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 },
+]