Merge pull request 'Fix routing and add tests' (#1) from fix-routing-and-add-tests into main

Reviewed-on: #1

.env.example

@@ -0,0 +1,3 @@
+# Copy this file to `.env` and fill in your real key. `.env` is gitignored.
+# Required: Google Maps API key with the Routes API enabled.
+GOOGLE_MAPS_API_KEY=your-api-key-here

README.md

@@ -1,2 +1,266 @@
 # Tatami
-Tool for Arranging Tasty Appointments, Meetings & Invitations
+
+**T**ool for **A**rranging **T**asty **A**ppointments, **M**eetings & **I**nvitations.
+
+Tatami generates a **running dinner** masterplan. Given a list of participants with
+home addresses, it forms small hosting groups, decides which groups cook which
+course and who visits whom, and orders the whole evening to minimize travel time
+(by bike, using the Google Maps Routes API), finishing at a shared after‑party.
+
+- [What is a running dinner?](#what-is-a-running-dinner)
+- [How Tatami builds the plan](#how-tatami-builds-the-plan)
+- [Requirements](#requirements)
+- [Setup](#setup)
+- [Input: the participant CSV](#input-the-participant-csv)
+- [Running it](#running-it)
+- [Output format](#output-format)
+- [What you can tweak](#what-you-can-tweak)
+- [How the algorithm works](#how-the-algorithm-works)
+- [Testing](#testing)
+- [Limitations & scaling](#limitations--scaling)
+- [Project layout](#project-layout)
+- [Development](#development)
+
+---
+
+## What is a running dinner?
+
+A running dinner is a social dinner event spread across many homes. Participants
+are split into **hosting groups**. The evening has three courses — **starter,
+main, dessert** — and each group cooks **exactly one** course in their own home.
+For the other two courses they travel to other groups' homes as guests. The
+tables are mixed for every course, so people meet many others over the night.
+Everyone converges on a common **after‑party** location at the end.
+
+Tatami arranges all of this and tries to keep the total cycling time low.
+
+## How Tatami builds the plan
+
+The pipeline (see the `__main__` block of `src/tatami/tatami_masterplan.py`):
+
+1. **Load participants** from a tab‑separated CSV into `Participant` objects.
+2. **Fetch travel times** — a full pairwise duration matrix between every
+   participant address plus the after‑party address, via the Google Routes API.
+3. **Build the masterplan**:
+   - Rank participants by how convenient they are as hosts (kitchen‑size penalty
+     plus distance to the after‑party), then split into **hosts** (one per group)
+     and **semi‑hosts** (distributed into the host groups).
+   - Reduce the full matrix to a host‑to‑host matrix and bake in each host's
+     kitchen‑size penalty.
+   - Run **simulated annealing** to find a low‑travel‑time assignment of groups
+     to the dinner rotation.
+   - Assign each group a course and compute who hosts whom for each course.
+4. **Return** two lists of plain dicts (groups and participants) ready for
+   serialization.
+
+## Requirements
+
+- **Python ≥ 3.13**
+- **[uv](https://docs.astral.sh/uv/)** for dependency management
+- A **Google Maps API key** with the **Routes API** enabled
+  (the new `routes.googleapis.com` `computeRouteMatrix` endpoint — *not* the
+  legacy Distance Matrix API).
+
+## Setup
+
+```bash
+# 1. Install dependencies (creates the virtualenv from uv.lock)
+uv sync
+
+# 2. Provide your API key
+cp .env.example .env
+#   then edit .env and set GOOGLE_MAPS_API_KEY=...
+```
+
+The key is read from `.env` automatically (via `python-dotenv`). `.env` is
+gitignored, so your secret never gets committed. An already‑exported
+`GOOGLE_MAPS_API_KEY` environment variable takes precedence over the file.
+
+> The package raises at import time if no key is found, so `GOOGLE_MAPS_API_KEY`
+> must be set (even to a dummy value) just to import `tatami.traveltimes`.
+
+## Input: the participant CSV
+
+A **tab‑separated** file (the default working file is `test-config.csv` in the
+directory you run from) with these columns:
+
+| Column         | Type   | Meaning                                                              |
+|----------------|--------|----------------------------------------------------------------------|
+| `name`         | string | Participant / household name.                                        |
+| `address`      | string | Full postal address — this is what the Routes API geocodes.          |
+| `phone`        | string | Contact number (carried through to the output, not used in routing). |
+| `kitchen_size` | number | `0–10`; a *suitability‑to‑host* proxy. Bigger = better kitchen.      |
+| `allergies`    | string | Free text (carried through, not used in routing).                    |
+
+Example (columns separated by **tabs**):
+
+```
+name	address	phone	kitchen_size	allergies
+Alice	Römerstr. 12, 76189 Karlsruhe	555-1234	8	none
+Bob	Gottesauerstr. 30, 76131 Karlsruhe	555-5678	7	peanuts
+Charlie	Hermann-Hesse-Str 50, 76189 Karlsruhe	555-8765	9	none
+```
+
+## Running it
+
+```bash
+uv run python -m tatami.tatami_masterplan
+```
+
+This reads `test-config.csv` from the current directory, calls the Routes API,
+and prints the generated masterplan. The after‑party address and travel mode are
+currently set in the `__main__` block of `tatami_masterplan.py` (see
+[What you can tweak](#what-you-can-tweak)).
+
+To use Tatami from your own code:
+
+```python
+from tatami.tatami_masterplan import (
+    get_after_party_group, get_masterplan, load_csv_to_participants,
+)
+from tatami.traveltimes import get_participant_distance_matrix
+
+participants = load_csv_to_participants("my-participants.csv")
+after_party = get_after_party_group("Some Street 1, 12345 City")
+
+distance_matrix = get_participant_distance_matrix(
+    [*participants, after_party.main_member], mode="BICYCLE"
+)
+groups, participants_out = get_masterplan(participants, distance_matrix, after_party)
+```
+
+## Output format
+
+`get_masterplan` returns a tuple `(group_dicts, participant_dicts)`.
+
+Each **group** dict:
+
+```python
+{
+    "uuid": "Group_…",            # group id
+    "members": ["…", "…"],        # participant uuids in this group
+    "main_member": "…",           # the participant whose home is used for routing
+    "course": "starter",          # "starter" | "main" | "dessert"
+    "hosts": ["…", "…", "…"],     # the three groups this group eats with,
+                                   # ordered starter → main → dessert
+                                   # (includes this group itself, for its own course)
+}
+```
+
+Each **participant** dict mirrors the CSV columns plus a `uuid`. Everything is
+keyed by UUID, so resolve names/addresses by looking participants up by `uuid`.
+
+> Note: only a group's `main_member` address is used for all travel calculations;
+> other members are assumed to join at the main member's home.
+
+## What you can tweak
+
+All knobs currently live in the source. The most useful ones:
+
+| What | Where | Default | Effect |
+|------|-------|---------|--------|
+| **After‑party address** | `tatami_masterplan.py:230` (`__main__`) | a Karlsruhe address | Where everyone ends the night; also influences host ranking. |
+| **Travel mode** | `tatami_masterplan.py:233` (`mode="BICYCLE"`) | `BICYCLE` | Any Routes API `travelMode`: `BICYCLE`, `DRIVE`, `WALK`, `TWO_WHEELER`, `TRANSIT`. |
+| **Group sizing** | `tatami_masterplan.py:24` (`len(participants) / 6`) | 1 group per ~6 people | The divisor sets how many participants form one "course‑triple". Larger → fewer, bigger groups. |
+| **Kitchen‑size penalty** | `classes.py:19` (`minutes=3 * (10 - kitchen_size)`) | 3 min per point | Travel‑time‑equivalent penalty for small kitchens. Raise the `3` to push hosting toward big kitchens. |
+| **Annealing schedule** | `tatami_masterplan.py:48–50` | `T=1000`, `cooling=0.99`, `iters=10000` | Optimization quality vs. runtime. More iterations / slower cooling → better routes, slower. |
+| **Course names** | `tatami_masterplan.py:31` | `["starter", "main", "dessert"]` | The three courses. The 3‑course rotation is baked into the topology — changing the *count* needs more work (see below). |
+| **Rotation topology** | `tatami_masterplan.py:172–173` (offsets `+1`, `-4`) | — | Defines who hosts whom. Changing these changes who meets whom; keep the invariant that each group's three hosts cover all three courses. |
+| **Distance vs. duration** | `traveltimes.py` `get_distance_matrix(value=…)` | `"duration"` | Optimize on travel **time** (`"duration"`) or **distance** (`"distanceMeters"`). |
+
+After changing routing‑relevant knobs, run the test suite (`uv run pytest`) — the
+topology and cost invariants are covered there.
+
+## How the algorithm works
+
+### Group building
+
+`groups_per_course = floor(n / 6)` groups are created **per course**, for
+`3 × groups_per_course` groups total. Participants are sorted by
+`get_after_party_time` (kitchen penalty + distance to after‑party); the best
+become the one **host** of each group, and the rest are shuffled in round‑robin
+as **semi‑hosts**. A group's `main_member` (the host) is the only address used
+for that group in all distance lookups.
+
+### Rotation topology (`get_courses`)
+
+Each group occupies a **slot** `0 … n‑1`. The course a slot cooks is `slot % 3`
+(`0 → starter`, `1 → main`, `2 → dessert`). For slot `i`, the three groups it
+dines with are slots `i` (itself, for its own course), `i + 1`, and `i − 4`
+(mod `n`). These offsets are chosen so that:
+
+- a group's three hosts always cover **all three** courses,
+- **every** host serves **exactly three** groups (itself + two guests) for its
+  course,
+- guests are mixed differently at each course.
+
+These invariants are verified in `tests/test_routing.py`.
+
+### Route optimization (simulated annealing)
+
+The decision variable is *which physical group sits in which slot*. For a given
+assignment, `fast_total_time` sums every group's route
+(starter‑host → main‑host → dessert‑host → after‑party) using the reduced,
+penalty‑baked matrix. `simulated_annealing` starts from a random assignment and
+repeatedly proposes swapping two slots, accepting worse solutions with Boltzmann
+probability `exp(-Δ / T)` while the temperature `T` cools, and returns the best
+assignment it finds. It is a **heuristic** — good, not provably optimal — though
+on small instances it reliably reaches the true optimum.
+
+## Testing
+
+```bash
+uv run pytest            # full offline suite (no API calls, HTTP is mocked)
+uv run pytest -m e2e     # opt-in live test that calls the real Routes API
+```
+
+- The default suite (`tests/`) covers the domain model, group building, the
+  rotation topology, the route cost/optimization, and the Routes API wrapper
+  (with the HTTP layer mocked) — **no network, no API quota used**.
+- `tests/test_e2e_api.py` is marked `e2e` and **excluded by default**. Run it
+  explicitly with `-m e2e`. It makes a single minimal request (two addresses →
+  a 2×2, 4‑element matrix) and **skips itself** if only a placeholder/dummy key
+  is available, so it never spuriously fails.
+
+## Limitations & scaling
+
+- **Participant count.** The Routes API `computeRouteMatrix` caps at **625
+  elements** (a 25×25 matrix), so Tatami currently handles up to ~**24
+  participants** plus the after‑party in one shot. Bigger events need batching.
+- **Group counts** are multiples of 3, and you need **≥ 6 participants** before
+  any groups are formed at all.
+- **Heuristic routing.** Simulated annealing does not guarantee the global
+  optimum on large instances; tune the schedule if results look poor.
+- **One address per group.** Only the host's (`main_member`'s) address is used
+  for routing; guests are assumed to gather there.
+
+## Project layout
+
+```
+src/tatami/
+  classes.py            # Participant and Group domain model
+  traveltimes.py        # Google Routes API wrapper + matrix helpers
+  tatami_masterplan.py  # pipeline: load → fetch → group → optimize → assign
+tests/                  # pytest suite (offline + opt-in live e2e)
+running_dinner/         # legacy standalone prototype — NOT used by the package
+```
+
+> `running_dinner/running_dinner.py` is a pre‑package prototype kept for
+> reference only. It uses German field names, a brute‑force search, and the
+> **legacy** Distance Matrix API. Don't assume its conventions apply to
+> `src/tatami/`.
+
+## Development
+
+This project uses `uv` and enforces quality with `ruff` and `mypy`.
+
+```bash
+uv sync                                  # install (incl. dev tools)
+uv run ruff check                        # lint
+uv run ruff format                       # format
+uv run mypy --allow-redefinition src/    # type-check
+uv run pre-commit install                # enable the pre-commit hooks
+```
+
+Pre‑commit runs `ruff check`, `ruff format`, and `mypy` automatically (see
+`.pre-commit-config.yaml`).

pyproject.toml

@@ -8,6 +8,7 @@ dependencies = [
     "numpy>=2.2.4",
     "pandas>=2.2.3",
     "pandas-stubs>=2.2.3.250308",
+    "python-dotenv>=1.2.2",
     "requests>=2.32.3",
     "tqdm>=4.67.1",
     "types-requests>=2.32.0.20250328",
@@ -17,9 +18,18 @@ dependencies = [
 [dependency-groups]
 dev = [
     "mypy>=1.15.0",
+    "pytest>=9.1.1",
     "ruff>=0.11.5",
 ]
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# Deselect live API tests by default; run them with `pytest -m e2e`.
+addopts = "-q -m 'not e2e'"
+markers = [
+    "e2e: live tests that call the real Google Routes API (opt-in, costs quota)",
+]

src/tatami/classes.py

@@ -1,5 +1,6 @@
 import datetime as dt
 import pandas as pd
+from typing import cast
 from uuid import uuid4
 
 
@@ -23,7 +24,10 @@ class Participant:
         return (
             self.get_penalty()
             + pd.to_timedelta(
-                distance_matrix.loc[self.uuid, after_party_group.main_member.uuid]
+                cast(
+                    pd.Timedelta,
+                    distance_matrix.loc[self.uuid, after_party_group.main_member.uuid],
+                )
             ).to_pytimedelta()
         )
 
@@ -49,7 +53,9 @@ class Group:
         self.uuid = "Group_" + str(uuid4())
         self.members = members
         self.main_member = members[main_member]
-        self.course: str | None = None # For ordering the groups allowed values: "starter", "main", "dessert"
+        self.course: str | None = (
+            None  # For ordering the groups allowed values: "starter", "main", "dessert"
+        )
         self.hosts: list[Group] | None = None
 
     def set_course(self, course: str):
@@ -89,7 +95,12 @@ class Group:
         total_time = dt.timedelta()
         for group, next_group in zip(groups[:-1], groups[1:]):
             total_time += pd.to_timedelta(
-                distance_matrix.loc[group.main_member.uuid, next_group.main_member.uuid]
+                cast(
+                    pd.Timedelta,
+                    distance_matrix.loc[
+                        group.main_member.uuid, next_group.main_member.uuid
+                    ],
+                )
             ).to_pytimedelta()
             total_time += group.main_member.get_penalty()
 

src/tatami/tatami_masterplan.py

@@ -4,7 +4,6 @@ import pandas as pd
 import numpy as np
 import random
 from tqdm import tqdm
-from itertools import permutations
 
 
 def get_after_party_group(address: str) -> Group:
@@ -23,8 +22,9 @@ def get_masterplan(
     after_party_group: Group,
 ) -> tuple[list[dict], list[dict]]:
     groups_per_course = np.floor(len(participants) / 6).astype(int)
-    participants.sort(
-        key=lambda x: x.get_after_party_time(distance_matrix, after_party_group)
+    participants = sorted(
+        participants,
+        key=lambda x: x.get_after_party_time(distance_matrix, after_party_group),
     )
     hosts = participants[: 3 * groups_per_course]
     semi_hosts = participants[3 * groups_per_course :]
@@ -59,10 +59,17 @@ def get_masterplan(
 def assign_courses(groups: list[Group], courses: list[str]) -> None:
     """
     Assign courses to groups.
+
+    Courses are assigned to every group first, then hosts are wired up: a group's
+    hosts are sorted by course (``sort_hosts``), so all course assignments must be
+    in place before any ``set_hosts`` call, otherwise hosts whose course is still
+    unset get mis-ordered.
     """
-    for i, (group, course) in enumerate(zip(groups, courses)):
+    for group, course in zip(groups, courses):
         group.set_course(course)
-        hosts = [groups[i] for i in get_courses(i, len(groups))]
+
+    for i, group in enumerate(groups):
+        hosts = [groups[j] for j in get_courses(i, len(groups))]
         group.set_hosts(hosts)
 
 
@@ -77,11 +84,18 @@ def run_simulated_annealing(
     """
     Run simulated annealing to find the optimal order of groups.
     """
-    group_indices = list(range(len(groups)))
-    distance_matrix = reduced_distance_matrix.to_numpy()
+    group_indices = [int(i) for i in range(len(groups))]
 
-    # Convert group indices to a list of integers
-    group_indices = [int(i) for i in group_indices]
+    # The reduced matrix holds pd.Timedelta values; convert to a float matrix of
+    # seconds so it can be used numerically in the acceptance criterion
+    # (np.exp cannot operate on Timedelta objects).
+    distance_matrix = np.array(
+        [
+            [pd.Timedelta(x).total_seconds() for x in row]
+            for row in reduced_distance_matrix.to_numpy()
+        ],
+        dtype=float,
+    )
 
     if multiprocessing > 1:
         raise NotImplementedError("Multiprocessing is not implemented yet.")
@@ -98,25 +112,6 @@ def run_simulated_annealing(
         return best_ordererd_groups
 
 
-def next_permutation(
-    group_indices: list[int],
-    distance_matrix: np.ndarray,
-    T: float,
-) -> list[int]:
-    """
-    Generate the next permutation of group indices that minimizes the total travel time using boltzmann annealing.
-    """
-    all_permutations = list(permutations(group_indices))
-    times = {
-        i: fast_total_time(distance_matrix, perm)
-        for i, perm in enumerate(all_permutations)
-    }
-    min_time = min(times.values())
-    probabilities = {i: np.exp(-(time - min_time) / T) for i, time in times.items()}
-    key = np.random.choice(list(probabilities.keys()), p=list(probabilities.values()))
-    return all_permutations[key]
-
-
 def simulated_annealing(
     distance_matrix: np.ndarray,
     group_indices: list[int],
@@ -125,23 +120,48 @@ def simulated_annealing(
     max_iterations: int,
 ) -> list[int]:
     """
-    Simulated annealing algorithm to find the optimal order of groups.
+    Simulated annealing over assignments of groups to rotation slots.
+
+    ``solution[slot]`` is the group index placed in that slot. Each iteration
+    proposes a random two-slot swap and accepts it with the Boltzmann
+    probability; the best solution seen is tracked and returned.
     """
-    solution = group_indices.copy()
-    np.random.shuffle(solution)
+    current = group_indices.copy()
+    np.random.shuffle(current)
+    current_cost = fast_total_time(distance_matrix, current)
+
+    best = current.copy()
+    best_cost = current_cost
+
+    # Nothing to optimize with fewer than two slots.
+    if len(current) < 2:
+        return best
+
     current_temperature = initial_temperature
 
     for iteration in tqdm(range(max_iterations)):
         try:
-            solution = next_permutation(solution, distance_matrix, current_temperature)
-            time = fast_total_time(distance_matrix, solution)
+            candidate = current.copy()
+            i, j = np.random.choice(len(candidate), size=2, replace=False)
+            candidate[i], candidate[j] = candidate[j], candidate[i]
+            candidate_cost = fast_total_time(distance_matrix, candidate)
+
+            delta = candidate_cost - current_cost
+            if delta <= 0 or np.random.random() < np.exp(-delta / current_temperature):
+                current, current_cost = candidate, candidate_cost
+                if current_cost < best_cost:
+                    best, best_cost = current.copy(), current_cost
+
             if iteration % 100 == 0:
-                print(f"Iteration {iteration}: Time = {time}")
+                print(
+                    f"Iteration {iteration}: current = {current_cost:.0f}s, "
+                    f"best = {best_cost:.0f}s"
+                )
             current_temperature *= cooling_rate
         except KeyboardInterrupt:
-            print("Simulation interrupted. Returning current solution.")
+            print("Simulation interrupted. Returning best solution so far.")
             break
-    return solution
+    return best
 
 
 def get_courses(
@@ -155,25 +175,32 @@ def get_courses(
     return order
 
 
-def fast_total_time(distance_matrix: np.ndarray, group_indices: list[int]):
-    """Calculates the total travel time for all groups.
+def fast_total_time(distance_matrix: np.ndarray, solution: list[int]) -> float:
+    """Calculates the total travel time for a given slot-to-group assignment.
+
+    The rotation topology is defined over *slots* ``0..n-1`` via ``get_courses``;
+    ``solution[slot]`` gives the group placed in that slot. For each slot the
+    occupying group travels starter-host -> main-host -> dessert-host -> after
+    party, and the durations of those legs are summed across all slots.
 
     Args:
-        distance_matrix (np.ndarray): 2D array representing the distance matrix, where
-            distance_matrix[i][j] is the travel time from group i to group j in seconds. Should be of shape (n+1, n+1). The last column/row should be the after party group.
-        group_indices (list[int]): List of group indices for which to calculate the total travel time. Should be of length n.
+        distance_matrix (np.ndarray): 2D array where ``distance_matrix[i][j]`` is
+            the travel time (seconds) from group ``i`` to group ``j``. Shape
+            ``(n+1, n+1)``; the last row/column is the after-party location.
+        solution (list[int]): Permutation mapping each slot to a group index.
     """
-    n = len(group_indices)
+    n = len(solution)
     after_party_idx = n  # Since distance_matrix is (n+1)x(n+1)
 
-    total_time = 0
+    total_time = 0.0
     total_meetings = n
 
-    for group_index in group_indices:
-        a, b, c = get_courses(group_index, total_meetings)
-        total_time += distance_matrix[a][b]
-        total_time += distance_matrix[b][c]
-        total_time += distance_matrix[c][after_party_idx]
+    for slot in range(n):
+        a, b, c = get_courses(slot, total_meetings)
+        ga, gb, gc = solution[a], solution[b], solution[c]
+        total_time += distance_matrix[ga][gb]
+        total_time += distance_matrix[gb][gc]
+        total_time += distance_matrix[gc][after_party_idx]
 
     return total_time
 

src/tatami/traveltimes.py

@@ -1,9 +1,14 @@
 import pandas as pd
 import requests
 import os
+from dotenv import load_dotenv
 from tatami.classes import Participant, Group
 
 
+# Load secrets from a local .env file if present. Existing environment variables
+# take precedence (override=False), so an exported GOOGLE_MAPS_API_KEY still wins.
+load_dotenv()
+
 GOOGLE_MAPS_API_URL = (
     "https://routes.googleapis.com/distanceMatrix/v2:computeRouteMatrix"
 )

tests/conftest.py

@@ -0,0 +1,67 @@
+"""Shared pytest fixtures and test setup for the tatami package.
+
+``tatami.traveltimes`` raises at import time if ``GOOGLE_MAPS_API_KEY`` is unset,
+so we set a dummy value here (conftest is imported before any test module, and
+therefore before the package is imported) to make the modules importable without
+a real API key. Tests never hit the live API; the HTTP layer is mocked.
+"""
+
+import os
+
+os.environ.setdefault("GOOGLE_MAPS_API_KEY", "test-key")
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from tatami.classes import Participant
+
+
+@pytest.fixture(autouse=True)
+def _seed_rng():
+    """Make the randomized steps (shuffles, annealing) deterministic per test."""
+    np.random.seed(1234)
+
+
+def make_participants(
+    n: int, kitchen_sizes: list[float] | None = None
+) -> list[Participant]:
+    """Create ``n`` participants with distinct addresses and uuids."""
+    if kitchen_sizes is None:
+        kitchen_sizes = [10.0] * n
+    return [
+        Participant(
+            name=f"P{i}",
+            address=f"address {i}",
+            phone=f"phone {i}",
+            kitchen_size=kitchen_sizes[i],
+            allergies="",
+        )
+        for i in range(n)
+    ]
+
+
+def make_timedelta_matrix(
+    participants: list[Participant], seconds: np.ndarray
+) -> pd.DataFrame:
+    """Build a uuid-indexed square matrix of ``pd.Timedelta`` from a seconds array.
+
+    Mirrors the shape produced by ``get_participant_distance_matrix``: object dtype
+    cells holding ``pd.Timedelta`` values, indexed and columned by participant uuid.
+    """
+    uuids = [p.uuid for p in participants]
+    matrix = pd.DataFrame(index=pd.Index(uuids), columns=pd.Index(uuids), dtype=object)
+    for i, u in enumerate(uuids):
+        for j, v in enumerate(uuids):
+            matrix.at[u, v] = pd.to_timedelta(f"{int(seconds[i][j])}s")
+    return matrix
+
+
+@pytest.fixture
+def participants_factory():
+    return make_participants
+
+
+@pytest.fixture
+def matrix_factory():
+    return make_timedelta_matrix

tests/test_classes.py

@@ -0,0 +1,141 @@
+"""Tests for the core domain model: Participant and Group."""
+
+import datetime as dt
+
+import numpy as np
+import pytest
+
+from tatami.classes import Group, Participant
+from conftest import make_participants, make_timedelta_matrix
+
+
+class TestParticipant:
+    def test_uuid_is_unique(self):
+        a = Participant("A", "addr", "", 5, "")
+        b = Participant("A", "addr", "", 5, "")
+        assert a.uuid != b.uuid
+
+    @pytest.mark.parametrize(
+        "kitchen_size,minutes",
+        [(10, 0), (7, 9), (0, 30), (5, 15)],
+    )
+    def test_penalty_scales_with_kitchen_size(self, kitchen_size, minutes):
+        p = Participant("A", "addr", "", kitchen_size, "")
+        assert p.get_penalty() == dt.timedelta(minutes=minutes)
+
+    def test_after_party_time_combines_penalty_and_travel(self):
+        people = make_participants(2, kitchen_sizes=[7.0, 10.0])
+        # 600s travel between the two participants.
+        matrix = make_timedelta_matrix(people, np.array([[0, 600], [600, 0]]))
+        after_party = Group(members=[people[1]])
+        result = people[0].get_after_party_time(matrix, after_party)
+        assert result == dt.timedelta(minutes=9) + dt.timedelta(seconds=600)
+
+    def test_dict_roundtrip_fields(self):
+        p = Participant("Alice", "addr", "555", 8, "peanuts")
+        d = p.dict()
+        assert d == {
+            "uuid": p.uuid,
+            "name": "Alice",
+            "address": "addr",
+            "phone": "555",
+            "kitchen_size": 8,
+            "allergies": "peanuts",
+        }
+
+
+class TestGroup:
+    def test_default_main_member_is_first(self):
+        people = make_participants(3)
+        group = Group(members=people)
+        assert group.main_member is people[0]
+
+    def test_explicit_main_member_index(self):
+        people = make_participants(3)
+        group = Group(members=people, main_member=2)
+        assert group.main_member is people[2]
+
+    def test_add_member_appends_without_changing_main(self):
+        people = make_participants(2)
+        group = Group(members=[people[0]])
+        group.add_member(people[1])
+        assert people[1] in group.members
+        assert group.main_member is people[0]
+
+    def test_add_member_can_promote_to_main(self):
+        people = make_participants(2)
+        group = Group(members=[people[0]])
+        group.add_member(people[1], main_member=True)
+        assert group.main_member is people[1]
+
+    def test_set_hosts_sorts_by_course(self):
+        people = make_participants(3)
+        groups = [Group(members=[p]) for p in people]
+        groups[0].set_course("dessert")
+        groups[1].set_course("starter")
+        groups[2].set_course("main")
+        host = Group(members=[make_participants(1)[0]])
+        host.set_hosts([groups[0], groups[1], groups[2]])
+        assert [g.course for g in host.hosts] == ["starter", "main", "dessert"]
+
+    def test_get_total_time_sums_legs_and_penalties(self):
+        # Three host groups (penalties 0) + after party; verify the summed route.
+        people = make_participants(4, kitchen_sizes=[10, 10, 10, 10])
+        seconds = np.array(
+            [
+                [0, 100, 0, 0, 50],
+                [0, 0, 200, 0, 0],
+                [0, 0, 0, 0, 300],
+                [0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0],
+            ]
+        )
+        # build matrix including an after party participant
+        after_party_p = make_participants(1)[0]
+        all_people = people + [after_party_p]
+        full = make_timedelta_matrix(all_people, seconds)
+
+        starter = Group(members=[people[0]])
+        starter.set_course("starter")
+        main = Group(members=[people[1]])
+        main.set_course("main")
+        dessert = Group(members=[people[2]])
+        dessert.set_course("dessert")
+        after_party = Group(members=[after_party_p])
+
+        visitor = Group(members=[people[3]])
+        visitor.set_hosts([starter, main, dessert])
+        total = visitor.get_total_time(full, after_party)
+        # legs: starter->main (100) + main->dessert (200) + dessert->afterparty (300)
+        assert total == dt.timedelta(seconds=600)
+
+    def test_get_total_time_raises_without_hosts(self):
+        group = Group(members=make_participants(1))
+        after_party = Group(members=make_participants(1))
+        with pytest.raises(ValueError):
+            group.get_total_time(None, after_party)
+
+    def test_get_guests_collects_visiting_members(self):
+        people = make_participants(4)
+        host = Group(members=[people[0]])
+        guest_a = Group(members=[people[1]])
+        guest_b = Group(members=[people[2], people[3]])
+        # get_guests returns early when the host has no hosts of its own, so give it
+        # a (self-)host as it would have in a real plan.
+        host.set_hosts([host])
+        guest_a.set_hosts([host])
+        guest_b.set_hosts([host])
+        guests = host.get_guests([guest_a, guest_b])
+        guest_uuids = {p.uuid for p in guests}
+        assert guest_uuids == {people[1].uuid, people[2].uuid, people[3].uuid}
+
+    def test_dict_serializes_uuids(self):
+        people = make_participants(2)
+        group = Group(members=people)
+        host = Group(members=make_participants(1))
+        host.set_course("starter")
+        group.set_hosts([host])
+        d = group.dict()
+        assert d["main_member"] == people[0].uuid
+        assert d["members"] == [p.uuid for p in people]
+        assert d["hosts"] == [host.uuid]

tests/test_e2e_api.py

@@ -0,0 +1,67 @@
+"""Live end-to-end test against the real Google Routes API.
+
+This is intentionally excluded from the default test run (it is marked ``e2e``
+and ``addopts`` in pyproject.toml deselects that marker). It also costs billable
+API elements, so it is kept minimal: two addresses -> a 2x2 (4-element) matrix.
+
+Run it explicitly when you actually want to exercise the live API:
+
+    uv run pytest -m e2e
+
+It requires a real GOOGLE_MAPS_API_KEY (read from the environment or the local
+.env file); the test skips itself if only a placeholder/dummy key is available.
+"""
+
+import os
+
+import pandas as pd
+import pytest
+from dotenv import load_dotenv
+
+import tatami.traveltimes as tt
+from tatami.classes import Participant
+
+pytestmark = pytest.mark.e2e
+
+# Values that are not a usable real key (conftest's dummy and the template value).
+_PLACEHOLDER_KEYS = {"", "test-key", "your-api-key-here"}
+
+
+def _real_api_key() -> str | None:
+    # Prefer a real value from the environment / .env over the dummy that conftest
+    # sets for the rest of the suite.
+    load_dotenv(override=True)
+    key = os.environ.get("GOOGLE_MAPS_API_KEY", "")
+    return key if key not in _PLACEHOLDER_KEYS else None
+
+
+@pytest.fixture
+def live_api(monkeypatch):
+    key = _real_api_key()
+    if key is None:
+        pytest.skip("No real GOOGLE_MAPS_API_KEY available; skipping live API test.")
+    # traveltimes captured the key at import time, so point the module global at
+    # the real key for this test.
+    monkeypatch.setattr(tt, "GOOGLE_MAPS_API_KEY", key)
+    return key
+
+
+def test_live_route_matrix_minimal(live_api):
+    # Two real addresses -> a 2x2 matrix (4 billable elements), the smallest
+    # meaningful request.
+    participants = [
+        Participant("A", "Römerstr. 12, 76189 Karlsruhe", "", 10, ""),
+        Participant("B", "Gottesauerstr. 30, 76131 Karlsruhe", "", 10, ""),
+    ]
+
+    matrix = tt.get_participant_distance_matrix(participants, mode="BICYCLE")
+
+    uuids = [p.uuid for p in participants]
+    assert matrix.shape == (2, 2)
+    assert list(matrix.index) == uuids
+    assert list(matrix.columns) == uuids
+
+    # A real bike trip between two distinct addresses takes a positive duration.
+    travel = matrix.loc[uuids[0], uuids[1]]
+    assert isinstance(travel, pd.Timedelta)
+    assert travel > pd.Timedelta(0)

tests/test_masterplan.py

@@ -0,0 +1,141 @@
+"""Integration tests for the masterplan pipeline (group building + assignment)."""
+
+import numpy as np
+import pytest
+
+from tatami.classes import Group
+from tatami.traveltimes import reduce_distance_matrix
+from tatami.tatami_masterplan import (
+    assign_courses,
+    fast_total_time,
+    get_after_party_group,
+    get_courses,
+    get_masterplan,
+    load_csv_to_participants,
+)
+from conftest import make_participants, make_timedelta_matrix
+
+
+def full_matrix(participants, after_party_group, seed=0):
+    """Synthetic uuid-indexed Timedelta matrix over participants + after party."""
+    all_people = participants + [after_party_group.main_member]
+    rng = np.random.default_rng(seed)
+    n = len(all_people)
+    seconds = rng.integers(60, 1200, size=(n, n)).astype(float)
+    np.fill_diagonal(seconds, 0)
+    return make_timedelta_matrix(all_people, seconds)
+
+
+class TestGetAfterPartyGroup:
+    def test_single_member_with_no_penalty(self):
+        group = get_after_party_group("party street 1")
+        assert len(group.members) == 1
+        assert group.main_member.address == "party street 1"
+        assert group.main_member.get_penalty().total_seconds() == 0
+
+
+class TestLoadCsv:
+    def test_parses_tab_separated_file(self, tmp_path):
+        csv = tmp_path / "config.csv"
+        csv.write_text(
+            "name\taddress\tphone\tkitchen_size\tallergies\n"
+            "Alice\tStreet 1\t111\t8\tnone\n"
+            "Bob\tStreet 2\t222\t5\tpeanuts\n"
+        )
+        participants = load_csv_to_participants(str(csv))
+        assert [p.name for p in participants] == ["Alice", "Bob"]
+        assert participants[0].address == "Street 1"
+        assert participants[1].kitchen_size == 5
+
+
+class TestAssignCourses:
+    def test_assigns_cycling_courses_and_hosts(self):
+        groups = [Group(members=[p]) for p in make_participants(6)]
+        courses = ["starter", "main", "dessert"] * 2
+        assign_courses(groups, courses)
+        assert [g.course for g in groups] == courses
+        for i, group in enumerate(groups):
+            expected_host_uuids = {groups[j].uuid for j in get_courses(i, len(groups))}
+            assert {h.uuid for h in group.hosts} == expected_host_uuids
+            assert group.uuid in {h.uuid for h in group.hosts}
+
+
+class TestGetMasterplan:
+    @pytest.mark.parametrize("n", [6, 12, 18])
+    def test_group_count_and_coverage(self, n):
+        participants = make_participants(n, kitchen_sizes=list(np.linspace(0, 10, n)))
+        after_party = get_after_party_group("party street")
+        matrix = full_matrix(participants, after_party)
+
+        group_dicts, participant_dicts = get_masterplan(
+            participants, matrix, after_party
+        )
+
+        expected_groups = 3 * (n // 6)
+        assert len(group_dicts) == expected_groups
+        assert len(participant_dicts) == n
+
+        # Every participant ends up in exactly one group.
+        assigned = [uuid for g in group_dicts for uuid in g["members"]]
+        assert len(assigned) == n
+        assert set(assigned) == {p.uuid for p in participants}
+
+    def test_topology_of_output(self):
+        participants = make_participants(18, kitchen_sizes=list(np.linspace(0, 10, 18)))
+        after_party = get_after_party_group("party street")
+        matrix = full_matrix(participants, after_party)
+
+        group_dicts, _ = get_masterplan(participants, matrix, after_party)
+        by_uuid = {g["uuid"]: g for g in group_dicts}
+
+        # Courses are balanced across the three slots.
+        course_counts = {}
+        for g in group_dicts:
+            course_counts[g["course"]] = course_counts.get(g["course"], 0) + 1
+        assert course_counts == {"starter": 3, "main": 3, "dessert": 3}
+
+        for g in group_dicts:
+            host_courses = sorted(by_uuid[h]["course"] for h in g["hosts"])
+            assert host_courses == ["dessert", "main", "starter"]
+            assert g["uuid"] in g["hosts"]  # a group hosts its own course
+
+    def test_does_not_mutate_input_participant_order(self):
+        participants = make_participants(12)
+        original_order = list(participants)
+        after_party = get_after_party_group("party street")
+        matrix = full_matrix(participants, after_party)
+        get_masterplan(participants, matrix, after_party)
+        assert participants == original_order
+
+
+class TestCostConsistency:
+    def test_fast_total_time_matches_group_get_total_time(self):
+        # The optimizer cost (fast_total_time on the penalty-baked reduced matrix)
+        # must equal the sum of per-group route times computed independently by
+        # Group.get_total_time on the raw matrix.
+        n = 6
+        participants = make_participants(n, kitchen_sizes=[10, 8, 6, 4, 2, 0])
+        after_party = get_after_party_group("party street")
+        groups = [Group(members=[p]) for p in participants]
+        courses = ["starter", "main", "dessert"] * (n // 3)
+        assign_courses(groups, courses)
+
+        full = full_matrix(participants, after_party, seed=5)
+
+        reduced = reduce_distance_matrix(full, [*groups, after_party])
+        reduced_seconds = np.array(
+            [[pd_to_seconds(x) for x in row] for row in reduced.to_numpy()],
+            dtype=float,
+        )
+        optimizer_cost = fast_total_time(reduced_seconds, list(range(n)))
+
+        independent_cost = sum(
+            g.get_total_time(full, after_party).total_seconds() for g in groups
+        )
+        assert optimizer_cost == pytest.approx(independent_cost)
+
+
+def pd_to_seconds(value):
+    import pandas as pd
+
+    return pd.Timedelta(value).total_seconds()

tests/test_routing.py

@@ -0,0 +1,153 @@
+"""Tests for the dinner-rotation topology and the route-cost / optimization logic.
+
+These cover the two areas most prone to subtle bugs: the ``get_courses`` rotation
+(who hosts whom) and ``fast_total_time`` / ``simulated_annealing`` (the route cost
+and its optimization).
+"""
+
+import itertools
+from collections import Counter
+
+import numpy as np
+import pytest
+
+from tatami.tatami_masterplan import (
+    fast_total_time,
+    get_courses,
+    simulated_annealing,
+)
+
+# Group counts must be multiples of 3 (one slot per course); test a range of sizes.
+GROUP_COUNTS = [3, 6, 9, 12, 15]
+
+
+def asymmetric_matrix(n: int, seed: int = 0) -> np.ndarray:
+    """Random asymmetric (n+1)x(n+1) cost matrix, last index = after party."""
+    rng = np.random.default_rng(seed)
+    matrix = rng.integers(60, 1200, size=(n + 1, n + 1)).astype(float)
+    np.fill_diagonal(matrix, 0)
+    return matrix
+
+
+class TestGetCourses:
+    @pytest.mark.parametrize("n", GROUP_COUNTS)
+    def test_group_is_its_own_first_host(self, n):
+        # A group always hosts the course it cooks, so it appears in its own host list.
+        for i in range(n):
+            assert i in get_courses(i, n)
+
+    @pytest.mark.parametrize("n", GROUP_COUNTS)
+    def test_each_group_visits_three_distinct_courses(self, n):
+        for i in range(n):
+            hosts = get_courses(i, n)
+            assert len(hosts) == 3
+            assert len(set(hosts)) == 3, "a group must visit three distinct hosts"
+            # The three hosts must cook three different courses (course == index % 3).
+            assert {h % 3 for h in hosts} == {0, 1, 2}
+
+    @pytest.mark.parametrize("n", GROUP_COUNTS)
+    def test_hosts_returned_in_starter_main_dessert_order(self, n):
+        # get_courses sorts by index % 3 -> starter(0), main(1), dessert(2).
+        for i in range(n):
+            a, b, c = get_courses(i, n)
+            assert (a % 3, b % 3, c % 3) == (0, 1, 2)
+
+    @pytest.mark.parametrize("n", GROUP_COUNTS)
+    def test_every_host_receives_exactly_three_groups(self, n):
+        # The defining invariant of a running dinner: every hosting location serves
+        # exactly three groups (itself + two guests) for its course.
+        received = Counter()
+        for i in range(n):
+            for host in get_courses(i, n):
+                received[host] += 1
+        assert set(received.values()) == {3}
+        assert len(received) == n
+
+    @pytest.mark.parametrize("n", GROUP_COUNTS)
+    def test_guests_at_each_host_cook_distinct_courses(self, n):
+        # Invert the relation: the (exactly three) groups that show up at host h for
+        # its course must each be responsible for a different course in the rotation.
+        hosts_of = {i: set(get_courses(i, n)) for i in range(n)}
+        for host in range(n):
+            guests = [g for g in range(n) if host in hosts_of[g]]
+            assert len(guests) == 3
+            assert {g % 3 for g in guests} == {0, 1, 2}
+
+
+class TestFastTotalTime:
+    def test_matches_hand_computed_value_n3(self):
+        # For n=3 every slot resolves to hosts (0, 1, 2), so the cost is
+        # 3 * (D[s0][s1] + D[s1][s2] + D[s2][afterparty]).
+        matrix = np.array(
+            [
+                [0, 10, 20, 30],
+                [40, 0, 50, 60],
+                [70, 80, 0, 90],
+                [1, 2, 3, 0],  # after-party row (unused as origin)
+            ],
+            dtype=float,
+        )
+        solution = [0, 1, 2]
+        expected = 3 * (matrix[0][1] + matrix[1][2] + matrix[2][3])
+        assert fast_total_time(matrix, solution) == pytest.approx(expected)
+
+    def test_cost_depends_on_permutation(self):
+        # The whole point of the optimizer: different slot->group assignments must
+        # generally produce different costs on an asymmetric matrix.
+        matrix = asymmetric_matrix(6, seed=2)
+        costs = {
+            fast_total_time(matrix, list(p))
+            for p in itertools.islice(itertools.permutations(range(6)), 50)
+        }
+        assert len(costs) > 1
+
+    def test_returns_float(self):
+        matrix = asymmetric_matrix(6, seed=2)
+        assert isinstance(fast_total_time(matrix, list(range(6))), float)
+
+
+class TestSimulatedAnnealing:
+    @pytest.mark.parametrize("seed", [0, 1, 2, 3, 4])
+    def test_never_returns_worse_than_optimum(self, seed):
+        # Sanity floor: the cost can never be below the true (brute-force) optimum.
+        n = 6
+        matrix = asymmetric_matrix(n, seed=seed)
+        optimum = min(
+            fast_total_time(matrix, list(p)) for p in itertools.permutations(range(n))
+        )
+        result = simulated_annealing(matrix, list(range(n)), 1000, 0.99, 5000)
+        assert fast_total_time(matrix, result) >= optimum
+
+    @pytest.mark.parametrize("seed", [0, 1, 2, 3, 4])
+    def test_beats_random_baseline(self, seed):
+        # SA should reliably do better than the average random ordering.
+        n = 9
+        matrix = asymmetric_matrix(n, seed=seed)
+        random_costs = []
+        for _ in range(500):
+            perm = list(range(n))
+            np.random.shuffle(perm)
+            random_costs.append(fast_total_time(matrix, perm))
+        result = simulated_annealing(matrix, list(range(n)), 1000, 0.99, 5000)
+        assert fast_total_time(matrix, result) < np.mean(random_costs)
+
+    def test_returns_valid_permutation(self):
+        n = 9
+        matrix = asymmetric_matrix(n, seed=3)
+        result = simulated_annealing(matrix, list(range(n)), 1000, 0.99, 1000)
+        assert sorted(result) == list(range(n))
+
+    def test_handles_single_slot(self):
+        matrix = asymmetric_matrix(1, seed=0)
+        assert simulated_annealing(matrix, [0], 1000, 0.99, 100) == [0]
+
+    def test_handles_empty(self):
+        matrix = np.zeros((1, 1))
+        assert simulated_annealing(matrix, [], 1000, 0.99, 100) == []
+
+    def test_does_not_mutate_input_indices(self):
+        n = 6
+        matrix = asymmetric_matrix(n, seed=1)
+        indices = list(range(n))
+        simulated_annealing(matrix, indices, 1000, 0.99, 100)
+        assert indices == list(range(n))

tests/test_traveltimes.py

@@ -0,0 +1,121 @@
+"""Tests for the Google Routes API wrapper (HTTP layer mocked)."""
+
+import datetime as dt
+
+import numpy as np
+import pandas as pd
+import pytest
+
+import tatami.traveltimes as tt
+from tatami.classes import Group
+from tatami.traveltimes import (
+    get_distance_matrix,
+    get_participant_distance_matrix,
+    reduce_distance_matrix,
+)
+from conftest import make_participants, make_timedelta_matrix
+
+
+class FakeResponse:
+    def __init__(self, status_code, json_data=None, text=""):
+        self.status_code = status_code
+        self._json = json_data
+        self.text = text
+
+    def json(self):
+        return self._json
+
+
+def route_matrix_payload(durations_seconds):
+    """Build a computeRouteMatrix-style flat list of elements from an n x n array."""
+    payload = []
+    n = len(durations_seconds)
+    for i in range(n):
+        for j in range(n):
+            payload.append(
+                {
+                    "originIndex": i,
+                    "destinationIndex": j,
+                    "duration": f"{int(durations_seconds[i][j])}s",
+                    "distanceMeters": int(durations_seconds[i][j]) * 4,
+                }
+            )
+    return payload
+
+
+@pytest.fixture
+def mock_post(monkeypatch):
+    """Patch requests.post; returns a setter for the desired response."""
+    state = {}
+
+    def fake_post(url, json=None, headers=None):
+        return state["response"]
+
+    monkeypatch.setattr(tt.requests, "post", fake_post)
+
+    def set_response(response):
+        state["response"] = response
+
+    return set_response
+
+
+class TestGetDistanceMatrix:
+    def test_builds_duration_matrix(self, mock_post):
+        durations = np.array([[0, 120], [300, 0]])
+        mock_post(FakeResponse(200, route_matrix_payload(durations)))
+        matrix = get_distance_matrix(["a", "b"])
+        assert matrix.shape == (2, 2)
+        assert matrix.loc[0, 1] == pd.to_timedelta("120s")
+        assert matrix.loc[1, 0] == pd.to_timedelta("300s")
+
+    def test_distance_meters_value(self, mock_post):
+        durations = np.array([[0, 120], [300, 0]])
+        mock_post(FakeResponse(200, route_matrix_payload(durations)))
+        matrix = get_distance_matrix(["a", "b"], value="distanceMeters")
+        assert matrix.loc[0, 1] == 480.0
+
+    def test_empty_addresses_raises(self):
+        with pytest.raises(ValueError):
+            get_distance_matrix([])
+
+    def test_non_200_raises(self, mock_post):
+        mock_post(FakeResponse(500, text="boom"))
+        with pytest.raises(Exception, match="boom"):
+            get_distance_matrix(["a", "b"])
+
+    def test_invalid_value_raises(self, mock_post):
+        durations = np.array([[0, 120], [300, 0]])
+        mock_post(FakeResponse(200, route_matrix_payload(durations)))
+        with pytest.raises(ValueError):
+            get_distance_matrix(["a", "b"], value="bogus")
+
+
+class TestGetParticipantDistanceMatrix:
+    def test_labels_axes_with_uuids(self, mock_post):
+        participants = make_participants(2)
+        durations = np.array([[0, 120], [300, 0]])
+        mock_post(FakeResponse(200, route_matrix_payload(durations)))
+        matrix = get_participant_distance_matrix(participants)
+        uuids = [p.uuid for p in participants]
+        assert list(matrix.index) == uuids
+        assert list(matrix.columns) == uuids
+
+
+class TestReduceDistanceMatrix:
+    def test_selects_main_members_and_adds_penalty(self):
+        # group 0 main member has kitchen_size 7 -> 9 minute (540s) penalty.
+        people = make_participants(2, kitchen_sizes=[7.0, 10.0])
+        seconds = np.array([[0, 100], [200, 0]])
+        matrix = make_timedelta_matrix(people, seconds)
+        groups = [Group(members=[people[0]]), Group(members=[people[1]])]
+
+        reduced = reduce_distance_matrix(matrix, groups)
+
+        u0, u1 = people[0].uuid, people[1].uuid
+        assert list(reduced.index) == [u0, u1]
+        # Penalty added to every entry of group 0's row.
+        assert reduced.loc[u0, u1] == dt.timedelta(seconds=100) + dt.timedelta(
+            minutes=9
+        )
+        # Group 1 has no penalty (kitchen_size 10).
+        assert reduced.loc[u1, u0] == dt.timedelta(seconds=200)

uv.lock

@@ -1,53 +1,63 @@
 version = 1
+revision = 3
 requires-python = ">=3.13"
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577, upload-time = "2025-01-31T02:16:47.166Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 },
+    { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393, upload-time = "2025-01-31T02:16:45.015Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188, upload-time = "2024-12-24T18:12:35.43Z" }
 wheels = [
-    { 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 },
+    { 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, upload-time = "2024-12-24T18:11:05.834Z" },
+    { 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, upload-time = "2024-12-24T18:11:07.064Z" },
+    { 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, upload-time = "2024-12-24T18:11:08.374Z" },
+    { 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, upload-time = "2024-12-24T18:11:09.831Z" },
+    { 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, upload-time = "2024-12-24T18:11:12.03Z" },
+    { 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, upload-time = "2024-12-24T18:11:13.372Z" },
+    { 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, upload-time = "2024-12-24T18:11:14.628Z" },
+    { 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, upload-time = "2024-12-24T18:11:17.672Z" },
+    { 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, upload-time = "2024-12-24T18:11:18.989Z" },
+    { 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, upload-time = "2024-12-24T18:11:21.507Z" },
+    { 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, upload-time = "2024-12-24T18:11:22.774Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391, upload-time = "2024-12-24T18:11:24.139Z" },
+    { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702, upload-time = "2024-12-24T18:11:26.535Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767, upload-time = "2024-12-24T18:12:32.852Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
 ]
 
 [[package]]
@@ -58,52 +68,61 @@ dependencies = [
     { name = "mypy-extensions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717 }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717, upload-time = "2025-02-05T03:50:34.655Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/9b/fd2e05d6ffff24d912f150b87db9e364fa8282045c875654ce7e32fffa66/mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445", size = 10788592 },
-    { url = "https://files.pythonhosted.org/packages/74/37/b246d711c28a03ead1fd906bbc7106659aed7c089d55fe40dd58db812628/mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d", size = 9753611 },
-    { url = "https://files.pythonhosted.org/packages/a6/ac/395808a92e10cfdac8003c3de9a2ab6dc7cde6c0d2a4df3df1b815ffd067/mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5", size = 11438443 },
-    { url = "https://files.pythonhosted.org/packages/d2/8b/801aa06445d2de3895f59e476f38f3f8d610ef5d6908245f07d002676cbf/mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036", size = 12402541 },
-    { url = "https://files.pythonhosted.org/packages/c7/67/5a4268782eb77344cc613a4cf23540928e41f018a9a1ec4c6882baf20ab8/mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357", size = 12494348 },
-    { url = "https://files.pythonhosted.org/packages/83/3e/57bb447f7bbbfaabf1712d96f9df142624a386d98fb026a761532526057e/mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf", size = 9373648 },
-    { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777 },
+    { url = "https://files.pythonhosted.org/packages/6a/9b/fd2e05d6ffff24d912f150b87db9e364fa8282045c875654ce7e32fffa66/mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445", size = 10788592, upload-time = "2025-02-05T03:48:55.789Z" },
+    { url = "https://files.pythonhosted.org/packages/74/37/b246d711c28a03ead1fd906bbc7106659aed7c089d55fe40dd58db812628/mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d", size = 9753611, upload-time = "2025-02-05T03:48:44.581Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/ac/395808a92e10cfdac8003c3de9a2ab6dc7cde6c0d2a4df3df1b815ffd067/mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5", size = 11438443, upload-time = "2025-02-05T03:49:25.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/8b/801aa06445d2de3895f59e476f38f3f8d610ef5d6908245f07d002676cbf/mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036", size = 12402541, upload-time = "2025-02-05T03:49:57.623Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/67/5a4268782eb77344cc613a4cf23540928e41f018a9a1ec4c6882baf20ab8/mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357", size = 12494348, upload-time = "2025-02-05T03:48:52.361Z" },
+    { url = "https://files.pythonhosted.org/packages/83/3e/57bb447f7bbbfaabf1712d96f9df142624a386d98fb026a761532526057e/mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf", size = 9373648, upload-time = "2025-02-05T03:49:11.395Z" },
+    { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777, upload-time = "2025-02-05T03:50:08.348Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433, upload-time = "2023-02-04T12:11:27.157Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
+    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695, upload-time = "2023-02-04T12:11:25.002Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/78/31103410a57bc2c2b93a3597340a8119588571f6a4539067546cb9a0bfac/numpy-2.2.4.tar.gz", hash = "sha256:9ba03692a45d3eef66559efe1d1096c4b9b75c0986b5dff5530c378fb8331d4f", size = 20270701, upload-time = "2025-03-16T18:27:00.648Z" }
 wheels = [
-    { 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/2a/d0/bd5ad792e78017f5decfb2ecc947422a3669a34f775679a76317af671ffc/numpy-2.2.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cf4e5c6a278d620dee9ddeb487dc6a860f9b199eadeecc567f777daace1e9e7", size = 20933623, upload-time = "2025-03-16T18:13:43.231Z" },
+    { 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, upload-time = "2025-03-16T18:14:08.031Z" },
+    { 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, upload-time = "2025-03-16T18:14:18.613Z" },
+    { 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, upload-time = "2025-03-16T18:14:31.386Z" },
+    { 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, upload-time = "2025-03-16T18:14:54.83Z" },
+    { 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, upload-time = "2025-03-16T18:15:22.035Z" },
+    { 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, upload-time = "2025-03-16T18:15:48.546Z" },
+    { 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, upload-time = "2025-03-16T18:16:20.274Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/eb/38c06217a5f6de27dcb41524ca95a44e395e6a1decdc0c99fec0832ce6ae/numpy-2.2.4-cp313-cp313-win32.whl", hash = "sha256:f486038e44caa08dbd97275a9a35a283a8f1d2f0ee60ac260a1790e76660833c", size = 6308141, upload-time = "2025-03-16T18:20:15.297Z" },
+    { url = "https://files.pythonhosted.org/packages/52/17/d0dd10ab6d125c6d11ffb6dfa3423c3571befab8358d4f85cd4471964fcd/numpy-2.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:207a2b8441cc8b6a2a78c9ddc64d00d20c303d79fba08c577752f080c4007ee3", size = 12636885, upload-time = "2025-03-16T18:20:36.982Z" },
+    { 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, upload-time = "2025-03-16T18:16:56.191Z" },
+    { 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, upload-time = "2025-03-16T18:17:22.811Z" },
+    { 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, upload-time = "2025-03-16T18:17:34.066Z" },
+    { 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, upload-time = "2025-03-16T18:17:47.466Z" },
+    { 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, upload-time = "2025-03-16T18:18:11.904Z" },
+    { 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, upload-time = "2025-03-16T18:18:40.749Z" },
+    { 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, upload-time = "2025-03-16T18:19:04.512Z" },
+    { 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, upload-time = "2025-03-16T18:19:32.52Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2b/878576190c5cfa29ed896b518cc516aecc7c98a919e20706c12480465f43/numpy-2.2.4-cp313-cp313t-win32.whl", hash = "sha256:05c076d531e9998e7e694c36e8b349969c56eadd2cdcd07242958489d79a7286", size = 6366896, upload-time = "2025-03-16T18:19:43.55Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/05/eb7eec66b95cf697f08c754ef26c3549d03ebd682819f794cb039574a0a6/numpy-2.2.4-cp313-cp313t-win_amd64.whl", hash = "sha256:188dcbca89834cc2e14eb2f106c96d6d46f200fe0200310fc29089657379c58d", size = 12739119, upload-time = "2025-03-16T18:20:03.94Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
 ]
 
 [[package]]
@@ -116,21 +135,21 @@ dependencies = [
     { 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 }
+sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213, upload-time = "2024-09-20T13:10:04.827Z" }
 wheels = [
-    { 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 },
+    { 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, upload-time = "2024-09-20T13:09:25.522Z" },
+    { 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, upload-time = "2024-09-20T13:09:28.012Z" },
+    { 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, upload-time = "2024-09-20T19:02:10.451Z" },
+    { 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, upload-time = "2024-09-20T13:09:30.814Z" },
+    { 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, upload-time = "2024-09-20T19:02:13.825Z" },
+    { 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, upload-time = "2024-09-20T13:09:33.462Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175, upload-time = "2024-09-20T13:09:35.871Z" },
+    { 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, upload-time = "2024-09-20T13:09:38.685Z" },
+    { 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, upload-time = "2024-09-20T13:09:41.141Z" },
+    { 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, upload-time = "2024-09-20T19:02:16.905Z" },
+    { 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, upload-time = "2024-09-20T13:09:44.39Z" },
+    { 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, upload-time = "2024-09-20T19:02:20.639Z" },
+    { 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, upload-time = "2024-09-20T13:09:48.112Z" },
 ]
 
 [[package]]
@@ -141,9 +160,43 @@ dependencies = [
     { name = "numpy" },
     { name = "types-pytz" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/5a/261f5c67a73e46df2d5984fe7129d66a3ed4864fd7aa9d8721abb3fc802e/pandas_stubs-2.2.3.250308.tar.gz", hash = "sha256:3a6e9daf161f00b85c83772ed3d5cff9522028f07a94817472c07b91f46710fd", size = 103986 }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/5a/261f5c67a73e46df2d5984fe7129d66a3ed4864fd7aa9d8721abb3fc802e/pandas_stubs-2.2.3.250308.tar.gz", hash = "sha256:3a6e9daf161f00b85c83772ed3d5cff9522028f07a94817472c07b91f46710fd", size = 103986, upload-time = "2025-03-08T20:51:04.999Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/64/ab61d9ca06ff66c07eb804ec27dec1a2be1978b3c3767caaa91e363438cc/pandas_stubs-2.2.3.250308-py3-none-any.whl", hash = "sha256:a377edff3b61f8b268c82499fdbe7c00fdeed13235b8b71d6a1dc347aeddc74d", size = 158053 },
+    { url = "https://files.pythonhosted.org/packages/ba/64/ab61d9ca06ff66c07eb804ec27dec1a2be1978b3c3767caaa91e363438cc/pandas_stubs-2.2.3.250308-py3-none-any.whl", hash = "sha256:a377edff3b61f8b268c82499fdbe7c00fdeed13235b8b71d6a1dc347aeddc74d", size = 158053, upload-time = "2025-03-08T20:51:03.411Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
 ]
 
 [[package]]
@@ -153,18 +206,27 @@ 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 }
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
 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 },
+    { 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, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225 },
+    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" },
 ]
 
 [[package]]
@@ -177,43 +239,43 @@ dependencies = [
     { 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 }
+sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218, upload-time = "2024-05-29T15:37:49.536Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 },
+    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928, upload-time = "2024-05-29T15:37:47.027Z" },
 ]
 
 [[package]]
 name = "ruff"
 version = "0.11.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/45/71/5759b2a6b2279bb77fe15b1435b89473631c2cd6374d45ccdb6b785810be/ruff-0.11.5.tar.gz", hash = "sha256:cae2e2439cb88853e421901ec040a758960b576126dab520fa08e9de431d1bef", size = 3976488 }
+sdist = { url = "https://files.pythonhosted.org/packages/45/71/5759b2a6b2279bb77fe15b1435b89473631c2cd6374d45ccdb6b785810be/ruff-0.11.5.tar.gz", hash = "sha256:cae2e2439cb88853e421901ec040a758960b576126dab520fa08e9de431d1bef", size = 3976488, upload-time = "2025-04-10T17:13:29.369Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/23/db/6efda6381778eec7f35875b5cbefd194904832a1153d68d36d6b269d81a8/ruff-0.11.5-py3-none-linux_armv6l.whl", hash = "sha256:2561294e108eb648e50f210671cc56aee590fb6167b594144401532138c66c7b", size = 10103150 },
-    { url = "https://files.pythonhosted.org/packages/44/f2/06cd9006077a8db61956768bc200a8e52515bf33a8f9b671ee527bb10d77/ruff-0.11.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ac12884b9e005c12d0bd121f56ccf8033e1614f736f766c118ad60780882a077", size = 10898637 },
-    { url = "https://files.pythonhosted.org/packages/18/f5/af390a013c56022fe6f72b95c86eb7b2585c89cc25d63882d3bfe411ecf1/ruff-0.11.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4bfd80a6ec559a5eeb96c33f832418bf0fb96752de0539905cf7b0cc1d31d779", size = 10236012 },
-    { url = "https://files.pythonhosted.org/packages/b8/ca/b9bf954cfed165e1a0c24b86305d5c8ea75def256707f2448439ac5e0d8b/ruff-0.11.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0947c0a1afa75dcb5db4b34b070ec2bccee869d40e6cc8ab25aca11a7d527794", size = 10415338 },
-    { url = "https://files.pythonhosted.org/packages/d9/4d/2522dde4e790f1b59885283f8786ab0046958dfd39959c81acc75d347467/ruff-0.11.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ad871ff74b5ec9caa66cb725b85d4ef89b53f8170f47c3406e32ef040400b038", size = 9965277 },
-    { url = "https://files.pythonhosted.org/packages/e5/7a/749f56f150eef71ce2f626a2f6988446c620af2f9ba2a7804295ca450397/ruff-0.11.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e6cf918390cfe46d240732d4d72fa6e18e528ca1f60e318a10835cf2fa3dc19f", size = 11541614 },
-    { url = "https://files.pythonhosted.org/packages/89/b2/7d9b8435222485b6aac627d9c29793ba89be40b5de11584ca604b829e960/ruff-0.11.5-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:56145ee1478582f61c08f21076dc59153310d606ad663acc00ea3ab5b2125f82", size = 12198873 },
-    { url = "https://files.pythonhosted.org/packages/00/e0/a1a69ef5ffb5c5f9c31554b27e030a9c468fc6f57055886d27d316dfbabd/ruff-0.11.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5f66f8f1e8c9fc594cbd66fbc5f246a8d91f916cb9667e80208663ec3728304", size = 11670190 },
-    { url = "https://files.pythonhosted.org/packages/05/61/c1c16df6e92975072c07f8b20dad35cd858e8462b8865bc856fe5d6ccb63/ruff-0.11.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80b4df4d335a80315ab9afc81ed1cff62be112bd165e162b5eed8ac55bfc8470", size = 13902301 },
-    { url = "https://files.pythonhosted.org/packages/79/89/0af10c8af4363304fd8cb833bd407a2850c760b71edf742c18d5a87bb3ad/ruff-0.11.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3068befab73620b8a0cc2431bd46b3cd619bc17d6f7695a3e1bb166b652c382a", size = 11350132 },
-    { url = "https://files.pythonhosted.org/packages/b9/e1/ecb4c687cbf15164dd00e38cf62cbab238cad05dd8b6b0fc68b0c2785e15/ruff-0.11.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f5da2e710a9641828e09aa98b92c9ebbc60518fdf3921241326ca3e8f8e55b8b", size = 10312937 },
-    { url = "https://files.pythonhosted.org/packages/cf/4f/0e53fe5e500b65934500949361e3cd290c5ba60f0324ed59d15f46479c06/ruff-0.11.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ef39f19cb8ec98cbc762344921e216f3857a06c47412030374fffd413fb8fd3a", size = 9936683 },
-    { url = "https://files.pythonhosted.org/packages/04/a8/8183c4da6d35794ae7f76f96261ef5960853cd3f899c2671961f97a27d8e/ruff-0.11.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b2a7cedf47244f431fd11aa5a7e2806dda2e0c365873bda7834e8f7d785ae159", size = 10950217 },
-    { url = "https://files.pythonhosted.org/packages/26/88/9b85a5a8af21e46a0639b107fcf9bfc31da4f1d263f2fc7fbe7199b47f0a/ruff-0.11.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:81be52e7519f3d1a0beadcf8e974715b2dfc808ae8ec729ecfc79bddf8dbb783", size = 11404521 },
-    { url = "https://files.pythonhosted.org/packages/fc/52/047f35d3b20fd1ae9ccfe28791ef0f3ca0ef0b3e6c1a58badd97d450131b/ruff-0.11.5-py3-none-win32.whl", hash = "sha256:e268da7b40f56e3eca571508a7e567e794f9bfcc0f412c4b607931d3af9c4afe", size = 10320697 },
-    { url = "https://files.pythonhosted.org/packages/b9/fe/00c78010e3332a6e92762424cf4c1919065707e962232797d0b57fd8267e/ruff-0.11.5-py3-none-win_amd64.whl", hash = "sha256:6c6dc38af3cfe2863213ea25b6dc616d679205732dc0fb673356c2d69608f800", size = 11378665 },
-    { url = "https://files.pythonhosted.org/packages/43/7c/c83fe5cbb70ff017612ff36654edfebec4b1ef79b558b8e5fd933bab836b/ruff-0.11.5-py3-none-win_arm64.whl", hash = "sha256:67e241b4314f4eacf14a601d586026a962f4002a475aa702c69980a38087aa4e", size = 10460287 },
+    { url = "https://files.pythonhosted.org/packages/23/db/6efda6381778eec7f35875b5cbefd194904832a1153d68d36d6b269d81a8/ruff-0.11.5-py3-none-linux_armv6l.whl", hash = "sha256:2561294e108eb648e50f210671cc56aee590fb6167b594144401532138c66c7b", size = 10103150, upload-time = "2025-04-10T17:12:37.886Z" },
+    { url = "https://files.pythonhosted.org/packages/44/f2/06cd9006077a8db61956768bc200a8e52515bf33a8f9b671ee527bb10d77/ruff-0.11.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ac12884b9e005c12d0bd121f56ccf8033e1614f736f766c118ad60780882a077", size = 10898637, upload-time = "2025-04-10T17:12:41.602Z" },
+    { url = "https://files.pythonhosted.org/packages/18/f5/af390a013c56022fe6f72b95c86eb7b2585c89cc25d63882d3bfe411ecf1/ruff-0.11.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4bfd80a6ec559a5eeb96c33f832418bf0fb96752de0539905cf7b0cc1d31d779", size = 10236012, upload-time = "2025-04-10T17:12:44.584Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ca/b9bf954cfed165e1a0c24b86305d5c8ea75def256707f2448439ac5e0d8b/ruff-0.11.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0947c0a1afa75dcb5db4b34b070ec2bccee869d40e6cc8ab25aca11a7d527794", size = 10415338, upload-time = "2025-04-10T17:12:47.172Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/4d/2522dde4e790f1b59885283f8786ab0046958dfd39959c81acc75d347467/ruff-0.11.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ad871ff74b5ec9caa66cb725b85d4ef89b53f8170f47c3406e32ef040400b038", size = 9965277, upload-time = "2025-04-10T17:12:50.628Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/7a/749f56f150eef71ce2f626a2f6988446c620af2f9ba2a7804295ca450397/ruff-0.11.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e6cf918390cfe46d240732d4d72fa6e18e528ca1f60e318a10835cf2fa3dc19f", size = 11541614, upload-time = "2025-04-10T17:12:53.783Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b2/7d9b8435222485b6aac627d9c29793ba89be40b5de11584ca604b829e960/ruff-0.11.5-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:56145ee1478582f61c08f21076dc59153310d606ad663acc00ea3ab5b2125f82", size = 12198873, upload-time = "2025-04-10T17:12:56.956Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e0/a1a69ef5ffb5c5f9c31554b27e030a9c468fc6f57055886d27d316dfbabd/ruff-0.11.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5f66f8f1e8c9fc594cbd66fbc5f246a8d91f916cb9667e80208663ec3728304", size = 11670190, upload-time = "2025-04-10T17:13:00.194Z" },
+    { url = "https://files.pythonhosted.org/packages/05/61/c1c16df6e92975072c07f8b20dad35cd858e8462b8865bc856fe5d6ccb63/ruff-0.11.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80b4df4d335a80315ab9afc81ed1cff62be112bd165e162b5eed8ac55bfc8470", size = 13902301, upload-time = "2025-04-10T17:13:03.246Z" },
+    { url = "https://files.pythonhosted.org/packages/79/89/0af10c8af4363304fd8cb833bd407a2850c760b71edf742c18d5a87bb3ad/ruff-0.11.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3068befab73620b8a0cc2431bd46b3cd619bc17d6f7695a3e1bb166b652c382a", size = 11350132, upload-time = "2025-04-10T17:13:06.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e1/ecb4c687cbf15164dd00e38cf62cbab238cad05dd8b6b0fc68b0c2785e15/ruff-0.11.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f5da2e710a9641828e09aa98b92c9ebbc60518fdf3921241326ca3e8f8e55b8b", size = 10312937, upload-time = "2025-04-10T17:13:08.855Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4f/0e53fe5e500b65934500949361e3cd290c5ba60f0324ed59d15f46479c06/ruff-0.11.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ef39f19cb8ec98cbc762344921e216f3857a06c47412030374fffd413fb8fd3a", size = 9936683, upload-time = "2025-04-10T17:13:11.378Z" },
+    { url = "https://files.pythonhosted.org/packages/04/a8/8183c4da6d35794ae7f76f96261ef5960853cd3f899c2671961f97a27d8e/ruff-0.11.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b2a7cedf47244f431fd11aa5a7e2806dda2e0c365873bda7834e8f7d785ae159", size = 10950217, upload-time = "2025-04-10T17:13:14.565Z" },
+    { url = "https://files.pythonhosted.org/packages/26/88/9b85a5a8af21e46a0639b107fcf9bfc31da4f1d263f2fc7fbe7199b47f0a/ruff-0.11.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:81be52e7519f3d1a0beadcf8e974715b2dfc808ae8ec729ecfc79bddf8dbb783", size = 11404521, upload-time = "2025-04-10T17:13:17.8Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/52/047f35d3b20fd1ae9ccfe28791ef0f3ca0ef0b3e6c1a58badd97d450131b/ruff-0.11.5-py3-none-win32.whl", hash = "sha256:e268da7b40f56e3eca571508a7e567e794f9bfcc0f412c4b607931d3af9c4afe", size = 10320697, upload-time = "2025-04-10T17:13:20.582Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/fe/00c78010e3332a6e92762424cf4c1919065707e962232797d0b57fd8267e/ruff-0.11.5-py3-none-win_amd64.whl", hash = "sha256:6c6dc38af3cfe2863213ea25b6dc616d679205732dc0fb673356c2d69608f800", size = 11378665, upload-time = "2025-04-10T17:13:23.349Z" },
+    { url = "https://files.pythonhosted.org/packages/43/7c/c83fe5cbb70ff017612ff36654edfebec4b1ef79b558b8e5fd933bab836b/ruff-0.11.5-py3-none-win_arm64.whl", hash = "sha256:67e241b4314f4eacf14a601d586026a962f4002a475aa702c69980a38087aa4e", size = 10460287, upload-time = "2025-04-10T17:13:26.538Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
 ]
 
 [[package]]
@@ -224,6 +286,7 @@ dependencies = [
     { name = "numpy" },
     { name = "pandas" },
     { name = "pandas-stubs" },
+    { name = "python-dotenv" },
     { name = "requests" },
     { name = "tqdm" },
     { name = "types-requests" },
@@ -233,6 +296,7 @@ dependencies = [
 [package.dev-dependencies]
 dev = [
     { name = "mypy" },
+    { name = "pytest" },
     { name = "ruff" },
 ]
 
@@ -241,6 +305,7 @@ requires-dist = [
     { name = "numpy", specifier = ">=2.2.4" },
     { name = "pandas", specifier = ">=2.2.3" },
     { name = "pandas-stubs", specifier = ">=2.2.3.250308" },
+    { name = "python-dotenv", specifier = ">=1.2.2" },
     { name = "requests", specifier = ">=2.32.3" },
     { name = "tqdm", specifier = ">=4.67.1" },
     { name = "types-requests", specifier = ">=2.32.0.20250328" },
@@ -250,6 +315,7 @@ requires-dist = [
 [package.metadata.requires-dev]
 dev = [
     { name = "mypy", specifier = ">=1.15.0" },
+    { name = "pytest", specifier = ">=9.1.1" },
     { name = "ruff", specifier = ">=0.11.5" },
 ]
 
@@ -260,18 +326,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737 }
+sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540 },
+    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
 ]
 
 [[package]]
 name = "types-pytz"
 version = "2025.2.0.20250326"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4b/66/38c89861242f2c61c8315ddbcc7d7bbf64979f4b0bdc48db0ba62aeec330/types_pytz-2025.2.0.20250326.tar.gz", hash = "sha256:deda02de24f527066fc8d6a19e284ab3f3ae716a42b4adb6b40e75e408c08d36", size = 10595 }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/66/38c89861242f2c61c8315ddbcc7d7bbf64979f4b0bdc48db0ba62aeec330/types_pytz-2025.2.0.20250326.tar.gz", hash = "sha256:deda02de24f527066fc8d6a19e284ab3f3ae716a42b4adb6b40e75e408c08d36", size = 10595, upload-time = "2025-03-26T02:53:12.504Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/e0/17f3a6670db5c95dc195f346e2e7290f22ba8327c188133959389b578cbd/types_pytz-2025.2.0.20250326-py3-none-any.whl", hash = "sha256:3c397fd1b845cd2b3adc9398607764ced9e578a98a5d1fbb4a9bc9253edfb162", size = 10222 },
+    { url = "https://files.pythonhosted.org/packages/4e/e0/17f3a6670db5c95dc195f346e2e7290f22ba8327c188133959389b578cbd/types_pytz-2025.2.0.20250326-py3-none-any.whl", hash = "sha256:3c397fd1b845cd2b3adc9398607764ced9e578a98a5d1fbb4a9bc9253edfb162", size = 10222, upload-time = "2025-03-26T02:53:11.145Z" },
 ]
 
 [[package]]
@@ -281,9 +347,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/00/7d/eb174f74e3f5634eaacb38031bbe467dfe2e545bc255e5c90096ec46bc46/types_requests-2.32.0.20250328.tar.gz", hash = "sha256:c9e67228ea103bd811c96984fac36ed2ae8da87a36a633964a21f199d60baf32", size = 22995 }
+sdist = { url = "https://files.pythonhosted.org/packages/00/7d/eb174f74e3f5634eaacb38031bbe467dfe2e545bc255e5c90096ec46bc46/types_requests-2.32.0.20250328.tar.gz", hash = "sha256:c9e67228ea103bd811c96984fac36ed2ae8da87a36a633964a21f199d60baf32", size = 22995, upload-time = "2025-03-28T02:55:13.271Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/15/3700282a9d4ea3b37044264d3e4d1b1f0095a4ebf860a99914fd544e3be3/types_requests-2.32.0.20250328-py3-none-any.whl", hash = "sha256:72ff80f84b15eb3aa7a8e2625fffb6a93f2ad5a0c20215fc1dcfa61117bcb2a2", size = 20663 },
+    { url = "https://files.pythonhosted.org/packages/cc/15/3700282a9d4ea3b37044264d3e4d1b1f0095a4ebf860a99914fd544e3be3/types_requests-2.32.0.20250328-py3-none-any.whl", hash = "sha256:72ff80f84b15eb3aa7a8e2625fffb6a93f2ad5a0c20215fc1dcfa61117bcb2a2", size = 20663, upload-time = "2025-03-28T02:55:11.946Z" },
 ]
 
 [[package]]
@@ -293,34 +359,34 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "types-requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/a1/75e0d6f96f8c34a1bad6c232566182f2ae53ffdf7ab9c75afb61b2a07354/types_tqdm-4.67.0.20250404.tar.gz", hash = "sha256:e9997c655ffbba3ab78f4418b5511c05a54e76824d073d212166dc73aa56c768", size = 17159 }
+sdist = { url = "https://files.pythonhosted.org/packages/f4/a1/75e0d6f96f8c34a1bad6c232566182f2ae53ffdf7ab9c75afb61b2a07354/types_tqdm-4.67.0.20250404.tar.gz", hash = "sha256:e9997c655ffbba3ab78f4418b5511c05a54e76824d073d212166dc73aa56c768", size = 17159, upload-time = "2025-04-04T02:54:51.397Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/35/85/2c09e94d2554e8314cbc74f897c1b3012930b34a22f6905bb0b9fb79f40e/types_tqdm-4.67.0.20250404-py3-none-any.whl", hash = "sha256:4a9b897eb4036f757240f4cb4a794f296265c04de46fdd058e453891f0186eed", size = 24053 },
+    { url = "https://files.pythonhosted.org/packages/35/85/2c09e94d2554e8314cbc74f897c1b3012930b34a22f6905bb0b9fb79f40e/types_tqdm-4.67.0.20250404-py3-none-any.whl", hash = "sha256:4a9b897eb4036f757240f4cb4a794f296265c04de46fdd058e453891f0186eed", size = 24053, upload-time = "2025-04-04T02:54:50.2Z" },
 ]
 
 [[package]]
 name = "typing-extensions"
 version = "4.13.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967 }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967, upload-time = "2025-04-10T14:19:05.416Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806 },
+    { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806, upload-time = "2025-04-10T14:19:03.967Z" },
 ]
 
 [[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 }
+sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 },
+    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },
 ]
 
 [[package]]
 name = "urllib3"
 version = "2.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672 }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672, upload-time = "2025-04-10T15:23:39.232Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680 },
+    { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680, upload-time = "2025-04-10T15:23:37.377Z" },
 ]