commit 655db6839b8d3cb44268a671223e9d8e96b86221 Author: fn-registry agent Date: Sat May 30 17:28:44 2026 +0200 chore: sync from fn-registry agent diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md new file mode 100644 index 0000000..36a65c7 --- /dev/null +++ b/.claude/CLAUDE.md @@ -0,0 +1,40 @@ +# JUPYTER HABILITADO EN ESTE ANALISIS + +## Reglas OBLIGATORIAS para Claude + +### 1. CODIGO INMUTABLE — NUNCA MODIFICAR CELDAS EXISTENTES +- **PROHIBIDO** usar NotebookEdit para reemplazar celdas existentes +- **SIEMPRE** anadir celdas NUEVAS al final del notebook +- Si hay un error en una celda, crear celda nueva con la correccion +- El historial de trabajo debe quedar intacto para trazabilidad + +### 2. PROGRAMACION FUNCIONAL OBLIGATORIA +- **Funciones puras**: sin efectos secundarios, mismo input -> mismo output +- **Inmutabilidad**: nunca mutar datos, crear copias transformadas +- **Composicion**: funciones pequenas que se combinan +- Preferir: `map`, `filter`, `reduce`, list comprehensions +- Evitar: loops con mutacion, `global`, modificar argumentos in-place + +### 3. SIEMPRE usar MCP jupyter para ejecutar codigo Python +- Las ejecuciones se ven en tiempo real en Jupyter Lab del usuario +- Compartimos variables y estado del kernel +- **NUNCA usar bash para ejecutar Python en este analisis** + +### 4. Verificar Jupyter activo ANTES de ejecutar +- Si no esta activo: pedir al usuario que ejecute `./run-jupyter-lab.sh` + +### 5. Gestion de notebooks +- Notebooks en la carpeta `notebooks/` o subcarpetas +- Si un notebook tiene >50 celdas, crear uno nuevo +- Nombrar descriptivamente: `01_exploracion.ipynb`, `02_limpieza.ipynb` + +### 6. Gestion de Python +- **SIEMPRE usar `uv`** para gestionar dependencias +- Anadir paquetes con `uv add nombre_paquete` + +### 7. Acceso al fn_registry +- `FN_REGISTRY_ROOT` apunta a la raiz del registry +- Para importar funciones Python: `sys.path.insert(0, os.path.join(os.environ["FN_REGISTRY_ROOT"], "python", "functions"))` +- Para consultar registry.db: `sqlite3` o `import sqlite3` con la ruta `$FN_REGISTRY_ROOT/registry.db` + + diff --git a/.ipython/profile_default/history.sqlite b/.ipython/profile_default/history.sqlite new file mode 100644 index 0000000..a61f08e Binary files /dev/null and b/.ipython/profile_default/history.sqlite differ diff --git a/.ipython/profile_default/startup/00_fn_registry.py b/.ipython/profile_default/startup/00_fn_registry.py new file mode 100644 index 0000000..b376e1c --- /dev/null +++ b/.ipython/profile_default/startup/00_fn_registry.py @@ -0,0 +1,100 @@ +""" +fn_registry kernel startup +Autoconfigura acceso al registry en cada notebook. +Generado por write_jupyter_registry_kernel (fn_registry). +""" +import os +import sys +import sqlite3 +from pathlib import Path + +# ── FN_REGISTRY_ROOT ──────────────────────────────────────── +# Prioridad: env var > path hardcoded > descubrimiento automatico +def _discover_registry_root(): + if os.environ.get("FN_REGISTRY_ROOT"): + return Path(os.environ["FN_REGISTRY_ROOT"]).resolve() + hardcoded = Path("/home/lucas/fn_registry") + if (hardcoded / "registry.db").exists(): + return hardcoded + # Subir desde CWD hasta encontrar registry.db + p = Path.cwd() + for _ in range(10): + if (p / "registry.db").exists(): + return p + if p.parent == p: + break + p = p.parent + return hardcoded + +FN_REGISTRY_ROOT = _discover_registry_root() +os.environ["FN_REGISTRY_ROOT"] = str(FN_REGISTRY_ROOT) + +# ── sys.path: importar funciones Python del registry ──────── +_python_functions = FN_REGISTRY_ROOT / "python" / "functions" +for _domain in sorted(_python_functions.iterdir()) if _python_functions.exists() else []: + if _domain.is_dir() and not _domain.name.startswith("_"): + _path = str(_domain) + if _path not in sys.path: + sys.path.insert(0, _path) + +# Tambien el directorio padre para imports por dominio: from core import filter_list +_pf = str(_python_functions) +if _pf not in sys.path: + sys.path.insert(0, _pf) + +# ── fn_query: consultar registry.db desde el notebook ─────── +_REGISTRY_DB = FN_REGISTRY_ROOT / "registry.db" + +def fn_query(sql, params=()): + """Ejecuta una consulta SQL sobre registry.db y retorna las filas. + + Ejemplos: + fn_query("SELECT id, description FROM functions WHERE domain = ?", ("finance",)) + fn_query("SELECT id FROM functions_fts WHERE functions_fts MATCH ?", ("slice*",)) + """ + if not _REGISTRY_DB.exists(): + raise FileNotFoundError(f"registry.db no encontrado en {_REGISTRY_DB}") + con = sqlite3.connect(str(_REGISTRY_DB)) + con.row_factory = sqlite3.Row + try: + rows = con.execute(sql, params).fetchall() + return [dict(r) for r in rows] + finally: + con.close() + +def fn_search(term): + """Busca funciones y tipos en el registry por nombre o descripcion. + + Ejemplo: + fn_search("slice") + fn_search("finance") + """ + fts_term = f"name:{term}* OR description:{term}*" + functions = fn_query( + "SELECT id, kind, purity, lang, description FROM functions " + "WHERE id IN (SELECT id FROM functions_fts WHERE functions_fts MATCH ?) " + "ORDER BY name", (fts_term,) + ) + types = fn_query( + "SELECT id, algebraic, lang, description FROM types " + "WHERE id IN (SELECT id FROM types_fts WHERE types_fts MATCH ?) " + "ORDER BY name", (fts_term,) + ) + return {"functions": functions, "types": types} + +def fn_code(function_id): + """Retorna el codigo fuente de una funcion del registry. + + Ejemplo: + print(fn_code("filter_list_py_core")) + """ + rows = fn_query("SELECT code FROM functions WHERE id = ?", (function_id,)) + if not rows: + raise KeyError(f"Funcion no encontrada: {function_id}") + return rows[0]["code"] + +# ── Mensaje de bienvenida ─────────────────────────────────── +print(f"fn_registry conectado: {FN_REGISTRY_ROOT}") +print(f" registry.db: {'OK' if _REGISTRY_DB.exists() else 'NO ENCONTRADO'}") +print(f" Python functions: {_pf}") +print(f" Helpers: fn_query(), fn_search(), fn_code()") diff --git a/.jupyter-port b/.jupyter-port new file mode 100644 index 0000000..5246073 --- /dev/null +++ b/.jupyter-port @@ -0,0 +1 @@ +8888 diff --git a/.jupyter/collaboration_sessions.json b/.jupyter/collaboration_sessions.json new file mode 100644 index 0000000..556d35f --- /dev/null +++ b/.jupyter/collaboration_sessions.json @@ -0,0 +1,7 @@ +{ + "7da6e738-4e80-4249-8b21-6196c839c170": { + "version": "2.4.0", + "created_at": "2026-05-28T20:46:18.369137+00:00", + "document_version": "2.0.0" + } +} \ No newline at end of file diff --git a/.jupyter_ystore.db b/.jupyter_ystore.db new file mode 100644 index 0000000..5cfcb7c Binary files /dev/null and b/.jupyter_ystore.db differ diff --git a/.mcp.json b/.mcp.json new file mode 100644 index 0000000..a4b88b3 --- /dev/null +++ b/.mcp.json @@ -0,0 +1,12 @@ +{ + "mcpServers": { + "jupyter": { + "command": "/home/lucas/fn_registry/projects/imagegen/analysis/spike_image_to_3d/.venv/bin/jupyter-mcp-server", + "args": [ + "--transport", "stdio", + "--jupyter-url", "http://localhost:8888", + "--jupyter-token", "" + ] + } + } +} diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..24ee5b1 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.13 diff --git a/MULTIVIEW_MODELS.md b/MULTIVIEW_MODELS.md new file mode 100644 index 0000000..194d73f --- /dev/null +++ b/MULTIVIEW_MODELS.md @@ -0,0 +1,107 @@ +# Multi-View / Multi-Image Image-to-3D — Research (mayo 2026) + +Investigacion para extender `image_to_3d_studio` (hoy TripoSR single-image) a +condicionar con **varias fotos reales** del objeto (frente/espalda/lados). + +## Distincion clave + +Dos cosas se llaman "multi-view 3D" — solo UNA acepta tus fotos reales: + +| Clase | Input | Que hace | Ejemplos | +|---|---|---|---| +| **A. Multi-view *conditioning*** | Tus N fotos reales | Reconstruye desde las fotos que das | **Hunyuan3D-2mv**, **TRELLIS multi-image**, **EscherNet**, GS-LRM/MeshLRM (posed) | +| **B. Single-image con NVS interno** | 1 foto | Alucina los lados que faltan, luego reconstruye. NO puedes meter fotos reales de atras/lados | InstantMesh, Unique3D, CRM, Wonder3D, Era3D, SV3D, Zero123++, LGM, GRM | + +**Hallazgo principal**: la mayoria de repos famosos "multi-view" (InstantMesh, CRM, Unique3D, LGM, GRM) son **Clase B** — el "multi-view" es andamiaje interno, no input del usuario. Para "pasar detalles de varios lados" necesitas **Clase A**. + +## Tabla comparativa + +| Modelo | Autor/Año | Clase | Fotos reales? | #vistas | Poses | Output | Licencia | VRAM | Repo | +|---|---|---|---|---|---|---|---|---|---| +| **Hunyuan3D-2mv** | Tencent 2025 | **A** ✅ | Si | 3 (front/left/back, config) | Fijas canonicas | Mesh | tencent-hunyuan-community (restrictiva) | ~6 GB shape / ~12 GB +tex | [GH](https://github.com/Tencent-Hunyuan/Hunyuan3D-2) · [HF](https://huggingface.co/tencent/Hunyuan3D-2mv) | +| **TRELLIS multi-image** | Microsoft 2024/25 | **A** ✅ | Si | N arbitrario | Libres/unposed | 3DGS+mesh+RF | MIT (codigo) | ~16-24 GB | [GH](https://github.com/microsoft/TRELLIS) | +| **EscherNet** | CVPR'24 oral | **A** ✅ | Si | Any (1..10) | 6-DoF relativas | NVS → NeuS mesh | ver repo | alta (A100) | [GH](https://github.com/kxhit/EscherNet) | +| **GS-LRM** | Adobe 2024 | A | Si (posed) | 2-4 | **Poses conocidas** | 3DGS | research, **sin weights** | A100 | [paper](https://arxiv.org/abs/2404.19702) | +| **MeshLRM/Long-LRM** | Adobe 2024 | A | Si (posed) | 4 / 32 | Conocidas | Mesh/3DGS | research, weights escasos | A100 | [Long-LRM](https://arxiv.org/pdf/2410.12781) | +| **MV-Adapter** | ICCV'25 | helper | n/a | — | — | Solo multi-view imgs (no mesh) | Apache-2.0 | ~14 GB | [GH](https://github.com/huanngzh/MV-Adapter) | +| InstantMesh | TencentARC 2024 | B | No | 6 interno | — | Mesh+NeRF | Apache-2.0 | ~12-16 GB | [GH](https://github.com/TencentARC/InstantMesh) | +| Unique3D | NeurIPS'24 | B | No | 4 interno | — | Mesh texturizado | MIT | ~10-12 GB (problemas en 8GB) | [GH](https://github.com/AiuniAI/Unique3D) | +| CRM | ECCV'24 | B | No | 6 interno | — | Mesh texturizado | MIT | ~9-16 GB | [GH](https://github.com/thu-ml/CRM) | +| Wonder3D/++ | — | B | No | 6 interno | — | Mesh via NeuS | MIT | ~12+ GB | [GH](https://github.com/xxlong0/Wonder3D) | +| SV3D | Stability 2024 | B (NVS) | No | 21 orbit | opcional | Video orbit → 3D | non-commercial | alta | [HF](https://huggingface.co/stabilityai/sv3d) | +| Zero123++ | SUDO-AI 2023/24 | B (NVS) | No | 6 fijas | fijas | Multi-view imgs | ver repo | ~12 GB | [GH](https://github.com/SUDO-AI-3D/zero123plus) | +| LGM | ECCV'24 | B | No | 4 interno | — | 3DGS → mesh | ver repo | ~10-16 GB | [project](https://me.kiui.moe/lgm/) | +| GRM | ECCV'24 | B | (posed) | 4 | conocidas | 3DGS, 0.1s | ver repo | A100 | [paper](https://arxiv.org/abs/2403.14621) | + +Baseline: **TripoSR** MIT, 1 img, ~6-8 GB, <0.5s (A100) / 5-10s (3060-class). + +## Recomendacion para image_to_3d_studio + +**Integracion primaria: Hunyuan3D-2mv.** + +1. **Hecho para input multi-lado** — el dict `{"front":..,"left":..,"back":..}` ES la UX. Sin NeuS, sin pose estimation, sin NVS interno. +2. **VRAM cabe** — shape ~6 GB (vs TRELLIS 16-24 GB que haria OOM en 3070 8GB/WSL2). Variante `Hunyuan3D-2mini` ~5 GB. +3. **Mesh directo** (trimesh), mismo shape que TripoSR → trivial en el dispatcher. +4. **Maduro**, ComfyUI + diffusers, weights HF, ejemplos claros. +5. **Calidad** SOTA multi-view open mayo 2026; mejora geometria atras/lados vs single-image. + +Watch-out: licencia `tencent-hunyuan-community` NO es OSI-permisiva (restricciones uso/escala). OK personal; revisar si comercial. + +**Secundaria "max flexibilidad": TRELLIS multi-image** detras de flag "high VRAM". MIT, N vistas unposed, 3DGS+mesh. Solo practico con CPU offload o GPU mayor. + +**Evitar como backend multi-view**: InstantMesh, Unique3D, CRM, LGM, GRM, SV3D, Zero123++ (son Clase B, no consumen fotos reales de lados). Unique3D/CRM siguen siendo buenos *single-image* alternativos a TripoSR (mejor textura, MIT). + +### Forma del dispatcher + +``` +backends = { + "triposr": single_image -> mesh # existente + "hunyuan3d_mv": multi_view -> mesh # NUEVO default multi-lado + "trellis_mv": multi_view(N) -> mesh+3DGS # opcional, flag high-VRAM +} +``` + +## Pipeline UI propuesto + +``` +Mode toggle: [ Single image ] [ Multi-side ] + +Multi-side: drop zones etiquetadas + [ FRONT* ] [ BACK ] [ LEFT ] [ RIGHT ] (+TOP) + * front obligatorio; resto opcional + [ Backend: Hunyuan3D-2mv v ] [ Generate ] + | POST {front, back?, left?, right?, top?} + v +Backend dispatcher: + 1. Validar: >=1 imagen, front presente + 2. Preprocess cada vista: bg removal + center + square pad (reusar paso TripoSR) + 3. Route: 1 img -> triposr ; >=2 labeled -> hunyuan3d_mv(image={front,left,back}) + 4. (opt) texture pass Hunyuan3D-Paint + 5. Export .glb -> path + thumbnail + v + Viewer 3D existente + download +``` + +Notas: +- **Reusar bg-removal/centering de TripoSR** por vista — Hunyuan3D-2mv espera inputs limpios, centrados, orientacion canonica. +- **Mapear labels UI -> claves canonicas** (`front`/`left`/`back`). Poses fijas → el etiquetado ES la pose, sin estimar camara. Por eso gana a EscherNet/TRELLIS (que necesitan poses o mas compute). +- Fallback front-only → TripoSR. +- Gate TRELLIS por `torch.cuda.mem_get_info`. + +## Fuentes + +Hunyuan3D-2/2mv: github.com/Tencent-Hunyuan/Hunyuan3D-2 · huggingface.co/tencent/Hunyuan3D-2mv · arxiv 2501.12202 +TRELLIS: github.com/microsoft/TRELLIS +EscherNet: github.com/kxhit/EscherNet · kxhit.github.io/EscherNet +InstantMesh: github.com/TencentARC/InstantMesh · arxiv 2404.07191 +Unique3D: github.com/AiuniAI/Unique3D +CRM: github.com/thu-ml/CRM · arxiv 2403.05034 +Wonder3D: github.com/xxlong0/Wonder3D +SV3D: huggingface.co/stabilityai/sv3d +Zero123++: github.com/SUDO-AI-3D/zero123plus +LGM: me.kiui.moe/lgm · arxiv 2402.05054 +GRM: arxiv 2403.14621 +GS-LRM: arxiv 2404.19702 +Long-LRM: arxiv 2410.12781 +MV-Adapter: github.com/huanngzh/MV-Adapter · arxiv 2412.03632 +TripoSR: github.com/VAST-AI-Research/TripoSR · arxiv 2403.02151 diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/analysis.md b/analysis.md new file mode 100644 index 0000000..0e48533 --- /dev/null +++ b/analysis.md @@ -0,0 +1,17 @@ +--- +name: spike_image_to_3d +lang: py +domain: datascience +description: "Benchmark single-image-to-3D: TripoSR, SF3D, Hunyuan3D-2, Trellis, InstantMesh, Wonder3D — latencia, VRAM, calidad mesh, licencias" +tags: [ml, 3d, image-to-3d, benchmark, mesh, gaussian-splatting] +uses_functions: [] +uses_types: [] +framework: "jupyterlab" +entry_point: "notebooks/main.ipynb" +dir_path: "projects/imagegen/analysis/spike_image_to_3d" +repo_url: "" +--- + +## Notas + +Benchmark single-image-to-3D: TripoSR, SF3D, Hunyuan3D-2, Trellis, InstantMesh, Wonder3D — latencia, VRAM, calidad mesh, licencias diff --git a/main.py b/main.py new file mode 100644 index 0000000..e264dfe --- /dev/null +++ b/main.py @@ -0,0 +1,6 @@ +def main(): + print("Hello from spike-image-to-3d!") + + +if __name__ == "__main__": + main() diff --git a/notebooks/.ipynb_checkpoints/01_panorama_image_to_3d-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/01_panorama_image_to_3d-checkpoint.ipynb new file mode 100644 index 0000000..507dce0 --- /dev/null +++ b/notebooks/.ipynb_checkpoints/01_panorama_image_to_3d-checkpoint.ipynb @@ -0,0 +1,230 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "aabd4af1", + "metadata": {}, + "source": [ + "# 01 — Panorama single-image-to-3D (2024-2026)\n", + "\n", + "**Objetivo:** mapear modelos open source serios para generar 3D (mesh / gaussians / NeRF) desde **una sola imagen**. Sirve de base para:\n", + "\n", + "1. Decidir cual integramos primero en el backend Python de `image_to_3d_studio`.\n", + "2. Documentar trade-offs (latencia, VRAM, calidad, licencia) que el bucle reactivo del registry pueda referenciar.\n", + "3. Generar contratos / wrappers comunes en `projects/imagegen/`.\n", + "\n", + "**Hardware target:** WSL2 Linux + CUDA (RTX local).\n", + "\n", + "**Vault de outputs:** `projects/imagegen/vaults/imagegen_models/` (mismo que diffusion 2D)." + ] + }, + { + "cell_type": "markdown", + "id": "5f7f4a7c", + "metadata": {}, + "source": [ + "## Taxonomia\n", + "\n", + "Los modelos varian en 3 ejes:\n", + "\n", + "| Eje | Opciones | Notas |\n", + "|---|---|---|\n", + "| **Representacion 3D** | mesh (GLB/OBJ), 3D gaussians (PLY), NeRF, SDF/voxel, multi-view RGB | Mesh = mas portable. Gaussians = render rapido pero pipeline raro. |\n", + "| **Pipeline** | feed-forward 1-pass, multi-view diffusion + reconstruction, optimization per-image | 1-pass = segundos. Multi-view = decenas de segundos. Optim = minutos. |\n", + "| **Texturizado** | albedo baked, PBR (albedo+normal+roughness), sin textura | Hunyuan3D-2 y Trellis = textura aparte. TripoSR = baked vertex color basico. |\n", + "\n", + "**Familias principales:**\n", + "\n", + "1. **LRM-likes** (feed-forward triplane→mesh): TripoSR, SF3D, OpenLRM, InstantMesh-recon. Rapidos.\n", + "2. **Multi-view diffusion + recon**: Zero123++, Wonder3D, SyncDreamer, InstantMesh. Mejor calidad geometrica con vistas multiples consistentes.\n", + "3. **Latent 3D structures** (Microsoft Trellis): structured latents (sparse voxels + features) → decoded a mesh/gaussian/NeRF.\n", + "4. **3D-native diffusion**: Hunyuan3D-2, Shap-E, Direct3D. Diffusion entrenado directamente en representacion 3D.\n", + "5. **3D Gaussian feed-forward**: LGM, GRM, GS-LRM. Bueno para gaussians, conversion a mesh pierde calidad." + ] + }, + { + "cell_type": "markdown", + "id": "6112267f", + "metadata": {}, + "source": [ + "## Tabla comparativa\n", + "\n", + "| Modelo | Autor / año | Repr. | Latencia GPU* | VRAM | Licencia | Repo | Output nativo |\n", + "|---|---|---|---|---|---|---|---|\n", + "| **TripoSR** | Stability+Tripo 2024-03 | mesh | ~0.5s | ~6 GB | MIT | github.com/VAST-AI-Research/TripoSR | OBJ (vertex color) |\n", + "| **SF3D (StableFast3D)** | Stability 2024-08 | mesh PBR | ~0.5s | ~7 GB | SAIL-1.0 (no comercial) | github.com/Stability-AI/stable-fast-3d | GLB (PBR baked) |\n", + "| **InstantMesh** | Tencent 2024-04 | mesh | ~10s | ~12 GB | Apache 2.0 | github.com/TencentARC/InstantMesh | OBJ + textura |\n", + "| **Wonder3D** | HKU 2024-01 | mesh + normals | ~3min (optim) | ~16 GB | AGPL-3.0 | github.com/xxlong0/Wonder3D | OBJ |\n", + "| **Trellis** | Microsoft 2024-12 | mesh / 3DGS / RF | ~30-60s | ~16 GB | MIT (modelo: research-only) | github.com/microsoft/TRELLIS | GLB / PLY |\n", + "| **Hunyuan3D-2** | Tencent 2025-01 | mesh + textura | ~25s mesh + ~20s tex | ~12 GB mesh / ~24 GB full | Tencent Community (uso libre <100M MAU) | github.com/Tencent/Hunyuan3D-2 | GLB con PBR |\n", + "\n", + "*Latencia aproximada en RTX 4090, batch=1, sin optimizaciones extra (FP16 por defecto).\n", + "\n", + "**Lectura rapida:**\n", + "\n", + "- **Velocidad** → TripoSR / SF3D (sub-segundo).\n", + "- **Calidad mesh** → Hunyuan3D-2 (mejor textura), Trellis (mejor geometria limpia).\n", + "- **Mas balance / variedad de outputs** → Trellis (mesh+gaussian+NeRF del mismo modelo).\n", + "- **Mas restrictivo legalmente** → SF3D (no comercial), Wonder3D (AGPL contagia).\n", + "- **Mas seguro para producto** → TripoSR (MIT), InstantMesh (Apache 2.0), Trellis (MIT codigo).\n", + "- **Mejor textura PBR** → Hunyuan3D-2, SF3D." + ] + }, + { + "cell_type": "markdown", + "id": "9d5dfabe", + "metadata": {}, + "source": [ + "## Decision de roadmap (propuesta)\n", + "\n", + "**Fase A — backend Python con TripoSR.** Razones:\n", + "\n", + "- MIT, sin friccion legal.\n", + "- Sub-segundo en GPU, perfecto para iterar UI C++.\n", + "- VRAM baja, libera GPU para diffusion 2D paralelo.\n", + "- Output OBJ trivial de convertir a GLB con `trimesh`.\n", + "\n", + "**Fase B — anadir Hunyuan3D-2 (calidad).** Razones:\n", + "\n", + "- SOTA open en textura.\n", + "- Licencia community OK para uso personal.\n", + "- Necesita VRAM, pero el RTX lo aguanta.\n", + "\n", + "**Fase C — anadir Trellis (variedad output).** Razones:\n", + "\n", + "- MIT codigo (modelo solo research, OK para nosotros).\n", + "- Mismo modelo da mesh + 3DGS + NeRF → util para experimentar con gaussians sin re-instalar nada.\n", + "- Pesado pero VRAM razonable.\n", + "\n", + "**Aplazado:**\n", + "\n", + "- **SF3D** — licencia no comercial nos bloquearia despues.\n", + "- **Wonder3D** — AGPL contagia el repo entero.\n", + "- **InstantMesh** — buen Apache pero queda eclipsado por Trellis y Hunyuan3D-2." + ] + }, + { + "cell_type": "markdown", + "id": "79b13fbf", + "metadata": {}, + "source": [ + "## Contrato compartido (propuesta tipo del registry)\n", + "\n", + "Espejo del `GenerationConfig_py_ml` de diffusion 2D:\n", + "\n", + "```python\n", + "@dataclass\n", + "class ImageTo3DConfig:\n", + " model_id: str # 'triposr' | 'hunyuan3d-2' | 'trellis'\n", + " image_path: str # o bytes\n", + " seed: int = 0\n", + " foreground_ratio: float = 0.85 # bbox crop antes de inferir\n", + " mc_resolution: int = 256 # marching cubes (TripoSR / Trellis)\n", + " texture: bool = True # Hunyuan3D-2: skip texture pass si False\n", + " output_format: str = 'glb' # 'glb' | 'obj' | 'ply'\n", + " output_path: str = '' # vault destino\n", + "```\n", + "\n", + "Cuando estabilice, se promueve a `python/types/ml/image_to_3d_config.py` + `.md` y se anade `tags: [image-to-3d, imagegen]`." + ] + }, + { + "cell_type": "markdown", + "id": "ac91228a", + "metadata": {}, + "source": [ + "## Integracion con app C++\n", + "\n", + "Arquitectura:\n", + "\n", + "```\n", + "image_to_3d_studio (C++/ImGui)\n", + " POST /generate (model_id, image bytes, config) →\n", + " backend FastAPI (uvicorn, 127.0.0.1:8600)\n", + " dispatcher(model_id)\n", + " → triposr_backend() / triposr / 3.10+\n", + " → hunyuan3d_backend() / hunyuan3d-2\n", + " → trellis_backend() / TRELLIS\n", + " ← bytes GLB (Content-Type: model/gltf-binary)\n", + " C++ guarda en local_files/cache/{hash}.glb\n", + " Viewer GLB (tinygltf + OpenGL) en panel ImGui via FBO\n", + "```\n", + "\n", + "Aislamiento: cada modelo en su `.venv` separado dentro de `backend/envs//` para evitar conflictos de torch/CUDA. El dispatcher arranca el subproceso correcto bajo demanda." + ] + }, + { + "cell_type": "markdown", + "id": "e9949f01", + "metadata": {}, + "source": [ + "## Verificacion entorno\n", + "\n", + "Comprobar que torch + CUDA funcionan antes de cargar modelos pesados." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c506c304", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "print(f'torch: {torch.__version__}')\n", + "print(f'cuda available: {torch.cuda.is_available()}')\n", + "if torch.cuda.is_available():\n", + " print(f'device: {torch.cuda.get_device_name(0)}')\n", + " print(f'vram total: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB')\n", + " print(f'cuda runtime: {torch.version.cuda}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "518eb741", + "metadata": {}, + "outputs": [], + "source": [ + "# Acceso al registry desde el kernel\n", + "fn_search('imagegen')[:5]\n" + ] + }, + { + "cell_type": "markdown", + "id": "bcbd7d5d", + "metadata": {}, + "source": [ + "## Pasos siguientes\n", + "\n", + "- **02_smoke_triposr.ipynb** — clonar TripoSR, generar 1 mesh, medir latencia/VRAM, dump GLB en vault.\n", + "- **03_smoke_hunyuan3d.ipynb** — repetir con Hunyuan3D-2.\n", + "- **04_smoke_trellis.ipynb** — repetir con Trellis (probar los 3 outputs).\n", + "- **05_benchmark.ipynb** — set fijo de 10 imagenes, cruzar metricas (latencia, VRAM peak, mesh stats: #vertices, manifoldness, area, watertight).\n", + "- Promover contrato `ImageTo3DConfig` a `python/types/ml/`.\n", + "- Refactor backend `image_to_3d_studio/backend/` con dispatcher final." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/.ipynb_checkpoints/02_smoke_triposr-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/02_smoke_triposr-checkpoint.ipynb new file mode 100644 index 0000000..78c1e75 --- /dev/null +++ b/notebooks/.ipynb_checkpoints/02_smoke_triposr-checkpoint.ipynb @@ -0,0 +1,304 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c9b49319", + "metadata": {}, + "source": [ + "# 02 — Smoke TripoSR\n", + "\n", + "**Objetivo:** validar pipeline single-image-to-3D end-to-end con el modelo mas barato (MIT, sub-segundo, ~6 GB VRAM). Antes de pelearnos con Hunyuan3D-2 y Trellis, confirmar:\n", + "\n", + "1. Repo upstream clona y compila sin drama.\n", + "2. Modelo se descarga (HF hub) y carga en GPU.\n", + "3. Inferencia genera mesh valido (watertight, manifold-ish).\n", + "4. Latencia + VRAM peak coinciden con lo prometido (~0.5s / ~6 GB).\n", + "5. Export GLB usable por el viewer C++.\n", + "\n", + "**Output:** GLB en `vaults/imagegen_models/image_to_3d/triposr/smoke_.glb`.\n", + "\n", + "## Plan\n", + "\n", + "- Seccion A: setup (clone repo + install deps + descarga checkpoint).\n", + "- Seccion B: imagen sample (de cualquier vault o descargada).\n", + "- Seccion C: inferencia + medicion (warm-up + 3 runs).\n", + "- Seccion D: mesh stats (vertices, faces, watertight, bounds).\n", + "- Seccion E: export GLB con trimesh + verificacion." + ] + }, + { + "cell_type": "markdown", + "id": "a943b390", + "metadata": {}, + "source": [ + "## A. Setup\n", + "\n", + "TripoSR vive en `github.com/VAST-AI-Research/TripoSR`. Clonamos a `sources/` (gitignored, fuera del repo del analysis). Deps extra: `rembg` (segmentacion background), `omegaconf`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e94d4d4", + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys, subprocess, pathlib\n", + "\n", + "REGISTRY_ROOT = pathlib.Path(os.environ['FN_REGISTRY_ROOT'])\n", + "SOURCES_DIR = REGISTRY_ROOT / 'sources' / 'TripoSR'\n", + "VAULT_DIR = pathlib.Path.home() / 'vaults' / 'imagegen_models' / 'image_to_3d' / 'triposr'\n", + "VAULT_DIR.mkdir(parents=True, exist_ok=True)\n", + "\n", + "if not SOURCES_DIR.exists():\n", + " SOURCES_DIR.parent.mkdir(parents=True, exist_ok=True)\n", + " subprocess.run(['git', 'clone', '--depth=1',\n", + " 'https://github.com/VAST-AI-Research/TripoSR.git',\n", + " str(SOURCES_DIR)], check=True)\n", + "\n", + "# Anadir al sys.path para importar el paquete tsr/\n", + "if str(SOURCES_DIR) not in sys.path:\n", + " sys.path.insert(0, str(SOURCES_DIR))\n", + "\n", + "print('SOURCES_DIR:', SOURCES_DIR)\n", + "print('VAULT_DIR: ', VAULT_DIR)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66dbea10", + "metadata": {}, + "outputs": [], + "source": [ + "# Deps extra del repo. Las instalamos en el .venv del analysis con uv.\n", + "# omegaconf, einops, rembg vienen en su requirements.txt. xatlas para UV unwrap (opcional).\n", + "import subprocess\n", + "subprocess.run(['uv', 'add', 'omegaconf', 'einops', 'rembg[gpu]', 'xatlas', 'onnxruntime-gpu'],\n", + " cwd=str(REGISTRY_ROOT / 'projects' / 'imagegen' / 'analysis' / 'spike_image_to_3d'),\n", + " check=True)\n", + "print('deps OK')\n" + ] + }, + { + "cell_type": "markdown", + "id": "776fe837", + "metadata": {}, + "source": [ + "## B. Imagen sample\n", + "\n", + "Usamos `examples/chair.png` del propio repo (incluido en el clone)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ab0f81e", + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "sample_path = SOURCES_DIR / 'examples' / 'chair.png'\n", + "assert sample_path.exists(), f'sample faltante: {sample_path}'\n", + "img = Image.open(sample_path).convert('RGB')\n", + "print('imagen:', img.size, img.mode)\n", + "img.thumbnail((256, 256))\n", + "img\n" + ] + }, + { + "cell_type": "markdown", + "id": "1aeb1dda", + "metadata": {}, + "source": [ + "## C. Inferencia + medicion\n", + "\n", + "TripoSR API minimo: `TSR.from_pretrained(repo, ...)` → `model(image)` → mesh. El repo guia con `run.py`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eda8e7d2", + "metadata": {}, + "outputs": [], + "source": [ + "import time, torch\n", + "from tsr.system import TSR\n", + "from tsr.utils import remove_background, resize_foreground\n", + "from rembg import new_session\n", + "\n", + "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n", + "print('device:', DEVICE)\n", + "\n", + "# Carga (la primera vez descarga ~1.2 GB desde HF)\n", + "t0 = time.perf_counter()\n", + "model = TSR.from_pretrained(\n", + " 'stabilityai/TripoSR',\n", + " config_name='config.yaml',\n", + " weight_name='model.ckpt',\n", + ")\n", + "model.renderer.set_chunk_size(8192)\n", + "model.to(DEVICE)\n", + "print(f'load: {time.perf_counter() - t0:.2f}s')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34911de7", + "metadata": {}, + "outputs": [], + "source": [ + "# Pre-procesado: quitar fondo (necesario para TripoSR — espera foreground sobre canvas vacio)\n", + "rembg_session = new_session()\n", + "raw = Image.open(sample_path)\n", + "fg = remove_background(raw, rembg_session)\n", + "fg = resize_foreground(fg, 0.85)\n", + "fg.thumbnail((384, 384))\n", + "fg\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f646c3c5", + "metadata": {}, + "outputs": [], + "source": [ + "# Warm-up (compilacion CUDA + cache) + 3 runs medidos\n", + "torch.cuda.reset_peak_memory_stats()\n", + "_ = model([fg], device=DEVICE)\n", + "torch.cuda.synchronize()\n", + "\n", + "runs = []\n", + "for i in range(3):\n", + " torch.cuda.reset_peak_memory_stats()\n", + " t0 = time.perf_counter()\n", + " scene_codes = model([fg], device=DEVICE)\n", + " torch.cuda.synchronize()\n", + " dt = time.perf_counter() - t0\n", + " peak = torch.cuda.max_memory_allocated() / 1e9\n", + " runs.append({'idx': i, 'inference_s': dt, 'vram_peak_gb': peak})\n", + "\n", + "import pandas as pd\n", + "pd.DataFrame(runs)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8150499f", + "metadata": {}, + "outputs": [], + "source": [ + "# Extraer mesh (marching cubes en la representacion triplane)\n", + "t0 = time.perf_counter()\n", + "meshes = model.extract_mesh(scene_codes, resolution=256)\n", + "dt_mesh = time.perf_counter() - t0\n", + "mesh = meshes[0]\n", + "print(f'extract_mesh: {dt_mesh:.2f}s')\n", + "print(f'vertices: {len(mesh.vertices):,}')\n", + "print(f'faces: {len(mesh.faces):,}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "339bc8f9", + "metadata": {}, + "source": [ + "## D. Mesh stats\n", + "\n", + "Pasamos por `trimesh` para validar manifoldness y exportar a GLB con normales." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "daffd271", + "metadata": {}, + "outputs": [], + "source": [ + "import trimesh, numpy as np\n", + "tm = trimesh.Trimesh(vertices=np.asarray(mesh.vertices),\n", + " faces=np.asarray(mesh.faces),\n", + " process=True)\n", + "stats = {\n", + " 'n_vertices': len(tm.vertices),\n", + " 'n_faces': len(tm.faces),\n", + " 'watertight': bool(tm.is_watertight),\n", + " 'volume': float(tm.volume) if tm.is_watertight else None,\n", + " 'area': float(tm.area),\n", + " 'bounds_min': tm.bounds[0].tolist(),\n", + " 'bounds_max': tm.bounds[1].tolist(),\n", + " 'euler': int(tm.euler_number),\n", + "}\n", + "stats\n" + ] + }, + { + "cell_type": "markdown", + "id": "9a21c430", + "metadata": {}, + "source": [ + "## E. Export GLB\n", + "\n", + "Convencion: `/triposr/smoke_.glb`. Verificamos que `trimesh.load` lo lee de vuelta sin warnings." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78614388", + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime\n", + "out_path = VAULT_DIR / f'smoke_{datetime.now():%Y%m%d_%H%M%S}.glb'\n", + "tm.export(out_path)\n", + "print('saved:', out_path, '-', out_path.stat().st_size, 'bytes')\n", + "\n", + "# Round-trip verification\n", + "roundtrip = trimesh.load(out_path, force='mesh')\n", + "print('roundtrip:', len(roundtrip.vertices), 'verts /', len(roundtrip.faces), 'faces')\n" + ] + }, + { + "cell_type": "markdown", + "id": "0b2f2d9f", + "metadata": {}, + "source": [ + "## Conclusion + handoff a backend\n", + "\n", + "Si las metricas confirman lo prometido (latencia <2s end-to-end, VRAM peak <8 GB, mesh manifold):\n", + "\n", + "1. Funcion del registry candidata: `triposr_infer_py_ml(image_bytes, seed, mc_resolution) -> bytes (GLB)`. Stub si no quieres atar deps al registry.\n", + "2. Backend dispatcher en `apps/image_to_3d_studio/backend/` puede importar directamente desde `sources/TripoSR` (no atado al registry).\n", + "3. Cliente C++ envia POST `/generate?model=triposr` con la imagen, recibe bytes GLB y los guarda en `local_files/cache/`.\n", + "\n", + "Si no cumple (lento / VRAM mayor / mesh roto): debug pre-procesado (rembg buena? foreground bien cropeado?), probar `chunk_size` mas grande, validar checkpoint." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/01_panorama_image_to_3d.ipynb b/notebooks/01_panorama_image_to_3d.ipynb new file mode 100644 index 0000000..507dce0 --- /dev/null +++ b/notebooks/01_panorama_image_to_3d.ipynb @@ -0,0 +1,230 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "aabd4af1", + "metadata": {}, + "source": [ + "# 01 — Panorama single-image-to-3D (2024-2026)\n", + "\n", + "**Objetivo:** mapear modelos open source serios para generar 3D (mesh / gaussians / NeRF) desde **una sola imagen**. Sirve de base para:\n", + "\n", + "1. Decidir cual integramos primero en el backend Python de `image_to_3d_studio`.\n", + "2. Documentar trade-offs (latencia, VRAM, calidad, licencia) que el bucle reactivo del registry pueda referenciar.\n", + "3. Generar contratos / wrappers comunes en `projects/imagegen/`.\n", + "\n", + "**Hardware target:** WSL2 Linux + CUDA (RTX local).\n", + "\n", + "**Vault de outputs:** `projects/imagegen/vaults/imagegen_models/` (mismo que diffusion 2D)." + ] + }, + { + "cell_type": "markdown", + "id": "5f7f4a7c", + "metadata": {}, + "source": [ + "## Taxonomia\n", + "\n", + "Los modelos varian en 3 ejes:\n", + "\n", + "| Eje | Opciones | Notas |\n", + "|---|---|---|\n", + "| **Representacion 3D** | mesh (GLB/OBJ), 3D gaussians (PLY), NeRF, SDF/voxel, multi-view RGB | Mesh = mas portable. Gaussians = render rapido pero pipeline raro. |\n", + "| **Pipeline** | feed-forward 1-pass, multi-view diffusion + reconstruction, optimization per-image | 1-pass = segundos. Multi-view = decenas de segundos. Optim = minutos. |\n", + "| **Texturizado** | albedo baked, PBR (albedo+normal+roughness), sin textura | Hunyuan3D-2 y Trellis = textura aparte. TripoSR = baked vertex color basico. |\n", + "\n", + "**Familias principales:**\n", + "\n", + "1. **LRM-likes** (feed-forward triplane→mesh): TripoSR, SF3D, OpenLRM, InstantMesh-recon. Rapidos.\n", + "2. **Multi-view diffusion + recon**: Zero123++, Wonder3D, SyncDreamer, InstantMesh. Mejor calidad geometrica con vistas multiples consistentes.\n", + "3. **Latent 3D structures** (Microsoft Trellis): structured latents (sparse voxels + features) → decoded a mesh/gaussian/NeRF.\n", + "4. **3D-native diffusion**: Hunyuan3D-2, Shap-E, Direct3D. Diffusion entrenado directamente en representacion 3D.\n", + "5. **3D Gaussian feed-forward**: LGM, GRM, GS-LRM. Bueno para gaussians, conversion a mesh pierde calidad." + ] + }, + { + "cell_type": "markdown", + "id": "6112267f", + "metadata": {}, + "source": [ + "## Tabla comparativa\n", + "\n", + "| Modelo | Autor / año | Repr. | Latencia GPU* | VRAM | Licencia | Repo | Output nativo |\n", + "|---|---|---|---|---|---|---|---|\n", + "| **TripoSR** | Stability+Tripo 2024-03 | mesh | ~0.5s | ~6 GB | MIT | github.com/VAST-AI-Research/TripoSR | OBJ (vertex color) |\n", + "| **SF3D (StableFast3D)** | Stability 2024-08 | mesh PBR | ~0.5s | ~7 GB | SAIL-1.0 (no comercial) | github.com/Stability-AI/stable-fast-3d | GLB (PBR baked) |\n", + "| **InstantMesh** | Tencent 2024-04 | mesh | ~10s | ~12 GB | Apache 2.0 | github.com/TencentARC/InstantMesh | OBJ + textura |\n", + "| **Wonder3D** | HKU 2024-01 | mesh + normals | ~3min (optim) | ~16 GB | AGPL-3.0 | github.com/xxlong0/Wonder3D | OBJ |\n", + "| **Trellis** | Microsoft 2024-12 | mesh / 3DGS / RF | ~30-60s | ~16 GB | MIT (modelo: research-only) | github.com/microsoft/TRELLIS | GLB / PLY |\n", + "| **Hunyuan3D-2** | Tencent 2025-01 | mesh + textura | ~25s mesh + ~20s tex | ~12 GB mesh / ~24 GB full | Tencent Community (uso libre <100M MAU) | github.com/Tencent/Hunyuan3D-2 | GLB con PBR |\n", + "\n", + "*Latencia aproximada en RTX 4090, batch=1, sin optimizaciones extra (FP16 por defecto).\n", + "\n", + "**Lectura rapida:**\n", + "\n", + "- **Velocidad** → TripoSR / SF3D (sub-segundo).\n", + "- **Calidad mesh** → Hunyuan3D-2 (mejor textura), Trellis (mejor geometria limpia).\n", + "- **Mas balance / variedad de outputs** → Trellis (mesh+gaussian+NeRF del mismo modelo).\n", + "- **Mas restrictivo legalmente** → SF3D (no comercial), Wonder3D (AGPL contagia).\n", + "- **Mas seguro para producto** → TripoSR (MIT), InstantMesh (Apache 2.0), Trellis (MIT codigo).\n", + "- **Mejor textura PBR** → Hunyuan3D-2, SF3D." + ] + }, + { + "cell_type": "markdown", + "id": "9d5dfabe", + "metadata": {}, + "source": [ + "## Decision de roadmap (propuesta)\n", + "\n", + "**Fase A — backend Python con TripoSR.** Razones:\n", + "\n", + "- MIT, sin friccion legal.\n", + "- Sub-segundo en GPU, perfecto para iterar UI C++.\n", + "- VRAM baja, libera GPU para diffusion 2D paralelo.\n", + "- Output OBJ trivial de convertir a GLB con `trimesh`.\n", + "\n", + "**Fase B — anadir Hunyuan3D-2 (calidad).** Razones:\n", + "\n", + "- SOTA open en textura.\n", + "- Licencia community OK para uso personal.\n", + "- Necesita VRAM, pero el RTX lo aguanta.\n", + "\n", + "**Fase C — anadir Trellis (variedad output).** Razones:\n", + "\n", + "- MIT codigo (modelo solo research, OK para nosotros).\n", + "- Mismo modelo da mesh + 3DGS + NeRF → util para experimentar con gaussians sin re-instalar nada.\n", + "- Pesado pero VRAM razonable.\n", + "\n", + "**Aplazado:**\n", + "\n", + "- **SF3D** — licencia no comercial nos bloquearia despues.\n", + "- **Wonder3D** — AGPL contagia el repo entero.\n", + "- **InstantMesh** — buen Apache pero queda eclipsado por Trellis y Hunyuan3D-2." + ] + }, + { + "cell_type": "markdown", + "id": "79b13fbf", + "metadata": {}, + "source": [ + "## Contrato compartido (propuesta tipo del registry)\n", + "\n", + "Espejo del `GenerationConfig_py_ml` de diffusion 2D:\n", + "\n", + "```python\n", + "@dataclass\n", + "class ImageTo3DConfig:\n", + " model_id: str # 'triposr' | 'hunyuan3d-2' | 'trellis'\n", + " image_path: str # o bytes\n", + " seed: int = 0\n", + " foreground_ratio: float = 0.85 # bbox crop antes de inferir\n", + " mc_resolution: int = 256 # marching cubes (TripoSR / Trellis)\n", + " texture: bool = True # Hunyuan3D-2: skip texture pass si False\n", + " output_format: str = 'glb' # 'glb' | 'obj' | 'ply'\n", + " output_path: str = '' # vault destino\n", + "```\n", + "\n", + "Cuando estabilice, se promueve a `python/types/ml/image_to_3d_config.py` + `.md` y se anade `tags: [image-to-3d, imagegen]`." + ] + }, + { + "cell_type": "markdown", + "id": "ac91228a", + "metadata": {}, + "source": [ + "## Integracion con app C++\n", + "\n", + "Arquitectura:\n", + "\n", + "```\n", + "image_to_3d_studio (C++/ImGui)\n", + " POST /generate (model_id, image bytes, config) →\n", + " backend FastAPI (uvicorn, 127.0.0.1:8600)\n", + " dispatcher(model_id)\n", + " → triposr_backend() / triposr / 3.10+\n", + " → hunyuan3d_backend() / hunyuan3d-2\n", + " → trellis_backend() / TRELLIS\n", + " ← bytes GLB (Content-Type: model/gltf-binary)\n", + " C++ guarda en local_files/cache/{hash}.glb\n", + " Viewer GLB (tinygltf + OpenGL) en panel ImGui via FBO\n", + "```\n", + "\n", + "Aislamiento: cada modelo en su `.venv` separado dentro de `backend/envs//` para evitar conflictos de torch/CUDA. El dispatcher arranca el subproceso correcto bajo demanda." + ] + }, + { + "cell_type": "markdown", + "id": "e9949f01", + "metadata": {}, + "source": [ + "## Verificacion entorno\n", + "\n", + "Comprobar que torch + CUDA funcionan antes de cargar modelos pesados." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c506c304", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "print(f'torch: {torch.__version__}')\n", + "print(f'cuda available: {torch.cuda.is_available()}')\n", + "if torch.cuda.is_available():\n", + " print(f'device: {torch.cuda.get_device_name(0)}')\n", + " print(f'vram total: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB')\n", + " print(f'cuda runtime: {torch.version.cuda}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "518eb741", + "metadata": {}, + "outputs": [], + "source": [ + "# Acceso al registry desde el kernel\n", + "fn_search('imagegen')[:5]\n" + ] + }, + { + "cell_type": "markdown", + "id": "bcbd7d5d", + "metadata": {}, + "source": [ + "## Pasos siguientes\n", + "\n", + "- **02_smoke_triposr.ipynb** — clonar TripoSR, generar 1 mesh, medir latencia/VRAM, dump GLB en vault.\n", + "- **03_smoke_hunyuan3d.ipynb** — repetir con Hunyuan3D-2.\n", + "- **04_smoke_trellis.ipynb** — repetir con Trellis (probar los 3 outputs).\n", + "- **05_benchmark.ipynb** — set fijo de 10 imagenes, cruzar metricas (latencia, VRAM peak, mesh stats: #vertices, manifoldness, area, watertight).\n", + "- Promover contrato `ImageTo3DConfig` a `python/types/ml/`.\n", + "- Refactor backend `image_to_3d_studio/backend/` con dispatcher final." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/02_smoke_triposr.ipynb b/notebooks/02_smoke_triposr.ipynb new file mode 100644 index 0000000..062309e --- /dev/null +++ b/notebooks/02_smoke_triposr.ipynb @@ -0,0 +1,423 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7c80f1ed", + "metadata": {}, + "source": [ + "# 02 — Smoke TripoSR\n", + "\n", + "Validar pipeline single-image-to-3D end-to-end con TripoSR (MIT, ~6 GB VRAM).\n", + "\n", + "Output: GLB en `vaults/imagegen_models/image_to_3d/triposr/`." + ] + }, + { + "cell_type": "markdown", + "id": "9b87f78b", + "metadata": {}, + "source": [ + "## A. Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0c2159df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SOURCES_DIR: /home/lucas/fn_registry/sources/TripoSR\n", + "VAULT_DIR: /home/lucas/vaults/imagegen_models/image_to_3d/triposr\n" + ] + } + ], + "source": [ + "import os, sys, subprocess, pathlib\n", + "\n", + "REGISTRY_ROOT = pathlib.Path(os.environ['FN_REGISTRY_ROOT'])\n", + "SOURCES_DIR = REGISTRY_ROOT / 'sources' / 'TripoSR'\n", + "VAULT_DIR = pathlib.Path.home() / 'vaults' / 'imagegen_models' / 'image_to_3d' / 'triposr'\n", + "VAULT_DIR.mkdir(parents=True, exist_ok=True)\n", + "\n", + "if not SOURCES_DIR.exists():\n", + " SOURCES_DIR.parent.mkdir(parents=True, exist_ok=True)\n", + " subprocess.run(['git', 'clone', '--depth=1',\n", + " 'https://github.com/VAST-AI-Research/TripoSR.git',\n", + " str(SOURCES_DIR)], check=True)\n", + "\n", + "if str(SOURCES_DIR) not in sys.path:\n", + " sys.path.insert(0, str(SOURCES_DIR))\n", + "\n", + "print('SOURCES_DIR:', SOURCES_DIR)\n", + "print('VAULT_DIR: ', VAULT_DIR)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d049648f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "deps OK (omegaconf, einops, rembg[cpu], xatlas, onnxruntime already in venv)\n" + ] + } + ], + "source": [ + "print('deps OK (omegaconf, einops, rembg[cpu], xatlas, onnxruntime already in venv)')" + ] + }, + { + "cell_type": "markdown", + "id": "df57ddfc", + "metadata": {}, + "source": [ + "## B. Imagen sample" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1d8ad619", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "imagen: (512, 512) RGB\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAB9v0lEQVR4Ae29Z6xl2ZXfd3O+98VKXdXVic1ucprDIMYZipkaSxQ0GlmCIHkEGLAkCIIhfzRkw5Zgyf5i2BBsBVsYARMAC5JHljTDySTF2GSzOWyy2WTH6sr55Xdz9O+3zq3q6uqihkGiqs6757537zn77HT2+a+111p77b0zmcWxaIFFCyxaYNECixZYtMCiBRYtsGiBRQssWmDRAosWWLTAogUWLbBogUULLFpg0QKLFli0wKIFFi2waIFFCyxaYNECixZYtMCiBRYtsGiBRQssWmDRAosWWLTAogUWLbBogUULLFpg0QKLFli0wKIFFi2waIFFCyxaYNECixZYtMCiBRYtsGiBRQvczS2QvZsr9x+jbuVKJTOdzmYznzybyWZznEw5nc1K+fwom+11u/8xyl3keXe2wMEigMcfPP6x975vc3uj2+3ORuN8LlcqlfOFwjCfKc0KDy6v7pZLz3znuWwhn8llssXi8eMPXL169emnn4ZQkvfHb9BMttvvTSeTu/Ol/oC1qtbrucwseQoeL5fLveunnphMhgMejafMZi9tbF25vjGbwh9SexwgAlhaqv23f/Mv779ytbO71R9Ptgbjdn+QnQ5BAF1CPpfN5gulQrFSreWLxUKhmC+V6o0GnUW3180XirlcPkdosVgpVYv5/Mvnzl2+fCWbg1ByfEsg+Ww+WyBludkk2rXr1//wm39I8MyeZn7MuODyBjnFDS+SHoleiY/d0yxDx0TcWVKxLP1TEteYN6kxyXRmRHqw+ERxETC/+Z53v/f4idWtzb3paDgdDqfjcY470wl/737nu0qzUaezM+r3M+PxOJuvtNb39zrDwaA3HO10OqPJZLs/OPX8i/tJvZMs0/V989Wk67Hu9DQf+uAH/sLHP5EZDM6feu76xla2Us0Uittbm9Nxb9jtjUYjgEyfEOAEUjnYO2iDL+ZzeTA3E7Y5gUm0bLYMxotFoE8MIhTyhSn/hUIpk4N+ioXcdDrZ73by2Ry0lU9AD4FQsWye2BCTiM4Tki9msuPJGPKZFWfFfHEwHE+mk2q+MJpNx8NRrVgqlYrQaIG0dE3TCbKa/HlmdQkbTycw8jx0kJ1xQtopBM3fZJyZjmu1eqaYmfYHQBz0k574k9FoMhzB6eXuPOR0UqjUi/c9OskVh73u5YuXTl+6POb5c9n7arXOq6c/s719pxZNQ5itekCOyaB7/er5Qqk1qa9tn79039Ly8tJytVK5cP5MpVQGdABBRAFyFYQpqA0mDKImEoTsGG1BZjjKZPpcxAHwFBGCPGDUJDUylCPUs3QQ9hDeNiD+s5NsTtKR3XNTtg+iOTe/LHCFqDI70oeayW4SLOQzBb7meSqjcZ/DKnOPHwiEEyoQX9YjO0OhgWSoeBKtAMXxJKAbiqKyZpjLNlca9z8xq9Rn49FWt3vx2kYmVygX8xDS9mxaeNMj5We+NRiPLSB1xwEigPF4tLdxtbP3aq7RWjl8pLW62mwtZ/K565X63mgAsMajTH8yKQpn0CLQhVgAbQz4pvD67DRLzyD0wT0EAd6A/yQ7hQHDfPmfBqbBGHcm3J9mCyTIZkb0CLlsNRIPc1kyLIPKbDYgKzGNA81glbKhB74ndCaiX5wCe3qLhNIS/p9QExWoEDefm0gDKC/AOYdyg0KPUF+kwrkcSIekqC45FagJdc+RuWIVXVa+0mi86Y+VW2szuoXp5OyFS9SkUqsSi8tSNrPUbEitKT0OEAFc3+62O93e3mZ76/rSkROPvu2dg04HEahcLI2noAtmrAiBaIH0IPi5RNAAl+BGxGs9AuGajUQlIVn6Bn6hkXEWISToZQKdcF+wgkFwBu7IZQaGZ9kBMJWsSDsbBtOnjAJikmFe56eBfnKYzgoUzyElcsfbQSMCPWLnYOdU2grZkYD87BgKCBFL2skX1Gzo0Ky7yi4iEOKRvRjdW3QUlHb4TT+99uhbR8MR0c698vLVre1yvVYsFHnCETQ7m+VLIa1RZBqPA0QAFy9d7D/xwJV2r9Nub7a77/3QR9cO3/edbz/TH40RSXqDHjxeoOYAiFxXEOfk0oRKCQmOQKYSToIFhR9i8g23JkyEBm14aqC37ELQE5JbwctFs4D1UDQhT2EK4U3zk1kxS5cCdEnOHyewbckAUglNXEID56grCCr0Ktqy8qjldgzSBBqGSnyhWKqgx9s5oBeMhv3xoNDvZ0fDyWRMAN0Xem+htXr8Le/Mlqul0mg6Hr300ovoPCRtawueNWpVtP6dwTakkzxw+r4PEAHA0TvD/WyhAHeEBr74md//xJ/8M8MB+ue4kMt1M4XMbARLB4vATYhCBqQBVZncVMl5zotDAgHZ4I00QSfZXEkGDMzVb1F6OfGP/zhBPeYOrJkroWokDtUAUlFWQmehvE4ydisQDsHgjfIViqAW4lI0yQBloVTm4LtQLCvGgH5Kp7hiMUxZxWK5UqoA6xIPMRoNet1OZ3dnb/N6Z2dj0N4Z9TrowSgHhx9+vLq0jNmnUCmffunMy6dPF8qVqxubl65cefzB+0vFQrNefe7VK6MR9UnncYAIYDAYn768+cDyaqfbrxfLp57/7uEjx2D6iL7AC6xgGcnORrDfTB6ZRyYfQn5uikUH3qqcIcox3QA1wVYoisl8IVcs5bD8EFAqYQnClporinhwXyoWgwoKpkAsgWEDZTIgCzAuquXuSibIXXQ1IarTrcjZJR4Rr5EJOjERYZpiC+VSEQIokn2Ju9quoFPz4kpjLeN95UqV+zwFWY76g+4eGtDlrUvntq5d6OxuDPa2q8XqkQffTNnq1bPZd77znf12J98fnr92rYwOwXPnM9DYq2fOpxP78VQHiAB43ldOX3nkZ49ipwRMiLYvfPdbJ46fHI1HvO1KoTAplibjAVgIkRwmnAX4gXpEc3GvdA24GSIQ2ACeQTSGC4ITEw5UySiQLlCVv0lgCMWBTboRBJkxmTqCZifDN0HQmZaaiaYZ3wchxI7MyAFpRqEE4YYci0VqlMHsORorq0E5aO3mn4dEqTlnk2IRxEN7mSI9CbRB/xEkVCzVGq3R8tpoMFB3GfRrq0ery6t0gJDi9a3N5198CWLe7/XHs+nJw4fQv+EN13Z2+4PhggBS0gKDwaA72gMH11H1ipX9vb3+0g6SNnI8wnOlXO6MepnpSECCr+DPSkGKP8hBytwZ7P2hfE6RSugkEA2IOh6DbLoNzOpZjZwgNu8QlhBFv07EJbm96KYwdQ00UU7DYG8IuimZjMCabJzywLLifW4CCTEmIBEU8iPJgHNYe4EeILqZPp2KIpK5Kx2VMS9RNqelbJGeDCHKou09QjOAqSMHQllLJx7AUjuZDIjxyksvbu/slMoVOgryXmk0qiVyL16+uoGqkJLXf6fHOFg9AHLvt5/f+8j7Htnc29sfDMuz6c7edh6JR6Ekz9jWuFgZ94M9h8obDBoZQcNJXgkFNHHBCOkU+04B4YGugVEkMQqvl1fTAYD/2RjAFmaQQT4/y6O7Qhaye6glD+qz/PKjzB+OSfYJmGmymbEDa0EAdhqapfIlhsjMujSdjvNjuyAKNgNSorxgQcJuJIEqWTFiBjVThTHxx6PJuKidVeHIQTQraO+HgX+WL1SW147B/q3FaPTyyy9LVHSD43EZQsNqS89SLG6mdwgsIYeDRQA8887udqVaP3po/ezFK1udUaHYO9KqTkFKsQAui6UyGqP8GLYephyYK50AEHIwjAPgaZyZFrB8YiTMTJB01JcZXIquJD+jg4Cx0wOgO08RnhgjgCrAqGyfOGAf05InGGIctbU4wDrFQI95Uq03OLamI8A6CcY9LYyQbYDwBLIrwLbHhekYhKIeOwpgd0WHQV+TKRdzGHoA8mA0yo5GEBqkBAXY4fBEGJUYKBhPKkur5WpjMma4ebKxvXn5ytVWo9XtDyCCtaWlyZhRD6yopStXr/rU6T0OHAHgBvcr/+L//egH3n380Pqp4XivNzjaKk9Hg0ylhKVSHlksYzKH14eSqh0T9CDEIEqLXC6VdoIFZychkSN/0IxCWiav/jzJ4nJApzGjF4AwUCpk0t7VhKq2C+zg4Ij+DDZh9slM6FXG/Ekzmn3sAFBC+cCIJ/nipAj7H8P+p4XxFFrV1WEWwhUR0ashAMbJUFNMVCgOxyVUGw/pkMIZveZgLJAxjul0MJo0jxyy00GXyEzPnT83HI7Wl5Y73W61WqnVa/RpR5eXt7/9XLrlH5rlwBEAzwwCXr5w9S/9mT9V/Naz25vXq4A5M4Jfar2xScqjcQ+IAllgleiqielTKUNyUIHlEOKCm7jxD6/lBKogjrIScbmVE62yZjQJD+hB8QdjPLK1aMQ3R/cciIFvGDXCF31KSECqwkhF0zzqAVQjwdBLISYxQsX4FxVB3kJ+ivgF9XTLLeLRMOGBhhiuIBJMVYpbUD7GUAyi/UGf2tSaS+PhECV6NBq+eupVlYdqpVwqHaoeatUbK+trG/3tL168EFVO81e8yTQ/4J2fDcSsLi//heP3zY6uDLvb7cFgb5QrV2uIJKCjN0RGgCXLqQEP8DGXGArQcyH8C4pgU6GDPqOArgmfRhjR5oI44ol8mLsQUZiDGO0NOdwvswPC0gDoVwqfaBfCDARTD7UA5BKfjgBbE2RJMRieEi0DVRgXbi2wDGgQy46FpwHp1mz+5ZiD5id6E3sKRK3hqNPvD9Gxx+P+qM8gwdvf8Z48JtRp5vLlS//i3/ybZnNpdXWNAa+l1fXeYPDCyy9++9nnoI07N1+KQg9iD8DrA9Sod7+yvf0z+Tc/cXSpmJ12h4MhnFiZJre8tASSlEhg0uPxwHAZtYwUtg/rx4oIKw9eLmWIQBAr/MF5sG/IIVi0vUVgX6DSCRiK2E4a87GfITCsQPY1DjcjJxXoSCLHTGGAyQatFm2AIFNDXQ57SVpGAuaRP0RixhbPl7KTntnFEoPB1RJjApXV9XXEG4bPGPGA9hTWeL5Z5qVTL+9ubqBNdyvloyfuP3vp0leefHJ/fz9FIP/3PcoBJYCkSXqZzOnre48dWylXiquzzPXuaJwpKLIjGyB5wznh1PJW7SwgDVjqqSMORdoc94E5mL0DYQgScQTDpk8wDt8kInmoyyaUJcP1pQfV5ygETh1OF3QPWoSUqfBmxo4ahOO3WYFu/OfI1kIT8EMAUU70NFSPoQl0+RIjFaVKscxgF6iv4ttJzSQbuoUp6nSJjodSev3emTNniNHvdq4PBtc2N7/6zWf+fXhJ3b0DTQC8zQvXrmenDyC6rFWL4+HgwgBjD4rkGLebxx57EyyfbgBOPej1UCrHw3F3QH+A3Ix1BdwCVr3vUQfoKwYZBAaDiR/HHLScGwqzB8BQFyMF9iO4kAprzpCyADGoJ6Ijt8YhpohHjWCctobmzDAFhlpkKtRibiGGhTZAdwDFYa+E4SMUafhX/4B0EH7oSBgfwwybYbAOia7RrG1t7/S7/eWlNRWTTG5zc2N7axt6QFCqVqsXNrct/yAdB50AsHtW1w7Prp0bTGfMb8n2UGFzCD86GBRyKytrzBpBbMCAguwAiMEZJIE4Dg0APFRK8IdaqR6rv3O23enA8XvdHp3EaDgc42uEwAHBAGV0XEyQTMtC0BkxDRN2nkEMYcgAZRR+DoWgY5AtNKC9HwcNBnQRZnDWq5Rq+Xy9XCJyqV6F9kqVCsIMMg0mfbTfZrNFF4MbM5aeWrOJ+F6vN5HYVKgBNDOeK+V2u8Pw8ZJWTgaTqdD08qVLKAaWMsuUq+XGSjNz+iDB/2BagW59w91e/xvPvfie40uzwbBagMVOO47qTof9fntzW3fIQqlaa2YHQ/TRbrtdyWf7w3G2DGPF3jJrVauTfL7WYHKtEgkfoIY4pJiv5JNDnKk36r1Op1qvQQblcnVnZ7vVauqZPB43Ws1Op9NsNne3t+qNZqVa6ff7AHRjc3N9bY3zcqUOTCezcb1a6/W6zVaz3+vWGrVBbwDXhwK63U6t3ujs7dWarf293dby8v72drlazff6UMig0y1IJxW6A2YAX7u2ceXK9ZP3PaDQlUXQG168eIma85fYnl586dVbG+cgnB/0HgCsKxzDdce4GRSb5WknBo8QaUK2mR09evS+Bx7G8AI3RYpg6Apej0EdDooohASDaqxhkZujCYafQbcHoOgxlPsrxV6vx/x5EuCOCdvud3u1en13a3t5dQUfG0R95J5+p1ur1fo9hqBngx6gr1AQfQjZDkfOacSAWSpWen2c9rcbzdbmxm6j3uh2+khDw8Gk3kD3qBXLtVojW6o0Vw+TogF29RWlGytDrDno+fq1y7u726UwVDm0ncnstfehNHqqIN7cXg9j2OAggP7WZzzoBEBbvLrTffOxVlk1N9+qFq52HD1Fdtjt9FY0mveRT5CUMGpGMLIM8oLKMEK6o6whrfuDgISMjihPVlghtcZkwljpidK8KUmR1+CJwMMcGaawaPWPXKAhzfz69EMAUCMBFAEjJz4mS2IpFYX0j5lT/ZlpxEr50e2EQKURCyU73jD1Up+ZjOlJEMwQjbq9XoV5j6GnoCdc23B1DOKjTqC+X7y6Cd1G0gP0tSCAzPnz56ePHMZBACg0sJ7AvwHAdDJAWEdXnU3woKvPWqANno6XA4G6HhBHNIJ7oMevsjYBykH8OVnLBN5EmZAyTBZkAz4jNj8ZZgCHbROkcl8NGngKXbRSIkF4JKFmjnVFhnxDSErwlKcoEx54YU2CeoI6ky81bCrLUyAabW5cH/T2u/vdQyeP0rcp/k+nGxvXYziZwQBG/4qt1ZXMuQsHCPvxqAsCwL+zkK9Xs+09zCLVfI41T0A+OBsiowyG21sb64eOwkenev9rs48PwosAY4QXqDLvNigCQgBX2mOUqXN6RNgvwMn5AsfYe4SxCfkPKvCXe375p3kT9UAHtnLZFxQyUpCcMc0ELRkPJK84otvhHBoR/BDcHP0Uqwg3YNZne3dnB82b5R7QySGi8ZjJmAzBjbaRf8gN2ssyUWz8wounkkwP1PeCAEBVflBqFLJ76rW5TK2U3x6wRIrOMwglYFZ9YDxl6SwigFVECKUICQDXOMAJmmKiMIm15OgHjQEfvpogHu+boI+sM9JJTw7AMNAMMeg9kdORLvDLEAFmqEm20vA6CQwZya6EhISA/rgTlGQXYycTfkigX5mJ+AzbITaNWO+Hde46aM/40e3u7TAGJj2iwOQy+EXs7e6SiTbXWZbxZmQkMz5gh33pAT+G/d4LL7zErC7Blck0WHUHUMF6x5P9/TZ+NawThelTNVf8BTBl1x6gHUbLLWgEVSEZFiCxB5omXybTEIqzJ4QEwUhMBN68hwHUGbpce+CEgTqbUJcQl16kNHIyxyg9yT8ClZoiTvIOg0CoEtXFBDvoDwZ9au9gxmS0v7/XWlpmMMPCp5P2/n6331deoweYTR995OE6i0YevGPRA4jWEdDGS348hBdWihCAErmqKOjEOX44ALygFngopkMf2kB1m8BtXthKMBzK+a4FgeoLpnBZgzdLL0TIMoMLl88Zy2fB4bGOwrVNot4cgo0umwymlSp1BnNJJZtXoqHPMXuIAFIjXB8IUnETXOeyrOUQspXyk/QhKTlSB7lBajj6MyAA4fE8e9v7h9ePQBc8FKl3d7YZ7kAr4alYFunpZ7+zfyAXRV0QgEzvvs3d8onVLoJ9LlNhNCCX7Qn3GWxyNEYJHiAxy41B2FzM5lQDPUwe2yUXMFnHXmczfDXhsMwyDGkpPEMtQVkFKE9HaNUilaCE6+O1AKS5D2yx/Dj+FRFuEJU8X8TL/zW5RrhMm0Sq16FtWwLJiCOz14mJuTD6Q9MzMeMxn0OP7/VZ6AFZfwjlQki7u7tU1xEwvouF9n47CCNyOkhfCwLwbX9+a+vw7MHizEWjSoynlvIdKWCGlzw4mrCUyJDOAfwkIJfri3u5s99cKyOpoToHANPjhMFbjZTA3WTw5eDhFAURMNKWYf4Lg8C6gE6cegWOicNQrEuzgGNUCZEe2nE4pKIk0PEU7IlY5kRBqqRDEvFYRQVSnJUnU2QdrTvKZGbiAagnKL4ZxH08HfR40wdbaWxnb8cc+dAzzWY7e/sHCfavPeuCAGyLNo5uldKsPVBsz6MH57a6QIN5Wh5w/W6/uw6+RTF81lvAiC8FFdeVGBKTaEW0yaLSOvPHNOfYZ/ghCBSagGM6G8bUFCwzXI2LOlkgAJWqdQyigNauxwIiLWfKQV4Da6AN9PHit8RCsVmtzPslaFWLrUUZScXE3gD2zz+E1G3voc2rfTBNLJMZjPrtfdYt5dR/Um1ubVriwTsWSrDvHKxcbneYwgsWaJEq8nggF/aPHgwXBXDEgRdDAqGa8u3cQsyWQJtB3MuXLuDjIIMWiKIvwBiAYnZhQDcA7EQwDrqUTpelenBNa7NqFQNbTEgHiPJntAzBnBCCOSUMHV7OkHJngF2nA0dvd9r0OIgw1tXDLosJjowL6G1H7DjownCGoLYNloRwqi8d0HTY7aIh+yQ+Z6ZUY5TvgCLhgD72bZwOkfnS5R28fcAdmMCFICCltDIYuhIDejCIklSC+QN6DsgEEcTBsczs2rVrg+4ABQDfOAJjaFf7DbiEgwProApzRQcgApgG/WfPvnL96iXsj+Vmi3KJLZZh4H5JKREQ+OcrQD0Y9vf2treuXWnv75APEbjDj5Ei4pB4hDjT0i6HXquzv3/50sWhtiwNUtzaabfR66Nvckh7Z581UZNO57aGSf/lggDm7xjbDwfYAYI153cJVgYCcM7Z29xRwkF3jAEvool7Rk9ZvhNBP59fP3zk0cfecujo4eZSi2mFaLLSgPK+7FygqQ+EwMF6tBqc8tVKFas8SvaVKxdd/xwTpOX7OoigcK4SMAc1w9L8SQJINaNRr7139dK5i6dPYeDH845UFADYKU7rk+fO6IfTc45+Uamw/m2TlYzAP/MwoaN2ex9SgEChHypz/foGvUX6wX6nJ1zoAPNWqa4cZpnBWaYLZHE/YFXkgXx02usNXJXfSeXDulw6vBJCwmE8Scw6SSt/8sGHIA8WLMT/DM6NzKNTqQxcIJOObNWhoTFAiSt/sXjyoTch9LOC29LKOvAW9nQpcnQpxoPkN36lhsTCCi3h3DYcVGs1MoT8wHn0HspKTiowKlWI7gDET8eb27tXrly6b/04EhPh1AXXILO3BOQ4tskpJQUdwO8FAcxf+tPfeu6xn31rXUxMkYjLhdweXH/CEmyTnd29peUWzgTgClJg9XBAFCw6uPacBsA/XgZOC0AKIib5IIoE43eAFiJwyPUGn8eZGfQ+8fZ3VZmNVmJ+FrqpclEeGSXUgKAczkghTKklhDYrlGpNqCjzpre87ZFHH19ZXUfSTyQmmDmHshNJQgdQ4GEEIJfHTfTQOiu95ZjWSRQsW+1+D5rhjyRMFVtimfiDeiwIYP7mcfscMMuEFZhZaKqQq2Kd7w4RW7CEwmW1hWIMBYfY3XUmEzyYbIL1ijxygQEzrgRvHgx7yDTKLMrnrCYnU4a1izntPLpe5rB+KviwJAXDvyN2hiGHAK/fWv0jQEEooTJu033gajfJFRrNEycfLFdq4Ft6gcsj0ATLd74jdOelofxBVxvXrjIpmKXTx1M8WzEEDUe9IbWhFEbj+v3Bsy++Mm+Fg/ez0AHm7xw4Lh8+IpQ1hGZxieMG6EPo7vd6iPV4xgFLI2j4Ec3GAHZKHuIuUMj0GNakmgx7LKwSmi94U5SSN8OYOQHHpGOclsVrQa2WSeeKaWliAI1sKJS/AHQUR8IIUdJyUbfpyqEjeEfD3k0VB3VA4grsa+Sx5yIfKHAyZZINlYV6qQ4aBLUc4B1BbybFhsKQxdsj/as/0IZ3PBYEMG8WBJlhhuUwkVMQ4GeIQDQN0gYwY1bk/i6bzE2YAoNRhT+wqDSvaV+hmwNcgl52nuTDgK6edDHminuDeivYxEYZpnpSTocD1naWQAKRgp5OQM7t0BW4xHRPHRSb7EQkCcsMY1RraYUZ97oPSVGwf9dWceKZFENiQtzVwtFgaMHuaryxtUHXJMGwLhZEQKfGaACpyWE6bbXq+MPeERwHIXBBAPO3zI4BX3nqKYQTr2eQghDnFKAxLwuhqNtt41WjTmsE5Z+IGGJO4B9EwmBhuoAP7wLsldpsZO4a5Dn1T5RDKEjerPXJr52KxAP5IM0r/yeX4pikXCDc+8d47XCI4YgVPM3E/oWipB14P4YmDtVtPfCiN4psCIZICcDDIsQlSmSGAPt9qZXoPZTLXt/uUJQPdSCPg0v6b3zdZcZinWPFjjGI+jB5AKKlEK7Oev8ycceaFMX5x4sNG5EhN44giCAPGDejwmBuOGTfVPAnPlUfWCi3MB0Myo0m2eCGpqRCPxPzwqABysKLmvylC6CtlQdCjOkv0V3UWy24PIkgTSjT1Hq2YfGUjkC3AJcQpF1yoNqIYyxmoVYB6O1Vpj2mYtq5BBkX8levX6dDuPEQB+53QQCvvXKHwRTUwZA7kQI9kcK46XB4/dr1Vr0FCxc2QBaLDeRBJyErVlBRWw0WnMBXFQFcs5QnrjgovnB9Qcf+GyPmdjH7nnBuyIVFKhqyyE2qQnwxjsMok8kkBqYZ6LDKXGGzkjCopkSSpOHCehMeg1yQJYn9k2LH/R6TIVWFzVHnDOeIER8SoUb0dyy6/loTHLyzBQG89s5P3v9IsToe9DuYOUFeMZ9TpIF1jiesGIsFpjPo1xU/UGX5cAsGrBRhRwGXt2/wkB6CLmT5KLf4PYD/IUt1VrKjMVsSkRRFwFQiF/hOsJYGrdFZQBCs/IxeLGzJ0jn7GmxmpWqVb2gBDYFEZiAFRFcRNCkdGMIR92ezRqO+cf0Km8lIEfYQku2IDS+kRmhG02q5dBCnAdx86wsd4GZTZH77qac2XdVHd0vapQzwVHmxBE07uBPs7WCoAUfJODCQ5I+ZjwF7M1FWEfxMsVK+CPTKYIE7667ttXexJtGDsGIhHqGST+jEnGK7ZPGtJIhTBJLeCL8KZ3NhUxXT0ykmIwz5nDFgGzQD8WnmAe8SB8w/MhD9Ckf2ZdRl0N2/evkSg9OSSghLxEcF9jZ5zVzekX25rf1BPRY9wGtvHiezor7DfoAPFn8YJiZRpZVZtl6rxbTaIWKD0HPdfwUJASnsJBWRHdJPkkti9ARqG9cuMTmLSI2m7N99KHMK5KRWoJlnISaFNL2FC6Lgg+2WvrVqFWGqXNVVLsBt7ZIyoTeV2RuX3A/tIWLZl9BplNcOre5s7Knm2uXQe9AV8ThWlPjMBKi2Wq81wcE7k8EtjqQFcKspNdmEK8OkdpwjVT/tAnBrxgAz6LQ78lcYvxZJl6idhKlUHIFMICWoQKdEEdg2NXfa+3vnzp+/dPHKeMikGW7n2FSDzkLyiFQYhjCwIixhL0JbIJC/cZ/57EzS6kB+rG7L/ALzcpOmEN7FuuiXYCjO/oDDHLmMMTAiZ0fd/qmXToF47mFn5YNmwEgw1bOMbIZlUV45dXBHwXhDCwJIwO83wvqrO5vgBrxAArj1yMhdylNrI7jpdJhP4qpBRBZfTiBT1wWcAXwHCSQaWXJsWldgzyI2bKwtLa8jardWVhpLLZzg8JogdeA2mVKjGQcKUEzHXsqsRdbemoz3drY3N64yBs3qbgCcviXJHKUV+IfF1KFcy2P0OspVPlNP8AIP51KldPz4cSe8hzOf6TCbOkPAh6D+KBhcGvugHgsCeO3NI3Scu9iBtcNXGRCrFNlyQnzBOPEXwH0N2SKxzctrZaiI1Z7xD6K4FomiLOkGFJ/g9Kzl9tCDD7/rfR+478T9rNcJMI2DLqEUomJKBkyjjF+YupjW1jkcttu7Z06/zIgaOwJAMIQLX3i58A2Mk968tGk6OZg4ylCKVRSAyajd7Z8+c8bRBEbHwj6KrxIaeTyVqVTZJcWDeyx0gNe9+9giBpiJKSZGCg25OUvZjrY2N5fYU5rxXVVkpH3de5T4E8wTkjBV8wtbEKII/UEsvXjsxIlqowlLZn4xZh1jKu6EyK+0pGQC2URP4t4AJdYEajaXV1e12nAdqriijpJLUqDlWU91cXf5Iz34D7JAYbHa1j2bO3ToCJsY9ycdikD7ZicOjvn9bKZaLEs4B/hYEMDrXn6tzNa/BfaXw7Ge2fHIQImcjeSztLIsv9d5QeYKimXaYhMAyfLBsVCSdlwfAoGGE/KADFwulwsCGbRqd3Q/tvvgSloQtgFJ+hDyQ8EoVmrlWuWhev29R4+z8i7EQk9iaQF3kkSJCmCkR4KxpIQawvbvUDQsn+L6g43rG0cPHaPa0AuV7Ok+N9dVKK5x6BDdC7spva4VDtLFggBe97ZPPvw4i0D3+11gDvtGWUU7RchnHGr7+gazChExQK5wDQYMEEVlIBgiCGjKp+0ZMOQznBC9CEJ/DHwpcILVXqddqLBHqyJTCFHQhuO9pCc6e7ogmrO5y5FjS+yHBMdHgpd+PChYdSAknTAhAeroGCw7YkCWVI9vN/0u5NfW1uk2FNYkMmc18Gic849+8p3nvoOe/bomOGAXvpLFcbMF/u2/+8LW7j7sGoYKb8AQJOScRQ7nnGmd1JHG0QCEd+4Zj9vSgfEgCuEY+COAXkFJh1BYMsmYC89IAov54I/Q7cKIkcjxlkPf5dw45JlHRGJluWmt0YQmwCuUg58QCznQY1AYpKWIH7UKg0+gnhI0cybkZJ2IS2eyt7vD4nD2WdyPilIB1Y6ocaKLk97sDuqx6AFe9+bhzWBnlHFWACowS6SwVhtyjrvmzWbMLZQDc8iGJQykF+ggkdGDCJS/xaWLVrE/pFhFqBG7ykgm4Rr+znrl49kQa2vCzfOkoMfhBgLYaNRoLaMP6HlBqiQhO6iGvUkCkP+rGVA4slZiN6UmSVdEGY7QhSSGeGOJatgO2RGOLQtKsFsiGt9W6kAfix7gda8fPbVSqyXAQPLBDgTSbCOcontdlllOHGlMA3SAIF+RQcB0jibYbRAJztGwf6yq4hU9F8UXIIYMzgYwUAd0YRC9RH/IHjPOvAG6OIq6QgTWehLHn9kh64dXBbQHpr3Fr5xchPPvaZRj0agf2QySFBtzMM+HAWy6h6gccwU0Ac2Nr0wvYC3sg30c9Oe/7e3jEHrs4ceQVEAX2MYpmgjAC0EEyLPfHIHAC/yB+4SDSgdEkmjii7u4kxIJaSeicQfQAnRGEFQtHEUOUmBlRQQSZxCwYkMPezwkR2dSabSCMChEEgH3ZEb/owwUh6k1ZUoIEiKdhf8YUOl1PItuCdUF5wnWKSpRAoSXUCcCXNz1uUv5/KEq65Ae6GNBAK97/SwY+Dtf/HKZ2fFinC26QocFZxNnx7PBBGqAtzDIIH74owA0pwBlEkV6BtSQ9hM2jICEzMG5TDsORHhkFagCbs+AMiTQ2d+jc0HWB9BsxwSGJRHRDzHx8Y/kkhj+nBKMs20YMCMjJC0IITF/kj2v07SWR8czZucl8oRqCJYOmTsTq6H4zEh05eoD9z34uuc/eBcLHeB17xzk9Dud6aE6QEYEiXVygYoQRpJm+2t2foEdB6sH7i6tDPrhuv5m2UmMNfgHcHsukWNEr9K/NMI4FFIKkUeJYYgQ5mERNphevXwRjFabzWqtwXwXXfy1h6Jd3HAYIp2OD+Tn+AHkRZ9RmZahT5i+ZED2li+FgHcohPGKWrXBcoi1CnspdaFMkkMrfUayfSAHsLfb+1/67suve/6Dd7HoAW5/58Uc6zWE5MOWAK73r5wBdsFoaL7CmKCAlJAT1HxyrA/HSm8b3c7+cOSia0QQx3J9Bn1l5iz/aWhkGCnYP4mlcMFslt2KIBrGjEOuEakUSUrzUNqHUJS7ZOHjYa/PynBb27vbkCtKcCjHMSYAjSoE6akEaZB0v9vDjATFWkXUEDoFN0GKzoQlrBkWiPVRbm+Cg3S96AFuf9tL68tsMs3WYJhlhFKYzEEhdsgui0WvMRIc3FYqgZm7vQrxYPWvvPzCoNdZWl6rNZaKbKkaSmlifo8uQZoBh+G9I7vOsjJKJrO8dvihbP6Bhx46fvKh0LchM+SVoBLzgGRURzyVhdunsJ8xK1v1N67V6rXSoaPIP5AWJIJtX6mMuAwmsOo68dhyr1xq7+wiyTm+rcJB9iov5KzhKM68OqjHggBuf/MvXdx4uHEfiAHf7E2Nc0RfNwPAw4JAgFbUgkgOhXX+OUID9TeW72dXdsZ+SULjwvgJTXAM3sAcUAZ2jDcTn3HiSrW2trqeR/LR79oBr2RYNyAv+iUFu4QgAYggxJzRYHT98hVyeO/h+6iTMj8sH38fC1YtsIfJMx+SnfGGDuaFXsESvvRjpEqeYGovcdApYEEAQvnW4+zZc6OHDjEEhjcEOyXpwwAYZzinqdeyyj5qqPwWcNNFQAbcRhQpFB565LH23k6t0YL7IoEQJZE8AL0nij8qqeQV/Ypn6AnmQ3ZKJsr4ik4QEnYekcn6u/Yb1sDbfsgJ784KOwHn8xtXr5IJk48n6NKhj0QsYpJs2mnvQ4i4/O9TENyf/Tmcd5/0Lu5OuVytYwhldJhUB/ZYEMDtrx5ggUCQCDeGsytMj8K5YDxmWlgyYAXs5uahRNbnezZrLa02W8sgFTWUQeNpEY0UgURX5yjDbychCvMcMwzg/XJuIhBLXVbJhI4GxUC9GR0A0uEwOb2RqxUBXtatYMvr1nR6gn097n+gXG8o9VBVfYjcU74fwwPZPM4Whd6gX2DZ9iAs6AzblJE5KGk6rdcbPKyXB/iAJS2O17dANjeqlpCogQme+06LAe7aN8cIRIgYbLsLiLTDg1vs+vxw7bdOcshEaKDYgEClmAywQR+sy0NHgS5LYXoJOW7r/gNIVthslM2VTxz8Yj8OCEe/CDoRhBkysgDow4XhGCar1OrNpeXH3/bOBx55TNme2GrbZDz/QshhNQm2RnVImGz5ivwoly4AaiEeVHr/mx4t16qvf/gDd7XoAW5/5eCsVmBt3I5oQhBiYqRw1wzElu7D3oBdVWWpsl0lIYHnr3w2YdegFugrdSPPx1qI2G7oDTQ9gmwEItbEjYUhOAHclAjGMa5CPuAcRzY2EfPc/MiY3TaQtvLUAXJCdcCQCZHVm83JBBOPllZJK+hQEpNm7E6azYZOq1mXzTK3cD2S/iJX5un8/u/+7vbWVgQc3K8FAdz+7kXUdFINwLEzO3AXMRrgcQl192wkaQIEGZgKFSCykF7k6hKGPQMr7OryL5XYW4DQUEQ5YYJvKYglPOfIR45MYoYKGGGQehC0DCAf6UcCsQoRDTJgunCtVkuYu52Jdk584cLJzW7D2QV41DG+JnHEHEtD8Sp1hIEqmhskh4AkwRzsY0EAt79/mPak3Jz1O0AE5bWsPScOpmINBzjYwKXBDZyWj7YeMSue/ALwfEWPAWrZL8N9u2TheKENc2OnyKDASg8QBzegIxYNAvtcsFukVKDWTbjUEvqCkj8EZc4k8ATqYhMCakOfEegfE8LKvkpCdiHSC8JSyGw5l/WdTUsMGFD/8IST0ngg6WAhAC+aIAH3Ld+Mnp48+YDmwoA0qwMFA9ZEw0SZ9h4rLEykCfAv5Dy4CilIth43+LUviMnvBrHFGNu6tPd3Yc6oqqCfg3zCM04pBh5OZvyZqVw5hKsYArMAeg3z41BtyMdOkjlkeyUrxHpVB6mQhJELJaJXMKMg3IfGjhJQXUQgx/IgVQ/7Ews56MeCB9yOgP3d3c9+9nPMZmf0ig8dAJZ1eC8sn6U98V+gHxD53EpEF4EZgBdVMlZjo4bGd7JfxplXXr509gyIL5TLxCAvcoh+BABLBopdSEqE8ssBNBPUBkFQQOw7T1UdCmZlIRDfh8CSZHyjOqORWymrRjg91fbGBnKRZEY6JjOo987xTyeF/adUO9BLYiUvfkEAtxMA8Ov1B9g/ZakKOWqqHmEIYnAVTHOLAC3qfkB68FWwbx8QFhmgGLcYKsAfkx0oGs0ldoJxHeYY6qJU5HHKCp4tI7dbCHYOYXADEAfLJ0O9IpILCYSMFY0Ac3Bw0R41TdaJUAyzN2Bv48bSUilfQvCPePQh7o5KPkkFGD1YX16//eEP3vVCB7jDOwdhwliETcsJ9kEziB9Num12nGa3ublxH9kdFjJBZsdgJPdP5AtAKnBRn/nBFvrmtz4BqMmDdQmBteI8URwU4Dev9AKOJTaic9fRKahLDVg68qAu2HHIrkCBYFj6gNrUCeK+3hB2WVLK1HUdS8XOznavx1x4JSrroQiktTQ+ago1RKkDfywI4A4QYF1zfSanM1Z2xvOBToBFZSEAOCjjUOWKw7cyWlHsH7ciF868I0BFXNj8k2usmEAU5aFUYnVouT5pKSLSkcw+BjuTchOBqh/SG4MM0gDgtyikFoOU3cnZLoG8pQlUX5TsSGNpqtZWnsV06/V6+9q2ROI/sxGgkahWdrbX7Tz3wkF3BaUxFgRAI9x+FColzCjApTDDIC82BWCWsTB899u7e3sMxTZqDZi6FiFuGANoKWG7zC1zG2G3YJdggaeAL1iJKqCx2YwSYdyUmFdh9mGZ0bMCpx4KUpHQaScIih9lLgUyqDHysTeRzhIytK8yJvsq8WNlXFZ9hN9ol73AJBVGtUkdEpC5QDvUBHXi9ic/eNcLArjDOy/UGP9FpsabR2MJ55jmEUqUQ7LZcgFv0SKyuAuwBe5kz8l5Ispgqic8MIuogrA+JyAoAOYdrF2pR/gLcb7c1AWJyCTKNvO8Ea3g+KggjqupHjPGbDkTd9Sj3lATlxTEMa+Ao8UOQKNSRKVDxYAgkdPoPfSLlnIsmYTxdYfnP0hBCwK4w9t+sLRWY3aL0Jrg0uC2SXjzh9vMcODi+qzczBpv8nZ4ekBKAM5BGHI4gcLehdyEvQBFSA96Cg6ciC4AETCSg251DBNDZxCD3kg5NuBgXxe7HwCdZY4CzkDE4ZTxgjAxkaMUQA5JEYo3OUQ07D45tgBj2gwEhMKAUhEykxYmCSbpfKBKaebAHwsCuAMELveHRxqsYq6owDqE4BElANghxGB1Z4s5+gUQjCgj2IWUEoiIAuViDL6LkCLgFFw06qChuvindOC3zJdQEkQfALbBvB54IN4ld5lgYLlMzQnagJQAfT5XKLGFcXZYLBuAXqH/m4q0Zd9g5yz4jLF1NO6xHrXeDyFTMdzGGeMAZkQXw9K/JlscCx3gThj4wte+9uCH34UnDQwZoScQCf7VRwmr1Kq9Lqu7YdHnmGBchM+yeCjTJVnSH/bd6/fZfHfYHxCZKVesA8dMYgDLbElQ3u/19dQfDZmqgl8F5FEs4ik3QWHt9HqNRgOvZfRXjKLVRg212+XRQW0uV+ZgFJnBhAqmqQzKOEtLAPwSnkuU5IAdvzj/ZBksY2eAWqW4k8+zubGLLUqS0iE5SXNObHBCwp2e/mCFLXqAO7xvLPfYEcejgThD/IDrqjTSAWTZXYJ5Ydsb1/m+eu1qrVJBJ4ZMuvsdFuFBRa5Wym3OCwWWU69WSvgOCUrYuXydldoKJbyL5NzZdrBvUMiOwTiFgs5+T4eGfndQbzZYw5Yp+HQoo6pbO2qKymbZVh4ZrNVq7m/vrh1e39vZwS0Ukz8bDlvLTL7VaLIWBaWXXeU0z2ITyv4stKUvE2f2Tgnu2TYmObnD8x+koAUB3OltqycGd9Q1JzYKCEMlbHZ3r/3MN59jMBjhejAQmkj28Gks9+id+CYoGgEzVVyUh2DMXAF9p+niW4oUU4YG5gybgnL5ntNu8v3tXShkskuSAtYblIshzs95CKnL8DMdTs41omeVfHXUY4mu1miAf0+Zbxf+GffZ2snZj9u7ISoVcKpmfma309PRyIk1esKpAvAg2JHAPnu5LnqAhRn0TvA3TNFeJZYT5QuslPwzZtXrD3vDXYV9uSkmT+w34Mrl/B0dU+jGo4G0UgBCRgIyZBjAjYwi+qQlg2HR/mAW9dJSIkLI9ZZISJ614ti7uIRRk7mYDG6VWbGlWqrWmBPDgg/lGmNZ1UONJe07FM9qEczMb3fwf+sPusNul/0hyZpdb1BF+uEIARFK21CX1bZDOODHoge4AwAC2oySxjKaMYMRuCZ9AqABTiJIrhrTZkKXdTA4jPKiO7FORsZaYTQIBcXM5W8sm0QS9FqK5mf+qqImRiW1WqkPV1GMsVjxi7GTmFti5/LoFhQvfaoXQxdlPEzRA9DQ6SyYWjNpj3Ms6cJoBHYnaTEGImLTPbIlNTSHjSiRiO7w/AcpSDa0ON7YAlO2ZYcli10ZOYeAE7EybFm1HgmaeqIFwxRpvyGkA9oweE4iEbkrEEXsKEnl2amSLuvpVJsb8SJnaSD0hSzDWqjgKreG2HM410wFwurQzTCPbIySYa/UZxkL1OvRgKXf6ItCNbeXUkuP3Te0QlFocpDuIx951/Jy40bAwf1d9AB3ePdArVSvsdAPAFemB+sCWJz6HcZONGKnrmtnZAktHXOYbYKUzR9SBmZ84hk/QGcPwL9TAzwTv3YMsvvoDkwTE74MweLKQDQjygy8OY9LYkOLZWJLgR8ikIGpzULWrtDlpsNUB39/6EJvOf6silyfYumufBDqI/un58iVzl34/HC4Fw90oL8WBHCH1w+rrRXyXWQSZoTZAwS7j+FZXSuBsGjWrKhR3xA+Qg+0ATB/+aajgAiwHQXyomtIyMESuQTKABVUhl+DkZGqNFRGAkAOaiObwG54UMDGmdabY7kTvJWYo8wKu2gf7PwCiUxcVYWrhLJYwc46MgjGPc6gNCg2+jEqx3DCl7/YYWrDHR7+gAXxFhbH7S2ALb/Mviw68Ih1YIhvNJHAC+BMgC8E4b6I19IB3FZ5g7tJXpEo0CvQwR1MX8ElzgLWniWUQlxT8R/eP8o7UkX0INSApACcu9IFiyBKeJbJH6IO67Yr8zgzhp6Au2IaIYlBCWvPB6K0r3AgLCmRrOgHarWFK6jvatED2Aq3HYz1vnzq0noB+z0qKExUdAI5TjgTd4KdL5TUCCGCAgtoA+3CjFDuAGjalxMT+i0ReOap0QB6Qh6EEArEg+kbSBTyJAdYFF2Eekgw8oio8wMH9cgJ/hGIR1SSBiTD6KRIhUwWReMKEVbaGAVQALMGJPHnwB8LArgDBFhZ9uzZM0cffSA3xiMaW4yzWMAcuFTCSIQeyUA5hLlX2Fvg2sy6TXAMwGCxIjth+oE4AwFxIvDgX0Sx0oD4DmIgLekZEND1CHTyxR8Uwq6pElNRXsUNp83kxzMYPPwe92xcgzCADlnCyzkCdg0So4khBnN0TRc6A4kriM5aUpWEPO7w8AcsaEEAd37hbFIBikEoUIQGAKWr/Qf4scxX2bi9Ua/my8cefOC3fv/3sLqL4sBwsGmR70RKrJSabJwdGfxWechMmJiihBMfrTPgVp7OLfi8Jh/Ysz47mUql+olPfnS4fWlnf9ZjSQrce/qjQndYLA5K1cFSs8WepwWm6jN0zSIU5IFHNHQi1lWQqRGZsgg1ZXLLR42KsPaWkzMXx0IE+n4YkIUKRnwzgUywckVwEcqtLz7zXCz9kyt945ubG5sh5ny/nH7c8NPXthjV1dIUioZghi4zGXbAPnny/v7e3rDfw22O7unYsWMP3ndfe283POvysy5qvKTHeu0OWUifXJqaoehmpen1gT8WPcD3gYBACdkEL4Ysu526QKIiy8zNFY/ed+zUq6dN2Wl/n/T/wYK/39pV7IDN363F5L/3QrlUQiemnvhQfOr976hhDFWPQYyzP1Co8pmy9Ua9efxw5tlv35r8YJ4vCODO7z3EhxjwQu4Prx4Igg4BLlyqVh9+ZG1OAHdOnVlbW2OzGW5WazUGaB1SC7YNWQUjNtmt50k28xBFLSUqVNpsN9h4cvuP+kYrYQ+bJFalxYoPikL2F8g+mrQgYxzx8tDB3n77m3/4nT8qvwNxf0EAd37NicgMEPEl0MKjRA4fNbjf7Q5z0wY6QKX6qU99qt1ul8ruJeagLQw2h89m9a//9b/+1FNfQ5b/qUcf63Z3CuUKzmcVxwQY/aVnyeK1jCKMzK59RuCHxR7pKjExIXZNxjuDQf5b3/7shfPdkOmpB/YcGDzbheUL1RdffOGb33yGpKRlwGu/P4d+8jwf/chHl7Kj9u4OvtzUGf6PHMeS7PxDEZTzw1DWnZsoHaELArjze8SoDjoHriybw28YFl5vsM5Iq9ZorK6v/8xHPrrKVnbZ2bFDhxmIcsZAYN9fzZc5XBI+/sGfdTwXLp47BHlomkm4vpjVPIqPGmeJsxARtFl6RA+hKj07xsVjj75VtVWllqWBIIG5pTOT7bRZjH3X6KPxYHfn33z+8w6DjTPD/f3T167t7u60KiwON2HiJlSLd4SudfgO8Y1RlW0PQhtOijzI3wsCuMPbR1JYWllZWltdW145dOzo2vrhUmu5ubK2vLyM5z3uZ05aFKMyXyeneBq4lrtywSLmLK8rbAFvEhK4jkhRoE5qkSpMM3FKZkZFbhHupKMENpx0CqYxPTTzWJJjDuVS+ejhw0xNxoqUPXbkv3nirZ4zIIZLaL9/bWvzu08/dfXCRVSIve3N3sAh4nKxECPD2XxJw+7ioAUWzXALDLLZ9bW1P/fzP//xj3z4rW97gjV8Gs0mvpawTfACvLTEKAmJzCSZ4J+3YcjtXCUIdRkflzeBAAjB6ikbjz9xDjtn1eYICHn/Bua5F9dILXgyDKWFpBxXkuCmSVgaSFlsxlxNDqLYdXjCIAB3JRE+dEOQQ284xOHh2qVLr7z0wve+98LOxgZdU65YKC01/+BLX2duzTz3A/yzIABfPhD/2M/8zF/5xf/iHe99z/r6GgyWAVZYN/xyDsJAIiBOGHYMYwl+LhNPnhvtGDzc8Pldwg2CHkSlnBuRJKQdQpT7BXzQUCwzoa0+PBaIbZFRbCA6rrgmB2ss4lVJVFEiamQbPnlxSZmUCMEk0RlkaO+3L5w789y3vvXSCy+wqu6//YPPmc+BP268uIPaECtLS3/253/+kx/60Ec//CHGt3pu8ov/AaCEh3rIZUUwIUIKuAtprvF6S9hzNKHyin5wxiUaEOdmxDAv0xtCACf2FUYNNDvYFhnqyGlMtW1yIGZkIrwjlTWJPfBQHgiB4xuJ0Bj/0lvJVdv5oHUYmECfMgzkIBGlMqXzyuXLV69e+9LXv/Hp3/zNbbSIg33Q5Af0WF9b/4t//s/9tV/8KycefGCSywzwJkB8AKKCUw8I8KUzsWgFPeBHfNIJoPveaDLHyMSxreh/ANOIopXr0DQ5c/USFgsiNucMaFlEIh3J8gP3RjeSfYXilrC3CgnN3OT7UQG7AeCPp0RyRu74ZpM3uDebEIPMgMFhFYOgFXqfIBVz1Usim9k6d+Fffvq3//m/+v+YrU+yg3n4Jg7agQr7c5/4+D/63/+31vLSECt9OI0BNfAE+gN0sufAumCO9hGbMGY+wBRLCtHEvZgNABuJhVISYlBMJwJAV1iST4eRh2GE8M8hT4w/TIi5cUgtZhSwZzk6pgSIXyNEkWaW3DUAhBPZ1eMSpdiYmjkD10akGthKCZbYOAkCkDbCtKWqAAUwmYEupVD88lef/PV/9S+ffvrbcyIzgwN02OwH6vj4xz72N//G3/jA+9+Dkw4295ALXHIBZq/YE1Arsp+cyAe+njg3BT6azAewiyCm6gCIKqrLqnAmLD/YddKkoteIweI551DaQVAxMfMXdS6V/QdM4/xmCqkqqUnQgR2IKrBx/bbOnpCFP65VjbhvGod7eQZCUJG5SzRgnnQUCFTRCWje5Z76A1TAdH4st73eN771nX/9+3/w+c9/3hodpOMAmUFZLAT0/+N/9H+stFosJQIycK6Uv98QSMCr01qAX16AA8HEAxp0K/0nQBd+LlulsUWvfVMLVsFuXiQMwHkDHZefwDVUZHwTe4e4fiWHE1WgAC+9i4gfWPcmlyri5uKQGUMHfnOZcZYwZiKqyxqIEAabLjF9B6FLYqAovOLowwC5REegvYGWqVhvV5HJ7Q30jHAuQbH0rve/5/G3//Sw13vyqaeSWh2Q7xsvIe2Py6JSv/SP/+HP/Wd/wsFWl8iUHXsE7AApqAUmsEnXJ4zFpEBsrCkyFXAJiud0IT45xL34N4uALDTCOYhzMUJDYnpYwraBuPkGLwd5Mm0ii0lOzUFlFW8FuxSK06kTI6X5QGZEcUANdBPPTb+SrOXkdlD2TuRvNHOLL/IiX4LMWSsqpwo9mo6sRmRlJ+CcHkKYVMBiEoPBpz//hV/+lV/b3NykSgfhsOlTf3wMseev/Vef+MTHcd8HD7LhkPUBEugBIgrr4oVzefFrCOYeFwFNgA6ZhNidIHbedGJUAjAqdAXCuAE0JQxncplrRJDGuFZW8ZDZo5UaOa7jW1wS27rMScJL8+M7SA03f55BAlChSGQo7pmCgihC02ekEOVxw8QJrfAskkSSEL2EOxysVe3BpGaXVmHvmd7g7/xPf/8b3/hDy0n7MX8bKX7Mj3/847/0f/+T+1ZX9gZ9QKL+KpaFGtJF4quQYBaEBRjBBO2RcGgRFPKPZANXBj8KNhFFG4/5iOIEbWacZOG3EBfHM0sBlyFdMb/RWTXUAaHIbTbm3UEkiPKBZ4D9BmatglAma05JGxlLThzwfkKtUNTAZ4Pk5kTCvaCoBPTsdeAKK1KdNyIFlQs/UZRoP0SEBvCtYMLAf/f3/ucvfP4LKQZG8mi0V2qPROj/pX/yD5darSHWfeAaEotw8aHFqF83/z0N40/gJoEhOANkAesAvucK2kE/MnzxlNyBnGCjwaeJr/hu/mYTxZGS8pW9OKHd51QnnBVl4m4CciQotRFrGQpAnFk3s0qKg6qU/k1pGgtNBsWoCkrwXGxLciVdjBLMswHpydODdxWHkIhuzvIkfyeLTac77b3f++3P/J//9J9GuaZI5ZFaAsDW+Wu/8it/4k98DFmBdTHxUgvODdjVN4EPUIo3iq4aaBLFoFI0JwCFPQf8AppJkCniH1cFcsXnB4MjISYRhcKRvIPtYiByHoodhtYe7oMti7X4UEfNOCjBpFaMqhkL+SbEE9M43MaPlQPoCXIJIAIfxHcCeUBYOnvbM5RGYcZOkijvc0aAJQbb1xBkKsiFe4pQ6glyf+sO8jmsLJ1BAQvZdPbP/+1v/vKv/tre3i65pvLwpafy+Lmf++T/82u/KnP1/UsFwkmBJFAmJDgRHECEA4EEGCqTyC+DPYMRXJznw1IIQrHnBDARX3MEc0r+lhCB3ADe2ltk/1JEZG4gYS6i6BYyjq9FCnGvDEOJxueuWWGEdb8jY3BEmCRh3hAAgXkknOjNKMgyjOQj8HSSBqVYvuHqvpxEHzOvThISKaIHsFAoge9EDcDfGv9WHwp1YjRuLS19+atf/9v//f/Qbu9bndQd0cipe6pPfvKTv/xL/1et3uAt4gMP4w1uKBAFh0DkCHwGUMRgBAV8wGLIFSRGYhHx3g4mKizMIegpoEY+QWNGCYAHqxZVSY6miOhkRrEKQIH0xECE/EM4CdGuBa6p0FKCkXshEQjfuDGnXixFmfEN+xKlcTvMO5RJdOk5askpFzJ6wqU6qxR1vJEb5JGMl8UzGUpXgI2MpVakAQLoKIbDerX26c9+/u/8nb9rm6XuSCEBrKwsf+Ppp46urekdD+/n/QMuQQRAJIAETWCCD9Ku8oZA1ygCguj9uREs2SSiROR4kDTWWuDafAAMGOPMUbPkNoEGyEAhr6T3AJIK6zE5PRGwLMi+JTG5Ruamsj7kI42EOSnGtqy1eRse7D0ikGH0KiFTRThRBLyRCRTuXJLEAWBvWCeeNHoHnwtyI5rPwGoXDn+oQoSNVYqPlXZxrTY6ejF+o//j3/9fvvrVFA4R2LhpOlB8f/mf/dIv/PyfZu1Xny1A4Vu0ExAd0d3HqRw3uC7R4kzge2q4MeMAOoSKzjlvTUBBEFnFOMGNmJYGwqQlV1DxMnoPYiaSvGhl8JgVDOHMopNrg8hcyowCiWCVI6aVMcWNIx7CygRZh8qtAx4xAPfNeAF1r4gWZJzci/t0QT4P57aAZz5YWJaU+wmADAL0asJw/yGPwilLDjHH4O/9r//gy1/+crTHjSrd+7832+3ef5R4go999KOf/le/DsL0jgmhGGiEcUYc8959f/zzrTFkhgkcvkiI0n/AIgQDZSRxHF5xiacYuIBnB+qNRw7RGwBhAMSlPpiiSuZt16AkY3lJriFhcyv6h4hI3JBYLCpGeamemXFJlWXeoRXMwerDeTf59a6xqKSrh3IqyXDTomO4jM4nCfLbpDmellREUgOBnBPlnzTR6XmLzSuDP4B4xCqmno3Gk0x/OIAqYi1Gto79S7/4X25v75A+NUeqXCEqlcrf+lv/da5cwLcTK41WSNlciL/yNYAqwhKuRjinXNj1c+K/aMFIwhE4JMKMPYwEWNwjOXcC1klqMUkJuLWZLwcgE+JIVhYa+RLmQZ4K4uLV/DgU7R0ps5YEka19Ave5F3WOMiNn0qvIA29JKolvVA1A/PoAfNB2lOll63zFk5KVdSQ51YlTizUBhftlx2Nt+LHvovpqTMYhIjM6WXlrNlRww2WwOJt95I//8X/9G79JwtQcqSIA9g561zt+Wr7FG/W9x6sG4Vo1kHRnbFHNi7d3F+OeAhVftv4FggwDi3b9QDl4cQQg3OvpDRgt1u9NMRpmT4aK1+CFoLDkmFeCKEI55Z8/yEl8ibcA5TSD0w5GHrUOy/YOMdgEkkykGaojAAO+1si05AMqSW914y5Px5vTayPoLUA96xs5pCuzmtMW1TbYdLJ9lkQkjqmISWGShWVGhSEhK8lurITTVBzsVFl0oZU4n07/81/4M5/74hd3UzSLIFUE8Gc/9acPH1ofjOGMdOkAHdjSk2vcFuuM+gBvGTyYZWcXmDSdggseZpw0Ls1wyxFR8Y33mBFeO8KWAgFJQ2JdQLEgJ7/E5+BEMHFLkT/Bl8XGiIHap50DyzpwFpikGFo/wZa7kXmISbKe52Og6OWbYFFJSTixRrgdF95BJgqxB0Llvh0Lv9ZPHyHok4NYVM8zzmXwSRFElBTInE+kQe2WSCKYuHQpmWLRNYCdPJkdTMZra0sf/tAHf+M3foti03GkhwCQfz71yU+4rqAvkc2kcfwZjvRtcX6jggwvklUSxIZuL75naACEcgKpxCriGj3BjdqtPv2AGhqQYEJuQUQmLdnzTRjpnBuP1OQ4kgAjc444ISmXit3UB1xaMNlIGuQdkbUveQkeTRNsX4FM8rUIkhBscaI0zFPAGDTz5w3KmyKWIJrP8St2zZAvUvoM9i44e0PcyPUydsKplanjC0WFuBPWi2CUIsKgGEqHzIhLRdyqOJcbjCjEZ2YV0j/2znf87u99ZjhIyRya9BAAL/Xxd/w0W18BZl5qt90G3hCBiyYLacf8me8ICgMYCcMGDSELAWcB7b9f8ktOFLKBENRDLPInDsFQjJgOQIA9bpCJyU0ssmSopMC1E9oISYncJJEANLGVx+lt9M6QGZOjsI6k5jMWsmYfdSCutyjCiDNmfrFyaBIbbAJDchbQyHXyeimNaQzAnZyogLo50pB1zHlL6Yt8qbS0FNuHzfL6CEVNIOnIm1LMkhhu78cOrSUm11MnNlZ680MPRvWodxqO9BDABz/4wfX1Q/D44WjI0iCdvZ1ssTAaDeGcCDjBfGGKQhm3CHDGIbMTloTZIYgwcUccBZsYkIrxgYQw5o7HIfpHCAiD2KQJ05pOVAW6uDJfCMC7/lsEAcHvIa+Qh8A64hpdlvCmMgkNGdm6RGwzSXBsftJZ0EySVcA4ykUWsu8A07JungK7jRQLAUs/ajVWjTnBEpv4p0i6BEmGkriK8WsdRtQe6NmQBqkIKgNrxAgSpg3ARkhYLuYff/yxZ771LW/f+0d6COBd73pXo9Xc290dM2zDDqZ0170h5/YIgF4QAisAIb8UV3wIFVOBDm7zC2LksmrNOE6aIgBu3JCIgKaxAQmXxI09ixRsDOWjJUfwRmkMkHkSjJ+odAuAEZORXQT5mY+UQVlWC2MtMR0vS6YEhL2SOGBRfh354Mnjxt3Qszq0vJyizQeTf2QO1uNJky9lHmncSIF6C8ISBWPnDkoIp9yMJbrYV0+tmqiUONRP1rMcg8LTwoCtWKHgaMpWs/HYow8vCMB3d1cdShYwVAT/wYB1/7q9br/ToYaBkBASZM6+b14+wYoUgVsicEP0Gar1H+7HJYzQQKAWqACmwZhNxTEmS+GtpG7KCCV+gi1CktAkc+9bOldsJAbvDROQCZ3mIjr9C5O+ZKaMFOkD93Jp9WczJCNVc5+C7AyRrc/JgxoFAUtQZAv6WdId4jEqTx6EFg9lhmalYGZ6j6QOPioNxN0pfUVSRnFaYhQMbUoSmE57g/573/f+3/it303H4oop6QGY8PXhD324N8QCxJyOcZfNcrd3Nnc26/VGERmWt8wrTwRu36poEhMYYeTZcESxzj+SkCfgITMrs+GQCKP3J2gOI0Rs0cmRBCjqzIknsiQ7uTgdQsDQkvgLPYE97lzdMO6hWkhm4hkdRe7Pf4y8CV5SGUHsWhHiSAKA0inIkhR5EyxquQpRzfEAVQ+fM+kKVAlEddTTx4jIxIHPwyogGlg+z2svweFypcxD02eWCaEUjvmMOtDZYE7oQAAjl6hjk0puPPTgyUQush3u8SM9BHDy/hPM6HMVTK097Bk9ZOF8BexKJSQBuKYw8mWDtsAW+AD9QEe5QXxwiM9gizMWmw0umbxhACOkuW+kOBFbCv5Jnt4FfGzXiDQi5XBQSmQrYClIY5G3JEhOuAlXjh7AxN4yYmD4Zv9kZKtBnQUlJUd/EPXgURSETMHTRfXt2TSYQtYjKhn4j+eJR6EyoTL7BHyspI5MIc5lBDiZ+xfLBTgSjHCE711x3EeYHKohl/LQf3dvl9aNZ7rnv1JCALwzh35BP9aeEITYUgIosIsue72IOdCF3K5f2xziIAbMgWFHT0WV71IszzEtM+WSYEXtAAwRxErACpCRrQSAYR5cAiYtj+IwTPtK/JJZAseElUswxmTMgcQQgKkCxOSpZh5SCqpFVIyCpKIQ9K0GVYvoY7i0cUPut8uyVo5mJBlGUWywTVWiZ4vaYt7l0bkFutGITREHIdRRsqIgn1HVGUp1MJF1sHv9UqWItWqEPXkyZedJomFuYheChx566HvPP8/VvX6khAB4DYjW6GtARmsF0qojAJlhvz+pVHnzQgsBRIQHlII78sbDvk3PDjYT/VFcJCDQSVJkAEcXTVEpdKMkcB1YJ1rkRDKFIlOJKnBsONFEGYBKoEiQuNOqGshMIgSNJIIWd4gxsexg+WKfEzsYdVY7regg6GQIgmghAGgUWYWI/LPnI2WjkABxCqUOuAMpL3FbRcUqQUWjPP0TB+TgHYJ9csrw1CpwotHYq7BxZXL0A+TPsyRY4WZrufXud797QQA27d1z+ELD1Ig84FvFelgoor3RJziaAxrmrzd+gtcDhBtvHsmCVxwCBJiQKcJ0ATR4EGGARL4OHRgUUAz7D1ATfRz82gEEYSk8a/EBtcFbBZ+r91gEfZGZE2Qx4gwCk8jIhlTIbC6qZQUIsEOKLEE7NQ0SCnUlgh1UNtQ8ZuxrH1Ru5j6UpQew55kYS+ORpfhUposfIkIYhnlDUSsKlaNE7dSErCeR6LjMxswhg8jgnv9KTQ8ArBzwgvmLoXyJdf1hjgQgrRYKVYVkX7NczvfKK3UQWHyKP14/TFbg+2ITPVJggwmOAJ+wkEoApugRMCQwP78SIBg5CMnIQSFgUCAjnQkiiwU9QpTKBQFYOrkRaE18CmWeqBkXQjgZlQh5LB7BFEnNKZRaUx9FKjqPqFXUhIyQqXxoSrcyQXhRfJCBajlyUwhNpKWCQYcadqlOEJ/Ng0w5xh/CDpKOxRa0hzFnZpwmj3yvf6eEAHhv0WsjEmiq44CljscD4MHcDsxAgkAYBG/mghcZQSJJHIe7pEgNLIehEnQo4hOBd09S/2WGCQHEtdmaq+iVu/uXhIQJJwQSjDSabUwe+ROJqwRplmel7BYgM2oHZEMzN9ACA+pEi5qYC6HBsFFboFPoysrJrFVeJVg1YDFNaLB1b4nc+ZNixpLRRzUtIh4tHpr5zZAFMZMP0ezpqJtl+i+FUiMqkM/jeEJgCo6UEADvGECEYioS2QnFnU3ln2AfWajE2DCUgJ2T7wRb/PBWkewZJLuFgdvVyzVhrTrTJFDx7UecGFIlV7HwGttHYaRAgUXWKIrkHOJEAVEBFYBgcCTkpbQbcJIMhGoccW5ySkmmDnPhHcqyugL2JjaJI1BDKiHrYOPmZiHRywHd5CmivxLvQe0m02YaOJ/nb3GWw+XQL8riIL4dJJ0po3IEcknNaU5uF1FIJtN22zGWFBwpIQA65WKxFC5vvCehj6EaRuWspvCOFsvYKBFdMRMFtnzXvmZeqil8+SG0JC81uGQomHJroSMywISJOJEIyIEr0iKqgCoyiD81V+8QW7uonyACkyUpBBVxuDa56ck2bgfcoivw0iwUT4iVJE4CuQDfSc5kaGnUL5h+nHtBnxB19OnMxpq9liRJYaaGve6galKXzaJtgD+uiSNJSfjYnrKYmy9cuPC6ZPfshS2ZgmN3Z+dXf/VXyuUKfCvZ3gtQ8SLZymg6wUFOiOAJh0CUwJS3mwAnGLNXGAq5JR9lONUOgAsyg4ObBFDHSCrIEw5JapiHZGB/kQAvwBSAEnfmZsw45KDkSaDMmOoEMAN+BMpxSaw7A6mCGpJSeDVGZjKNRIBJ3giGRXhSKq8w5PHI05x9n375KFHXSBBcPB4ykvMlVVBzL+MkMi8ErQQNkD6oiqf0UaR0MqGye+39p9KyhGhKegBeYM9hL14crxNFAKMIe6fHpnXAjlDCQ6LlRHTMO3TRJcMMsccXbQCwkQbEELfUYrkMQIbGmfQg0EF49ZgZ2Snni2k/kWlkBL3JTSPAOx7K4KYxiRSUxJaGIiu9l4VbYoMJQd+qhIbjgHFCgCa8cXjm40WuxvVhaAT+w4KTXCa5q9+Ts7JhCD+GkiAuPeGwcMxoUiLykozfqrkDJje5x8p2dLdslswCw5Hg3v5KSQ/ASygWGfGFvQIBoA/2C6USO6IXsnlfGfAEVzBXdGRera/XqM7PCtau6A8QyCHs+MBd9UAeL+Obw5TfQPQcMPHmLS8KJQU4AS2yULEExpCYY7cvroAUDBUcRyxumicXlCJbjSysAyZ6K+itCAZyHhFB/zweIy4pRYgTKTTsaYE7gWk7E0e3rTpzYmyRuGVcOLq5zrOmQfhIbsYJnwhGLaIhKM6Y6tk+lFIalKM8hpKNtEkzmCQFR0p6AN7Es88+u9fp8OYQWlTXtN1psMMQSo8Qg0SahIQlzJsEvMFsdpQwPzhuBHBb6AiSwJW0IrXMQSQDNlmCI1CgagxI5rmBFmMAIXIjH2gHHQOi88pMZL0w/kAgd0U+lSMbi5W6PLjgxs3tM6Iu5uaNJCN+ApdRL+kKac/cCTZ/bgcfD3K1NNKBX0sxJo/Aie3kU/oEJCbYDOw4iELFwbyPQzRPfMr44Ss36+870zMdR3oI4Ctf+tL2+Quto4fwg+YNVssV3x8jwmyLxc5fSEVagdQpAQDvO2GygkAUyO84fNlGEDBegxBiSAGAQ4wATcdZOVGfQHYH30YkKlFEdILjAEgUYW7cA6akR/6hCDOBN1MLhX9va7APoEko4aInNiPTyFLMxmWUFNyazIlJJHoVUiXKMkEi0zRmmyThmycgXIusEX0AApNDJxBDkz6QMFKaoRK/pz47i7bTj8JXmBywu7X90itnE0XlRh738G96CKA/GPz67/zmX/2rf3XGjKlCoVKrscIZiEcYgvH3uh3cudCPxWkcIdskgBEMQIJXnrBJ3/n8NO6YJEGMgr6gA8cmcq2ROamIOv9FNSeBGwyzwtDDJOHR4CosTtOkeG6BNIpFUbd80kFPUVJESCp6g3bMlCiRPR4cJg9eTRYOzyV9Dii3styiuHgYrsw3PiDYupiP2VhPiUE2zxn1A/CEawDQ94LAucbOJARuFgv5q5evPv+9589f3cQ72grd+0d6CIC3VqkvnfrOs7lScf3osc6g3+t1sPqjq3U6l3e3dvAO5a2iHuAhp0qH/DMYFAssVOVoMZ5eTP3O85KLxWG3VyiX8jl2Wh9pSJrNikU8kTOTwZAT8sfDolIqIV8Nuv1cCd8F3CfH5MzQE9bXUuQpwnWrHFeKBbzpiwxPFxI/0RlQwpQ+Y6JtnoWc9a9I6GqOOMCL5lAq8M0f5IxvKyjFzjsYudwLfZITWXCjLhQYf8BTrVgoTJmnyLgto7a4AI6GlUptOmAO86TUqPf7rIYxpuaT4RiuTv2Z4EJSl1EZjSu1iomm2Wq5XCz7UFoP8vnxcOyIeqXCSDDN0u50Tp869eLzrzSq9WuXrtKp3vvg9wnSQwA8zFe+/OSJWv7KlUtvfuKnW6ur1Wq9s9/euHbtySe/ttRq0ANsbO8urywBd7BebzXbe21eNZ/2/h64lxVPp/Vmg7WfVtdWhj38iGbVWrnb61UqiFTlvd09RkCrtfrOzm69UamVK0xAKwKRTAZIcaPXY2mSaWt5tbO/B4dttlo7O1trKyvdfr/X6bWWWoN+F95bbTR6nQ5wbSytDNttpjDkqrXxaMhEntbKSq/dhSpYlbY/GHU6ndX1tV5nn6me1Uptv9tFTWVvv163B2HXanViQgCVep0pi9azWqMdtrao/+qg1+t1u2uHj+7v77H3y8rqKs8FpdUb9Z3NrVq1CrDbu3s0CB0jPU+9htcgz1svlUtQ1AMPPzLqDzZfeeXI0SOjafbpr/9hpzvg8Xf7g/PXroqdVBx2g6k5SqXiP/i7f3vS2wO4/dF0c3d/Y3Nj3O9c29jEgxdBaDBiT7gsiB8N+pVyRRkJN7VCgWnERZxbECVk5AW2TGUauNOLh0MSIlfjEckgQ6fXh0kjB2MEVNZAmBkO4KwkHMKGiyWC9J4pFjHMIySUymWQWqvX0Hdhw61mHQqhY2q2mqTdb+9XQWE2s7fXXlpZZt5Jr9MFwfpimonMeDQcl6uV4aBvTaiSwxLjaqXMLBU0mlKlSufR7fXBNIv34LMMq6YHYE4c9i9kP2Jh2SpXq91uB77OLeiEPq1Av4GDMz3XdFYpl3p95gJM6/X6oI//c5n77KrdWlmGhuuVXL1a3exOi6UKtAb1Nlea//zXP83zpgM2qeoBeHM7+92VamXS3ymORsuFaX29WZjWHj+6HiPAzhjUZgMNaPDMo3ciUdjfI4owDqXDMPopcWcDpHQE5+k4y/gCkgSSsdYk8DfDpwKgoxe67y9SDpK+IjX6dugNOGYqdCtZK8LMraKz6XJDm1SjQT+D3IKoPTuyirhR5D98MZCJdGCmHtSEPHMs88b8SVd0UUDnH5JDPEmU34iA65/zf6yqIjvFKR3pB6W2TYIyS1ogalGNSoPKE4NH6odr6hRH/wyL1YWgVk08HjK5coWCCtnp0dV6dtJXKxjltnuDfGONWXb5UunRx9/y7PPPpUb+gYZTRQBM4PjKM8/+qT/+vtMXLp49cxqcgj8wqmnfl6+FL8b2OVUNBSglvh0zyJdpC4CkcI1eqw6YeNgj4IN+VMwi00QEeozagjMF9jCQg8XQZEWoarH6KGd+dFC1bGhJhAbgyJBlsAgFdNQB+6wkAdnMbTvzKVqxnIQWHkmItKTm4GHEcFz7TFTMuYuIbgQJcSvPCIYEwFViYzITqhHZkAfNYiZkZQasMAc7UKugMhXOmfNg9WJKMQ8+nfbzxXyuvbK8unb4WGt5rVxtJXWxPvf+kSoC4LV+6cmvveXRB3HCGcxye7v7gBDUiEWOwKLXmUzfmcOTerFQRZopFkqFfLKuIIwZ5gwAwtIPy1ZsILEo5o4clEtNNckRo0ZCah6APi2WEoZtwXYWJIjSuTYvMGqFXBZOTEZ9iGl4gm8DDSZdkq+3pEzEJQ6+onCrqqFSJPuJqvFN9S2CaniYSWRrXkmJ/CR1oltzFSJdlhLCHvLcFqDtl0gEU1J5qXLy/odQbJhRsbe7/eqrpyPjlHyligB838PB2rC7VSzWSuWrvQ0Rwiv1dc4PzsBHZzTZ6fbZu45RYmbNl5GYHTjT2Bes0X4gSUOgFnoYf8CFxIQnmYBjoiVClZAyZ0sjJ5PE3XkmkUCxhyMgxpcATZBMGUF2ccfQSC0VGSNicUbdok7cTOqQ5O2FVBCY5iv5zLMif8kWlm9k/iPPpGNRIkK3gf6b1RLn2lWJ5AMljywZ0bU88djJldVD6BW0zbg7fP573zNWWo60EcB0MNx65vnMWx7m5VVQRiGAAAUI8QAdDuYD53x3wL64Qy4BHz5DpZjhEdzTeIKGH0FiBgSEyT/yCDR5g6sEu8FxI2COzoAhxRg/4feeJYfJOPgRtZZi5YJxU1QwaqoRSY0UxRvJBBZnmXGVJDOp+UVNIu+omPQi0Sa3YpBDInNgIrLkyRDPutPpcj5fx5E2hKjQQHDttkfgcVAmWBwagy/9JRZctJHf+cznsA1Epin5ShsB4Atx6tjxdy8tI9di1xQGga8AVGBELOnnE2sA5oqZaTGbKeWzFRZoRp8VM4GROfJEHQKP4Aaigk14cUJIcibQQlQA6IYDLyLwHwe/ScSE9SqUQ3IBc0kzqmVEMqGmHnYeVsJa3DzMk0NqNW5c3Piak2o8l3cjr4gfHVoEeUn1LAH2T3pOVGawNMEkSFMC6cg86s7RMjyIQ8aJcERqlIrZb3/ms6+8+uqNYlPymzYC4LV84Utffsv6pzSjAOe8Y5lot+BSaARLBAax5GvOqTDCQsLgRwupSyJDB+JPiTzwRNLwnnNcNDyqEz4acQJ25mBfQfw5UhPwChyPhEeDO4lLFIeoHWATy4mwbmHcE/9WCSk8oZMIRSYhPMT6qC1oFZ9m7wm2LPJMpsCj8cvBrawx0K19GgnL0snUKsSjQbpowLB27hNgspyCkKxBarBGGAAgCUyov/17v58+9NO2KSQAxn+qzUbYZmRgPGTyNj1LQKPdBXRg6gHZclU+yEX0ARAGrz/wYThY0YI0Bwj8GkaYw5FOA1ECvvBaA1QuWZusMYEJKco0bZiPojewJs4VMxXZ21GUApnkxiU5eJKkCZZOLea0YAIqaMKkx/DKzoq87Ih4hZGhuoclq5fwlZSi/09SWTIX+jy21lR5QaKNEJFwb/KJno4Q87H+LAVgGLzkXFpmwMSTvfaVQgLQiJ7N4wKHBwFLnYERIOEr55hiaNe6DfAxL7KMCkOgFWzpOD0QKpucKAEHuIN6CBM3Jhcl84M1p+gTiEXPoizEPb0e5gbQAG6kIkpASW58QzpCtFBMQhUxA1EHLXJbwwvMWx49zzOAD0qFYyDWylgPPTYj47BtkgFwtwBq4rdF83xEDeI12BIFN7m7ipEDGi6zxdAGq+jy50KPFMMtI2IWinNnlkJppJ9M8C1PxwSA+Su88ZNCAoBdFUuFBx442Ww2ePGCjxce5nkGaH3x48mVrd3cfn+1Va+Visv16nKzvlavNNgMAtWB7bTgoKQI9LrFvKn1YAM7JsfBDupR9ghju2YWjfHa3sUuZx4SiHCleK4SdBohuU5ALiaTkOiLSSLYI3qSGPTL0IP8JCWjg2xvJr2BfkhBFIncExHt1nwMmbf3zERuH0WHq6kq7wT6n7B8GEPgGIKi20D6p/pBLSRxWwHn1OEQBRd5+0/91Je/9rUbsEnPbwoJ4APvfvf5K5cvnT9PT8+sAB0VeJFyQLkrB1Ae5PI4vLTKefwLgA4rX17vzPbzY5RBlELUACQh/eJIXkCXdqxXDwExhDe0GgEOFXzh/gZEoARGFZS2KQKkJUWpPYs6//gooythByq9JCtqQhK9Lx2fEqyi2aGvSIDhxUtSGM1gF71Qd6ACbjUZI9PeJjNINNLOoR51kDqkGPIzAn8QMOosf9KnglSuXqusLrfoM+kBySkOOxgajcT4SOxcv1yBi/Tb6UH9LU+SQgJgX0P8IPY7nXa36zpB/MlWlebBGNLxYDQt1luPv+2J/e2d0dbGIIcPZWWUKez3J9Mum6H0G+XyUq0G64SCeoMRbDLUaUUjBH3XWiQ7oA8kOUSKOAshniIUjgJJoh/HTCrgiBoxiBZ4JiPRRzytjZwnNSOlyI4AexgEGCAJ4vFLzRcwVpkF9y3ORF5DC/FM5CN16/CjZ0ceF9fhEMu9JAXOJWGjW7EKrqPTWX+SKXU6zUqtUKtd39zBRyi6GnkFMa2vNClJ0J9Wl9YuX90kJH2HzZe+Y6le+9B739Xb3kS+bff6yDy8ex8VxVcZJnPs/gdevXTlwqVLOIWpPPq+ZYB8ON77xFs/8PjDIB/gnLt6fbs7ABAox4BvdXmp0Fx59dyZMe6cgx4CEjmDF1d+Dlkc2lCO0PfIrN73Mx948/H7O5cvXqAquMHhsdYo9AaTYgHf5OrMFWdVRNAH9Mouuq99GWskc27LbEw0xaH1wQcePHv69Fe++lWxKZgpy5EMoE+l9ZiAFKZu704vgRN1oVyt1SprKy0XyYgFUnG6rjbqpJacJpNKrfr86fMvnzqF1gLaV9ZX8Z6q5CZlh5qjEOkk1GgUBtyXmsvjfOkLT3+DZ0ofVFLYA/CSdjvdjZ3O/euHrl+/ol9/cDUFCzzMmCxWKDeqlfPnL8xndSipvPZqkQpqVVZ9wsFecOF0CeyQh+G+qMd49n/2d36X+QA/IBSu/sHnQdd0MOhDPckCiXnVUDVuuxOYPrCMzOTtnCj0a8lUWkIoZwmqp/DHa+/v/4AlJtHe9pbHHz16uIfvp3QLbYbrkUIaC8bkj9136ObKnleuXssfWmutNGbsAADTDxUGT8EM/lEFuodGc3X905/7fCrRT1ulkwDwYf7kxz/6tre//Ytf+NJTX/gMqzjxWkEdvu/rKyvwt97+PszujpBqLrU+8YkPX/zudzAHYZlhhxklBwUJyYi5ZkDkjgnvGAhwf1js3pYP3vy3hfwgl6+cOXtydVn5x9ihI2j21SLGvIjNa9dvZoJ554H77+9tXnXaDY4hGlA1ndFedDQMoVTKxeNHDr964eLNJGk6SScB8N5nnfaZF79bzmaPrK0xY0XNFemgVkfGyJWylXoDhnvHFznud7cvv4xQBGq0bDJw6qHcThdyeHXdFUHu+tXxIfhyvdHf2VY7gQK4dl1o6QGrJ+vm8UhJCzD35ZFja1fG3fUjR9hT6tzZs72+ykOzWm+trMFK2GpwZXkpk1IC8L2m76iWSqvl8qkXvvfyt77eb+/x+rF5o97u7+xsb24wEYxJYcfpCu50ME4wbJfADSBQimekSdlHeajEJEmGlj292w8qvtfrMRAO+DXk02tRa0CPh/94/La3PVZRzPNA1bmyuVmt1hAImU2z3KQLbKzw16gVGfjr4y40nZUY+kvnkcYeIJf/i3/+F7q97UsvvcDMJkycuL0hzAABDqZrMUaGaeb4ifvObWzwdm9/sYCd6TFOO0dYV3pGNRQ9iNHl0lPfeLrdbt+e5O675hEvX7705vuOMchl3fXl8/mT7qyzt8vkRmarEcggWL8z6Y36+xcv8bQ8rzp8Jrfb6UP4yIGPrax/8G3vOPXSqd174cF/2FeRwh7gXY+d/Ng73/JTP/XEX/zFX/zUn/2Fn37nO48dO760tFpvtOrN5VpreXl5tV6prjQr9uxvOIAAvDAAH5O/xA0OBdokmRx4/4MPviHFXRpQLOvlzQum/liaNLbi6AYxzLL1cv3D73lvUu9jh1aqtRLD4s1alWaB2plEBtvfh2vMMliU9nZ3Rt39T3zoQ3fpc/541UphD7DWWnrxe8+uHzl+5Njx6n6nUm8dP1nJFkudbpelU7CyjAbMzO0iJj3yyJs2t56+rQFh+uyzWnbUIAsGQA+KI1NrQQ7W+N5+97b4d+3li6+efWhtPWxZ6rQaATi0ZeUYI7m+sw1/x1y7XK+dXFtaf/TBSa5w6eKV8+fPdQf9GnM1C4Xlam1tbbVYrfcGvbPnzty1T/rjVCyFBDCYZc+ev/Stb39X7xplH/ifMw8BMXvGMO4POyyz3VUu+81vfvONbYfOiHlciYkJta4sLQ8lGrhhcYevPvnVNya5S0MmU9etGPWdzKkWjGE3r5dHNjsYDN/3vvc/98KpXbZVHo23trfR+FlL5ujxY/1Bd3df7s/4ebJITKVSZjWKj3zs4y9fuMwixHfpw/6o1UohARTqy8V6Y7K5DV55kZPReKBIo0dxpcR6WTVmADPGuVRmwkyRCLc1HaE5B48hGUQgvOnUALD/wEQff+yxL37jme17BAT90fDFC+cfPLzK8kdKurABxokhZrSaXP7Cq6+waArB2UK5M57unL949uJFrEQQSjI5Bj2APdZY94XukrG1r33tq/t7P9xYxG0Ne3deplAHQL1jDR8YGEvfVMsMjcr1sd9jygTYjPk7HXgy3u+6kOgb38pH3/Pu5XrdoVzXOAm/MpDA1Nhy+Qtf+zrc8Y1J7s4QpZ5SkaUcUAKc9o4l7LWK6g/7yPHjBIwm7IzBYjD6y7GLCJ1Dp9vb73X3WcJlMOwOWB6JdcQy7b1d2uS1DNJylkICgMej/BXzhTLQZ/GF3LSSx5VNbwVWQNG5LZOBzSPWaOJ5w7G5t8OmuNyz96AHYAxYppmpFIr1EdbUewkEL758Gpdwpw7Qi+GszfPGUIAiXWa2vL6MUkBzVAr5SoyXIxlWizhhcFmoFgp1Wgk/jXAgt+tI45FCAvjs5z5Lxx22e/ZOdEMr/DmhBKe9awf0Naoa6m52BwLAOIil3FsaQZWYScFEmcJ41H/l5XsLA4Vi4eE3v3mA+KaHUpg3bxABi3+dvP8kvaJraZWZC+QsGXgCQx5K/84N4jc868Ir4w4tdW+1xfepbQoJoNvpwul5jci3OJahvuLcrO2Dl+2fZkH1Wr49ed1RbzTe9/73jYe6+jgAxA+piZjN9kqVr+HXeU8d++32cy+/tFSvu4FweMIl+Pe5WBMpM33TIw8z8R2tqCShe/h8tI1Df/Z7upYm529oq3uqJb5vZVNIALwxdACwHq8QSZj3iHu//Aw0g2VuBKjv0CjcwBca3k9axB2hoO3cVLVWiynkd0hzFwchsO32hplyGYu+jteTZFPJeY2xcbXq5aMnHyiVKwnXTwQk2D+tRXM5PY22CxZwhxHDu/jBf/Cq3WNv9Ad8MMZ/bqzzw1gm8I0XyRtFEJKxxYBodPm3ZciSsxsXzwetZPChjhTyf+ZM4UWB/nxb/Lv/8utPf4MpDeDY6fwQQGAcNyCImlGRw4ePQudoOzIIOwHNvTy1U4JoJR4vWACXuEal8kghAaDqlhrL8Qbl3LxO+Xm8yIT3RzeQKRcrWjhff3ygUGiClZjREn7QisZQD2tDb21u3otrYsK5z1++lmVtH4SgmA5884kRihgFu3jhwm6vS6PRFjYWf+gAoS9JDhHCesDVcjrdgW5HwM3WuXdPWMb58H0nqT/rznLAuRj/n2MdNHPpaiiz1tIqFtLbHrP+6KPsLQMSoBnWwpV8nHdiqs3de8AF6LbH4RIJcHO/65Qbnpk+IKQgHifYO53C7ND6mp2igr6THpwUHUYjkJGg3xYrFhutlTdmnoKQFBLA9vbWp3/z0wwCJL25Q1j25BzB3vjxBbMSchnN4NZXCLUM61UXf9YPlEFkuD/pXJ5kks+fv3ivOsRfunwZrUju74ZRw2gJh/YQ8cejwVKjUS1VsQpHEyEa0Sae8uxB/14wtII/1a1tlZrz1yEgHU9Fp9/tdFCFeXXxUmFwoQrL6KCF5I2Wn3zyK7cNbS61Wn/ygz/L5C3ePQ5hGPzlhjGFanOHYSDT3osHktvZ8xeYxoAUhCcsVIAxi6fhhx7hELM8V1dtFJHPIYPQgUQKINDJoEwqffXK5Xvx2f/IOqeQAHhmbdgx7M+vLC2BriuS81p9yxj34oW/DtOdbueVV15IqIZ+ACmICe98sSkMQwOhQf6R7Xk3RoD6Xzp7PlPA5TMGwu0E6BanLArELRwlEnWffo/m0NAbyI/OT2LAjNBtt7/21XvHCeqHeQnpJIByuYrexttLRnfQYvnjwzvGtMlLZbVxSeH1x6Nrh+w1glwG4t8IJGGjihdeeOn1ce+xK4b2OgA7n2eRCXxhsfvQoeEVoue/lM1OZMWCeoDPDx3QVjaE/EGDEdKSG+Gk8UgnAawfOVqoVGF4glzJhw5fS6iwF+CGwtJve6GHjh1hlVzuoy7SA0g/riKa77aZBP+DzoK/Lc+75BIp6NkXXmQzHB6ec7ZC0ifKTRLYRAmicEGLhOBhAdFmNhP/nvPPxes6y7vksf4DVCOdBHBha8sdUuFeUABvTs9ODUBAX0s+C0djKi2Wbm0/+oURGw7h7ZPNup2qvpCuPVKslK/v7esccY8fe/vtbLHsUAhOfiPWcxkx35mZD2AcTsF8+OAUwj2hANUADtqFTTILLGQqHaTvSCcB4LXPDom8MiyYfAcR+C552qI9eobZHuxUd+vrpIt/68MPwhx5z8yiZEUS7gKOXLG407lnJsHc+kS3ncPxt9uXy7WywAbyUDqrI44GbACo6d/B8tdBPJylaDr5hg5ybxgzuS3/e/QynQTAwC1jwcz9C3bmj+9RQMeyhplpqVo78eAjt76z+44edY/IEH6YRuBoEClQl0vVCxcv3RrzXj1HFT51mc6Q5kDkQfrnG1U/pDsuaRwJAJuvDAPJn0/8cMoKkWE6vlcf/d9T73QSAA/MDABmP+kBrCjjcJiCLKf+5zZ3tn/rd37n1nY5fnhNv193mR4PlX+I7hyAF0+dYoL5rTHv3fNOd3hucztfYm9wSSDBONu2ahkF+fJ4nttHlxRiRCCuIY9uLC587z769615OgmA/po9etF8A8l0A7p1wdeY2+4Dy+GyOI3ebJW1ldW3nDwx7PfARX80ifEvFqZ1aagXX3lZqKTlYP9MllDUJoD9hyObZQPj4Wigyh/P6Bg4j6vk723+GEVuXX+xMLm3zQDxcHf4SicBIP+wr7pwZ2ZvaAC8UCxA2H3YxTHpEMLYPW+Rn/nZn6lV2AlrPJhMWPyQqDgN4E+6295nH/Y7NNs9G8SO9pevbTMpFLUeGQiAo/kz90uWIPOXCjhLaJ5vyKKUz/y7M6M9dpBM45FOAuAFMn8lmBqvDT7O4ft1IEzu5vyAeNfzV3rt7On2zjaCATMAoQF2YWetWVaJ2rp4zXnx6TouXb7GMOGAZ2RhYPqCzKzT6ToPOMRDF6qWW8gfoARajb6gjUacrka4+TTpJABG+LHdawCKtyo/8wU6KTCBM+ui3WrWuL61XT9yX6HR7DDo5XKI43F2+Mqlqy+ev1f9f26+4Dee9Af9S5tbjJR32fLFvWFyGEOHA/iFXELJJzoCNKggg5CFEnnpjXnd+yEpXBWCl4IAtPTIw+evnOdcx554s7xP2D7qMPSQc9cLXvj8ePXipT988dXpaLC5sUE/UMr2epPdsxfCe/5GnDT9Xrx6dXXl0SnT3YejSujELP3QqFdoIjwB5Re2lZRgy/H7WlOlqRl8lnQSQHtv74uf/czxVq2jQE9n7jJXAB9x3hWPsXrvdBjsvfVlPvnkk7depvscTeDZ77240qqv1+rVerVUzrMoXJ/Vg1yy3YNRRA1nc/kApSmdkgJPmk4CwMbNqqDZpTpPCPDZTShxZCmg9jm1aTZYXpsybzhV+q3A/cEPeP/VjZ2N7G7+8rVCqfSJ9/+xfA/zL6xCtp9Ijvxy4ayIXDpxwgOmlrKz+L3wcPE6oxdP+nKXSmYTxIe2Nqtv8AXyxR+wY+4gzbYx1ZrzxTyU/cW95lD+JAYbM6VHagmA2V6JudOX6Wv0wDkOgzc3/uDUq3t3/Rr/SZ1/At/DweD5F15ALY6yNBdIBME8oAD2AGSbjJ9ANf6TFJFaAsDSF9I/CoDmPTWAcPPkG/W3XSqk1a73I8AItj+EHdBScgqaLXrL6DftEmix1OI/vSKQMxkTcVZ+lrxMOJn6HaYg9kj9EYCS4iRsm8BC2DRPWAZk+FrMboaklwJSK9sx0ul8J728gq8FeO3XdQLQ1JdiNP8Ij5aI/yTEIUp2ETKPbCO2yXF2REqP1IpAyLW6OyZeL04BF/G6xwXy07jM64+F0BLbBofRgIZC6QX/SePZfvSaDhin80gtAYxY54YVjwP3rmsSB9eod9o0Cqx9sjhea4FSs8UC2tj+GfNF+KHZQhWAFKalfIFddV6Lmq6z1BJAs9liXUsGdORdcDCGBjwN6Zb1D1M6w/VHBuf6iRPwBVwHaSWmCIeImAwe0ouOc93Oj5zzXZ4wtQRQqSyxEm7YfmT+UAAbw0ACujf0+svXN+7yF/MTrh4D4Rs72/iNsHCEc4TtKNGd5B+MFnYr8y0lf8K1+gkUl1olmA2qM7WWk3vxgGAC/HSqP69eQXkmAw42N38CjXsPFcGuYVgNsuEewpoRyD8MACMI5dg7NVNt1BxTT+WR2h7gmWeeyRWrzZVVNkuc5XNTVrfJF9kHbpYvLJ048Za//JdT+Tp/5Idi2KTRbFZr1QoL5rGEAH0mfQFcYzwpVNgvJ7WjJqntAU6cOLG0tLxx6TxrgLD8B3Y81oVgFXymQ12+eunLv/+5HxkrqUyImQxXuF6XmTFaRJkXyt5K7IqZc0Od7NUrV1L51DxUOnsAxm0+8oH3vflNby6z/cl0kowJ86xM7xqzEFp/eOLQWgwQp/W1/tDPdWRpqYTSC39gqhB76pQroH80ne33BvudzjLdQkrHwtJJALVa5d1ve9POxXMPLDfe8sCJlUa9nM/D/uuVcqlU7nT2jx1eZ63MHxomKU0A1h9/9OFGo3bk6LFiLJfEqhrY0NhicLlaZjnFtz/2KJsNpvLp00kAw8H45e++cvHiGaRYBvmZIM8LZfMrPF5YDI2d8sb9XjI0lsqX+sM+FHsKtsqldnufOUJHjxxZXVmuFvNry60HTz6wvro6Yy3F8eDo0aM/bLb3RPx0kvU73vGO4aBz8eJFJkbiEzFi28fxJFcstRpLSyvr/T6ybvueeD0/mUpi86SN2rt7QJ1l5YesnNhlilifrVFjY23GU6Yn1tbOnneGXcqOdBJAs4FJo1kqlYrwfDc8ZXhHl8bJaNhv76AM1Gu1W6dEpuyl/rCPg7mThfHYXhkdaW9na8DWqi6NyrK5o2qtUY9B4nHiJvfDZn3Xx0+nCPTkV79SrparS0t53mqpVGE7pFKhOJsOh7399i7v+8Lmrg7AiyNagDnxL5y5kEdQZMnIQhHtCGMom2KUiuWCq4LmO5PxtZ29VLZWOnsA5gL0i+1DR05c39zeZ+0DuoFY9aOYyVWKFcb8WQ0KMlgcN1tgNhjmCuX9/j7L4KEJOAjMSEB2WsoNm+XxxdPnT585ezNymk7S2QMMu+NzT57eunph0G2zxic7BbDKOctBMyjGbnAoBZr7UmrX+xHQyUywtUaD0S52UUZW7PaGeyhJjAW4RAQ7zE8ee+QRDAk/Qs53f5J0EkClVn3/h95z9Nh9K6us+Mly4Fj/3f+dBZBZ9Lbd7h5eO1Qsle7+1/OTqSHQfqxSWj68evjwYbQjNoRknbxGrdqsVdkwodPujvfaJ9YP/WQq8xMuJZ0EQCNudjvLh9afeMe7V9aPlGv1SrXOyNfO7t7e3i53R/0+PfxPuK3v2uJYJPWZYr4YK2SxJTAcg/Fgl1PFfQRDQpk7mdWl5bu2/j9OxdKpA/AGd7Z2Xv7ucwM2ghuPUIJZIZT1scpIQdUaG6PjERTTJH+cpktPWkxAy9X6sNvDera/t8dcSCbI4xA6Go2LhTGrrBYxji630vPAtzxJSnuA6bTJwv7NJmskDns9DNsT9rxgfSxGw1jmIF+8eG2Dt3tLOxzoU/bO2NvbH44m2AuaEEG9xkIobJMzGA27agLTQqk83zAmde2Uzh6AVS+/eursoyeOjafbWTZDyhZwB2IjuGSpCDZMYnBgMRJ8E8zIPN0+neWs026zMDCDAIV8toTvCD4SiEClIlvmPPXU12/GT9NJOnsALJzPnzk/xZWxXBvNcux4Tbce85yQ/GcsiH8+jYOaPw4uXz13gX0RcBKhpWD/7KHGx81mg2vs7u+74Wwaj3Q+FW/q2rVrODbqzat2l3MoWP92ZsNPq/X6YgzgNjCXSqNHHt3L5oowfTZRxlamtywKMWfFwqWLl9lb8rYk6bhMLQEA+CubW7xO3yNKsdCfsQo+TO3UmbOLYeDb4NvuTp7+drdaqxRBPPzCbeIZDXNpIDypru/s3BY/NZepJQA41rWNzXKljKcXnH+k7KNT0AyaqFS09C2OW1oA9vDquV3WEnMdUHiGKpLLArkwUDa7nV4CSKcSnLzZ3W5Pxdd3CfhdGoLdXpj2evrMmSTC4vvWFtja3mQ7MPtJ4c/aAbSZBLF7y2Zqt8ZPx3lqewBez3e/971Xz57LFov4Qg+nk85g0OcbR4iUirM/JiIZKT/Fjjg5XEWcFs90MJfWy2QvX76CnfTHzPyuTZ50c3dt9X7ciqHQPXL//UeOHdnY3Fxaap29cOnSlasLA+j3a9Yj64feevxYL7ZOwghUyRauj4avnDm7IIDv12L3Rjjb/fIKmRrGTI97o8b/6WqJElxvNmmrMiuibLevxwqr/+mqsyh50QKLFli0wKIFFi2waIFFCyxaYNECixZYtMCiBRYtsGiBRQssWmDRAosWWLTAogUWLbBogUULLFpg0QKLFli0wKIFFi2waIFFCyxaYNECixZYtMCiBRYtsGiBRQssWmDRAosWWLTAogUWLbBogUULLFpg0QKLFli0wKIFFi2waIFFCyxaYNECixY44C3w/wNA8fTTj5VflAAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from PIL import Image\n", + "sample_path = SOURCES_DIR / 'examples' / 'chair.png'\n", + "assert sample_path.exists(), f'sample faltante: {sample_path}'\n", + "img = Image.open(sample_path).convert('RGB')\n", + "print('imagen:', img.size, img.mode)\n", + "img.thumbnail((256, 256))\n", + "img" + ] + }, + { + "cell_type": "markdown", + "id": "4655363d", + "metadata": {}, + "source": [ + "## C. Inferencia + medicion" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b74bdd6c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[0;93m2026-05-28 22:42:08.349174846 [W:onnxruntime:Default, device_discovery.cc:283 GetGpuDevices] Failed to detect devices under \"/sys/class/drm/card0\": device_discovery.cc:93 ReadFileContents Failed to open file: \"/sys/class/drm/card0/device/vendor\"\u001b[m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: cuda\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "load: 5.52s\n" + ] + } + ], + "source": [ + "import time, torch\n", + "from tsr.system import TSR\n", + "\n", + "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n", + "print('device:', DEVICE)\n", + "\n", + "t0 = time.perf_counter()\n", + "model = TSR.from_pretrained('stabilityai/TripoSR', config_name='config.yaml', weight_name='model.ckpt')\n", + "model.renderer.set_chunk_size(8192)\n", + "model.to(DEVICE)\n", + "print(f'load: {time.perf_counter() - t0:.2f}s')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "44f7763f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tsr.utils import remove_background, resize_foreground\n", + "from rembg import new_session\n", + "import numpy as np\n", + "\n", + "rembg_session = new_session()\n", + "raw = Image.open(sample_path)\n", + "fg = remove_background(raw, rembg_session)\n", + "fg = resize_foreground(fg, 0.85)\n", + "\n", + "# Composite RGBA -> RGB sobre gris 0.5 (preprocesado canonico TripoSR run.py).\n", + "# Sin esto el tokenizer DINO recibe 4 canales y peta (expected 3).\n", + "arr = np.array(fg).astype(np.float32) / 255.0\n", + "arr = arr[:, :, :3] * arr[:, :, 3:4] + (1 - arr[:, :, 3:4]) * 0.5\n", + "fg = Image.fromarray((arr * 255.0).astype(np.uint8))\n", + "\n", + "fg_disp = fg.copy(); fg_disp.thumbnail((384, 384))\n", + "fg_disp" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e5f8382b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idxinference_svram_peak_gb
0015.59521.12
1124.10621.12
2215.32721.14
\n", + "
" + ], + "text/plain": [ + " idx inference_s vram_peak_gb\n", + "0 0 15.595 21.12\n", + "1 1 24.106 21.12\n", + "2 2 15.327 21.14" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.cuda.reset_peak_memory_stats()\n", + "_ = model([fg], device=DEVICE)\n", + "torch.cuda.synchronize()\n", + "\n", + "runs = []\n", + "for i in range(3):\n", + " torch.cuda.reset_peak_memory_stats()\n", + " t0 = time.perf_counter()\n", + " scene_codes = model([fg], device=DEVICE)\n", + " torch.cuda.synchronize()\n", + " dt = time.perf_counter() - t0\n", + " peak = torch.cuda.max_memory_allocated() / 1e9\n", + " runs.append({'idx': i, 'inference_s': round(dt, 3), 'vram_peak_gb': round(peak, 2)})\n", + "\n", + "import pandas as pd\n", + "pd.DataFrame(runs)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1d0a4ddf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "extract_mesh: 3.08s\n", + "vertices: 23,358\n", + "faces: 46,720\n" + ] + } + ], + "source": [ + "t0 = time.perf_counter()\n", + "meshes = model.extract_mesh(scene_codes, has_vertex_color=False, resolution=192)\n", + "dt_mesh = time.perf_counter() - t0\n", + "mesh = meshes[0]\n", + "print(f'extract_mesh: {dt_mesh:.2f}s')\n", + "print(f'vertices: {len(mesh.vertices):,}')\n", + "print(f'faces: {len(mesh.faces):,}')" + ] + }, + { + "cell_type": "markdown", + "id": "0a001b76", + "metadata": {}, + "source": [ + "## D. Mesh stats" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "12e5c907", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'n_vertices': 23358,\n", + " 'n_faces': 46720,\n", + " 'watertight': True,\n", + " 'area': 1.4886255298483926,\n", + " 'bounds': [[-0.4964459240436554, -0.27947795391082764, -0.30450111627578735],\n", + " [0.5693031549453735, 0.2906055450439453, 0.29652678966522217]],\n", + " 'euler': -2}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import trimesh, numpy as np\n", + "tm = trimesh.Trimesh(vertices=np.asarray(mesh.vertices), faces=np.asarray(mesh.faces), process=True)\n", + "stats = {\n", + " 'n_vertices': len(tm.vertices),\n", + " 'n_faces': len(tm.faces),\n", + " 'watertight': bool(tm.is_watertight),\n", + " 'area': float(tm.area),\n", + " 'bounds': tm.bounds.tolist(),\n", + " 'euler': int(tm.euler_number),\n", + "}\n", + "stats" + ] + }, + { + "cell_type": "markdown", + "id": "47ba64fb", + "metadata": {}, + "source": [ + "## E. Export GLB" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bf14e846", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved: /home/lucas/vaults/imagegen_models/image_to_3d/triposr/smoke_20260528_224618.glb (822.0 KB)\n", + "roundtrip: 23,358 verts / 46,720 faces\n" + ] + } + ], + "source": [ + "from datetime import datetime\n", + "out_path = VAULT_DIR / f'smoke_{datetime.now():%Y%m%d_%H%M%S}.glb'\n", + "tm.export(out_path)\n", + "size_kb = out_path.stat().st_size / 1024\n", + "print(f'saved: {out_path} ({size_kb:.1f} KB)')\n", + "\n", + "roundtrip = trimesh.load(out_path, force='mesh')\n", + "print(f'roundtrip: {len(roundtrip.vertices):,} verts / {len(roundtrip.faces):,} faces')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..b91ee92 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,28 @@ +[project] +name = "spike-image-to-3d" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.13" +dependencies = [ + "accelerate>=1.13.0", + "diffusers>=0.37.1", + "einops>=0.8.2", + "huggingface-hub<1", + "jupyter>=1.1.1", + "jupyter-collaboration>=4.4.0", + "jupyter-mcp-server>=1.0.2", + "jupyterlab>=4.5.7", + "matplotlib>=3.10.9", + "numpy>=2.4.6", + "omegaconf>=2.3.0", + "pandas>=3.0.3", + "pillow>=12.2.0", + "rembg[cpu]>=2.0.75", + "safetensors>=0.7.0", + "torch>=2.12.0", + "torchvision>=0.27.0", + "transformers==4.46.3", + "trimesh>=4.12.2", + "xatlas>=0.0.11", +] diff --git a/run-jupyter-lab.sh b/run-jupyter-lab.sh new file mode 100755 index 0000000..0739b68 --- /dev/null +++ b/run-jupyter-lab.sh @@ -0,0 +1,50 @@ +#!/bin/bash +# Jupyter Lab — modo colaborativo con autodeteccion de puerto +# Generado por write_jupyter_launcher (fn_registry) + +find_free_port() { + for port in 8888 8889 8890 8891 8892 8893 8894 8895 8896 8897 8898 8899; do + if ! ss -tln 2>/dev/null | grep -q ":${port} " && \ + ! lsof -i:"$port" >/dev/null 2>&1; then + echo $port + return + fi + done + echo 8888 +} + +PORT=${1:-$(find_free_port)} +cd "$(dirname "$0")" + +echo $PORT > .jupyter-port + +source .venv/bin/activate 2>/dev/null || true + +# IPython startup: cargar .ipython/ local (FN_REGISTRY_ROOT, helpers, sys.path) +if [ -d "$(pwd)/.ipython" ]; then + export IPYTHONDIR="$(pwd)/.ipython" +fi + +if ! python -c "import jupyter_collaboration" 2>/dev/null; then + echo "ERROR: jupyter-collaboration no esta instalado" + echo "Instala con: uv add jupyter-collaboration" + exit 1 +fi + +echo "════════════════════════════════════════════════" +echo " Jupyter Lab + Colaboracion en puerto $PORT" +echo "════════════════════════════════════════════════" +echo "" +echo " Abre: http://localhost:$PORT" +echo " Ctrl+C para detener" +echo "" + +jupyter lab \ + --port=$PORT \ + --no-browser \ + --ServerApp.token='' \ + --ServerApp.password='' \ + --ServerApp.disable_check_xsrf=True \ + --ServerApp.allow_origin='*' \ + --ServerApp.root_dir="$(pwd)" \ + --collaborative diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..e185d83 --- /dev/null +++ b/uv.lock @@ -0,0 +1,3997 @@ +version = 1 +revision = 3 +requires-python = ">=3.13" +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] + +[[package]] +name = "accelerate" +version = "1.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyyaml" }, + { name = "safetensors" }, + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/14/787e5498cd062640f0f3d92ef4ae4063174f76f9afd29d13fc52a319daae/accelerate-1.13.0.tar.gz", hash = "sha256:d631b4e0f5b3de4aff2d7e9e6857d164810dfc3237d54d017f075122d057b236", size = 402835, upload-time = "2026-03-04T19:34:12.359Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/46/02ac5e262d4af18054b3e922b2baedbb2a03289ee792162de60a865defc5/accelerate-1.13.0-py3-none-any.whl", hash = "sha256:cf1a3efb96c18f7b152eb0fa7490f3710b19c3f395699358f08decca2b8b62e0", size = 383744, upload-time = "2026-03-04T19:34:10.313Z" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/c6/61a2d7b7572279226bb2e7f61d7a19ca7c90da0329c93fa0d560cbf288d8/aiohappyeyeballs-2.6.2.tar.gz", hash = "sha256:e202810ee718bd01fc6ef49e8ea53d023d5cb6b581076d7925aa499fa55dbe64", size = 22591, upload-time = "2026-05-20T15:12:24.631Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/fc/a7bf5b6e4e617b45f90f2d9d2a68519c249c81dd4fc2658c7a2a61c4f4b7/aiohappyeyeballs-2.6.2-py3-none-any.whl", hash = "sha256:4708045e2d7a6c6bdf8aafa8ed39649eaf926a4543b54560659129e3365953c4", size = 15062, upload-time = "2026-05-20T15:12:23.328Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/e9/d76bf503005709e390122d34e15256b88f7008e246c4bdbe915cd4f1adce/aiohttp-3.13.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5029cc80718bbd545123cd8fe5d15025eccaaaace5d0eeec6bd556ad6163d61", size = 742930, upload-time = "2026-03-31T21:58:13.155Z" }, + { url = "https://files.pythonhosted.org/packages/57/00/4b7b70223deaebd9bb85984d01a764b0d7bd6526fcdc73cca83bcbe7243e/aiohttp-3.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bb6bf5811620003614076bdc807ef3b5e38244f9d25ca5fe888eaccea2a9832", size = 496927, upload-time = "2026-03-31T21:58:15.073Z" }, + { url = "https://files.pythonhosted.org/packages/9c/f5/0fb20fb49f8efdcdce6cd8127604ad2c503e754a8f139f5e02b01626523f/aiohttp-3.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a84792f8631bf5a94e52d9cc881c0b824ab42717165a5579c760b830d9392ac9", size = 497141, upload-time = "2026-03-31T21:58:17.009Z" }, + { url = "https://files.pythonhosted.org/packages/3b/86/b7c870053e36a94e8951b803cb5b909bfbc9b90ca941527f5fcafbf6b0fa/aiohttp-3.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57653eac22c6a4c13eb22ecf4d673d64a12f266e72785ab1c8b8e5940d0e8090", size = 1732476, upload-time = "2026-03-31T21:58:18.925Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e5/4e161f84f98d80c03a238671b4136e6530453d65262867d989bbe78244d0/aiohttp-3.13.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5e5f7debc7a57af53fdf5c5009f9391d9f4c12867049d509bf7bb164a6e295b", size = 1706507, upload-time = "2026-03-31T21:58:21.094Z" }, + { url = "https://files.pythonhosted.org/packages/d4/56/ea11a9f01518bd5a2a2fcee869d248c4b8a0cfa0bb13401574fa31adf4d4/aiohttp-3.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c719f65bebcdf6716f10e9eff80d27567f7892d8988c06de12bbbd39307c6e3a", size = 1773465, upload-time = "2026-03-31T21:58:23.159Z" }, + { url = "https://files.pythonhosted.org/packages/eb/40/333ca27fb74b0383f17c90570c748f7582501507307350a79d9f9f3c6eb1/aiohttp-3.13.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d97f93fdae594d886c5a866636397e2bcab146fd7a132fd6bb9ce182224452f8", size = 1873523, upload-time = "2026-03-31T21:58:25.59Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d2/e2f77eef1acb7111405433c707dc735e63f67a56e176e72e9e7a2cd3f493/aiohttp-3.13.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df334e39d4c2f899a914f1dba283c1aadc311790733f705182998c6f7cae665", size = 1754113, upload-time = "2026-03-31T21:58:27.624Z" }, + { url = "https://files.pythonhosted.org/packages/fb/56/3f653d7f53c89669301ec9e42c95233e2a0c0a6dd051269e6e678db4fdb0/aiohttp-3.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe6970addfea9e5e081401bcbadf865d2b6da045472f58af08427e108d618540", size = 1562351, upload-time = "2026-03-31T21:58:29.918Z" }, + { url = "https://files.pythonhosted.org/packages/ec/a6/9b3e91eb8ae791cce4ee736da02211c85c6f835f1bdfac0594a8a3b7018c/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7becdf835feff2f4f335d7477f121af787e3504b48b449ff737afb35869ba7bb", size = 1693205, upload-time = "2026-03-31T21:58:32.214Z" }, + { url = "https://files.pythonhosted.org/packages/98/fc/bfb437a99a2fcebd6b6eaec609571954de2ed424f01c352f4b5504371dd3/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:676e5651705ad5d8a70aeb8eb6936c436d8ebbd56e63436cb7dd9bb36d2a9a46", size = 1730618, upload-time = "2026-03-31T21:58:34.728Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b6/c8534862126191a034f68153194c389addc285a0f1347d85096d349bbc15/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:9b16c653d38eb1a611cc898c41e76859ca27f119d25b53c12875fd0474ae31a8", size = 1745185, upload-time = "2026-03-31T21:58:36.909Z" }, + { url = "https://files.pythonhosted.org/packages/0b/93/4ca8ee2ef5236e2707e0fd5fecb10ce214aee1ff4ab307af9c558bda3b37/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:999802d5fa0389f58decd24b537c54aa63c01c3219ce17d1214cbda3c2b22d2d", size = 1557311, upload-time = "2026-03-31T21:58:39.38Z" }, + { url = "https://files.pythonhosted.org/packages/57/ae/76177b15f18c5f5d094f19901d284025db28eccc5ae374d1d254181d33f4/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ec707059ee75732b1ba130ed5f9580fe10ff75180c812bc267ded039db5128c6", size = 1773147, upload-time = "2026-03-31T21:58:41.476Z" }, + { url = "https://files.pythonhosted.org/packages/01/a4/62f05a0a98d88af59d93b7fcac564e5f18f513cb7471696ac286db970d6a/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d6d44a5b48132053c2f6cd5c8cb14bc67e99a63594e336b0f2af81e94d5530c", size = 1730356, upload-time = "2026-03-31T21:58:44.049Z" }, + { url = "https://files.pythonhosted.org/packages/e4/85/fc8601f59dfa8c9523808281f2da571f8b4699685f9809a228adcc90838d/aiohttp-3.13.5-cp313-cp313-win32.whl", hash = "sha256:329f292ed14d38a6c4c435e465f48bebb47479fd676a0411936cc371643225cc", size = 432637, upload-time = "2026-03-31T21:58:46.167Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1b/ac685a8882896acf0f6b31d689e3792199cfe7aba37969fa91da63a7fa27/aiohttp-3.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:69f571de7500e0557801c0b51f4780482c0ec5fe2ac851af5a92cfce1af1cb83", size = 458896, upload-time = "2026-03-31T21:58:48.119Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ce/46572759afc859e867a5bc8ec3487315869013f59281ce61764f76d879de/aiohttp-3.13.5-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:eb4639f32fd4a9904ab8fb45bf3383ba71137f3d9d4ba25b3b3f3109977c5b8c", size = 745721, upload-time = "2026-03-31T21:58:50.229Z" }, + { url = "https://files.pythonhosted.org/packages/13/fe/8a2efd7626dbe6049b2ef8ace18ffda8a4dfcbe1bcff3ac30c0c7575c20b/aiohttp-3.13.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:7e5dc4311bd5ac493886c63cbf76ab579dbe4641268e7c74e48e774c74b6f2be", size = 497663, upload-time = "2026-03-31T21:58:52.232Z" }, + { url = "https://files.pythonhosted.org/packages/9b/91/cc8cc78a111826c54743d88651e1687008133c37e5ee615fee9b57990fac/aiohttp-3.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:756c3c304d394977519824449600adaf2be0ccee76d206ee339c5e76b70ded25", size = 499094, upload-time = "2026-03-31T21:58:54.566Z" }, + { url = "https://files.pythonhosted.org/packages/0a/33/a8362cb15cf16a3af7e86ed11962d5cd7d59b449202dc576cdc731310bde/aiohttp-3.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecc26751323224cf8186efcf7fbcbc30f4e1d8c7970659daf25ad995e4032a56", size = 1726701, upload-time = "2026-03-31T21:58:56.864Z" }, + { url = "https://files.pythonhosted.org/packages/45/0c/c091ac5c3a17114bd76cbf85d674650969ddf93387876cf67f754204bd77/aiohttp-3.13.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10a75acfcf794edf9d8db50e5a7ec5fc818b2a8d3f591ce93bc7b1210df016d2", size = 1683360, upload-time = "2026-03-31T21:58:59.072Z" }, + { url = "https://files.pythonhosted.org/packages/23/73/bcee1c2b79bc275e964d1446c55c54441a461938e70267c86afaae6fba27/aiohttp-3.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f7a18f258d124cd678c5fe072fe4432a4d5232b0657fca7c1847f599233c83a", size = 1773023, upload-time = "2026-03-31T21:59:01.776Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ef/720e639df03004fee2d869f771799d8c23046dec47d5b81e396c7cda583a/aiohttp-3.13.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:df6104c009713d3a89621096f3e3e88cc323fd269dbd7c20afe18535094320be", size = 1853795, upload-time = "2026-03-31T21:59:04.568Z" }, + { url = "https://files.pythonhosted.org/packages/bd/c9/989f4034fb46841208de7aeeac2c6d8300745ab4f28c42f629ba77c2d916/aiohttp-3.13.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:241a94f7de7c0c3b616627aaad530fe2cb620084a8b144d3be7b6ecfe95bae3b", size = 1730405, upload-time = "2026-03-31T21:59:07.221Z" }, + { url = "https://files.pythonhosted.org/packages/ce/75/ee1fd286ca7dc599d824b5651dad7b3be7ff8d9a7e7b3fe9820d9180f7db/aiohttp-3.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c974fb66180e58709b6fc402846f13791240d180b74de81d23913abe48e96d94", size = 1558082, upload-time = "2026-03-31T21:59:09.484Z" }, + { url = "https://files.pythonhosted.org/packages/c3/20/1e9e6650dfc436340116b7aa89ff8cb2bbdf0abc11dfaceaad8f74273a10/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6e27ea05d184afac78aabbac667450c75e54e35f62238d44463131bd3f96753d", size = 1692346, upload-time = "2026-03-31T21:59:12.068Z" }, + { url = "https://files.pythonhosted.org/packages/d8/40/8ebc6658d48ea630ac7903912fe0dd4e262f0e16825aa4c833c56c9f1f56/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a79a6d399cef33a11b6f004c67bb07741d91f2be01b8d712d52c75711b1e07c7", size = 1698891, upload-time = "2026-03-31T21:59:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/d8/78/ea0ae5ec8ba7a5c10bdd6e318f1ba5e76fcde17db8275188772afc7917a4/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c632ce9c0b534fbe25b52c974515ed674937c5b99f549a92127c85f771a78772", size = 1742113, upload-time = "2026-03-31T21:59:17.068Z" }, + { url = "https://files.pythonhosted.org/packages/8a/66/9d308ed71e3f2491be1acb8769d96c6f0c47d92099f3bc9119cada27b357/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fceedde51fbd67ee2bcc8c0b33d0126cc8b51ef3bbde2f86662bd6d5a6f10ec5", size = 1553088, upload-time = "2026-03-31T21:59:19.541Z" }, + { url = "https://files.pythonhosted.org/packages/da/a6/6cc25ed8dfc6e00c90f5c6d126a98e2cf28957ad06fa1036bd34b6f24a2c/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f92995dfec9420bb69ae629abf422e516923ba79ba4403bc750d94fb4a6c68c1", size = 1757976, upload-time = "2026-03-31T21:59:22.311Z" }, + { url = "https://files.pythonhosted.org/packages/c1/2b/cce5b0ffe0de99c83e5e36d8f828e4161e415660a9f3e58339d07cce3006/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20ae0ff08b1f2c8788d6fb85afcb798654ae6ba0b747575f8562de738078457b", size = 1712444, upload-time = "2026-03-31T21:59:24.635Z" }, + { url = "https://files.pythonhosted.org/packages/6c/cf/9e1795b4160c58d29421eafd1a69c6ce351e2f7c8d3c6b7e4ca44aea1a5b/aiohttp-3.13.5-cp314-cp314-win32.whl", hash = "sha256:b20df693de16f42b2472a9c485e1c948ee55524786a0a34345511afdd22246f3", size = 438128, upload-time = "2026-03-31T21:59:27.291Z" }, + { url = "https://files.pythonhosted.org/packages/22/4d/eaedff67fc805aeba4ba746aec891b4b24cebb1a7d078084b6300f79d063/aiohttp-3.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:f85c6f327bf0b8c29da7d93b1cabb6363fb5e4e160a32fa241ed2dce21b73162", size = 464029, upload-time = "2026-03-31T21:59:29.429Z" }, + { url = "https://files.pythonhosted.org/packages/79/11/c27d9332ee20d68dd164dc12a6ecdef2e2e35ecc97ed6cf0d2442844624b/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:1efb06900858bb618ff5cee184ae2de5828896c448403d51fb633f09e109be0a", size = 778758, upload-time = "2026-03-31T21:59:31.547Z" }, + { url = "https://files.pythonhosted.org/packages/04/fb/377aead2e0a3ba5f09b7624f702a964bdf4f08b5b6728a9799830c80041e/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fee86b7c4bd29bdaf0d53d14739b08a106fdda809ca5fe032a15f52fae5fe254", size = 512883, upload-time = "2026-03-31T21:59:34.098Z" }, + { url = "https://files.pythonhosted.org/packages/bb/a6/aa109a33671f7a5d3bd78b46da9d852797c5e665bfda7d6b373f56bff2ec/aiohttp-3.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:20058e23909b9e65f9da62b396b77dfa95965cbe840f8def6e572538b1d32e36", size = 516668, upload-time = "2026-03-31T21:59:36.497Z" }, + { url = "https://files.pythonhosted.org/packages/79/b3/ca078f9f2fa9563c36fb8ef89053ea2bb146d6f792c5104574d49d8acb63/aiohttp-3.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cf20a8d6868cb15a73cab329ffc07291ba8c22b1b88176026106ae39aa6df0f", size = 1883461, upload-time = "2026-03-31T21:59:38.723Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e3/a7ad633ca1ca497b852233a3cce6906a56c3225fb6d9217b5e5e60b7419d/aiohttp-3.13.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:330f5da04c987f1d5bdb8ae189137c77139f36bd1cb23779ca1a354a4b027800", size = 1747661, upload-time = "2026-03-31T21:59:41.187Z" }, + { url = "https://files.pythonhosted.org/packages/33/b9/cd6fe579bed34a906d3d783fe60f2fa297ef55b27bb4538438ee49d4dc41/aiohttp-3.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f1cbf0c7926d315c3c26c2da41fd2b5d2fe01ac0e157b78caefc51a782196cf", size = 1863800, upload-time = "2026-03-31T21:59:43.84Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3f/2c1e2f5144cefa889c8afd5cf431994c32f3b29da9961698ff4e3811b79a/aiohttp-3.13.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:53fc049ed6390d05423ba33103ded7281fe897cf97878f369a527070bd95795b", size = 1958382, upload-time = "2026-03-31T21:59:46.187Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/f31ec3f1013723b3babe3609e7f119c2c2fb6ef33da90061a705ef3e1bc8/aiohttp-3.13.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:898703aa2667e3c5ca4c54ca36cd73f58b7a38ef87a5606414799ebce4d3fd3a", size = 1803724, upload-time = "2026-03-31T21:59:48.656Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b4/57712dfc6f1542f067daa81eb61da282fab3e6f1966fca25db06c4fc62d5/aiohttp-3.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0494a01ca9584eea1e5fbd6d748e61ecff218c51b576ee1999c23db7066417d8", size = 1640027, upload-time = "2026-03-31T21:59:51.284Z" }, + { url = "https://files.pythonhosted.org/packages/25/3c/734c878fb43ec083d8e31bf029daae1beafeae582d1b35da234739e82ee7/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6cf81fe010b8c17b09495cbd15c1d35afbc8fb405c0c9cf4738e5ae3af1d65be", size = 1806644, upload-time = "2026-03-31T21:59:53.753Z" }, + { url = "https://files.pythonhosted.org/packages/20/a5/f671e5cbec1c21d044ff3078223f949748f3a7f86b14e34a365d74a5d21f/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:c564dd5f09ddc9d8f2c2d0a301cd30a79a2cc1b46dd1a73bef8f0038863d016b", size = 1791630, upload-time = "2026-03-31T21:59:56.239Z" }, + { url = "https://files.pythonhosted.org/packages/0b/63/fb8d0ad63a0b8a99be97deac8c04dacf0785721c158bdf23d679a87aa99e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2994be9f6e51046c4f864598fd9abeb4fba6e88f0b2152422c9666dcd4aea9c6", size = 1809403, upload-time = "2026-03-31T21:59:59.103Z" }, + { url = "https://files.pythonhosted.org/packages/59/0c/bfed7f30662fcf12206481c2aac57dedee43fe1c49275e85b3a1e1742294/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:157826e2fa245d2ef46c83ea8a5faf77ca19355d278d425c29fda0beb3318037", size = 1634924, upload-time = "2026-03-31T22:00:02.116Z" }, + { url = "https://files.pythonhosted.org/packages/17/d6/fd518d668a09fd5a3319ae5e984d4d80b9a4b3df4e21c52f02251ef5a32e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a8aca50daa9493e9e13c0f566201a9006f080e7c50e5e90d0b06f53146a54500", size = 1836119, upload-time = "2026-03-31T22:00:04.756Z" }, + { url = "https://files.pythonhosted.org/packages/78/b7/15fb7a9d52e112a25b621c67b69c167805cb1f2ab8f1708a5c490d1b52fe/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3b13560160d07e047a93f23aaa30718606493036253d5430887514715b67c9d9", size = 1772072, upload-time = "2026-03-31T22:00:07.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/df/57ba7f0c4a553fc2bd8b6321df236870ec6fd64a2a473a8a13d4f733214e/aiohttp-3.13.5-cp314-cp314t-win32.whl", hash = "sha256:9a0f4474b6ea6818b41f82172d799e4b3d29e22c2c520ce4357856fced9af2f8", size = 471819, upload-time = "2026-03-31T22:00:10.277Z" }, + { url = "https://files.pythonhosted.org/packages/62/29/2f8418269e46454a26171bfdd6a055d74febf32234e474930f2f60a17145/aiohttp-3.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:18a2f6c1182c51baa1d28d68fea51513cb2a76612f038853c0ad3c145423d3d9", size = 505441, upload-time = "2026-03-31T22:00:12.791Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + +[[package]] +name = "annotated-doc" +version = "0.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "antlr4-python3-runtime" +version = "4.9.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b", size = 117034, upload-time = "2021-11-06T17:52:23.524Z" } + +[[package]] +name = "anyio" +version = "4.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" }, + { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" }, + { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" }, + { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" }, + { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" }, + { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" }, + { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" }, + { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" }, + { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" }, + { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" }, + { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" }, +] + +[[package]] +name = "arrow" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, +] + +[[package]] +name = "async-lru" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/1f/989ecfef8e64109a489fff357450cb73fa73a865a92bd8c272170a6922c2/async_lru-2.3.0.tar.gz", hash = "sha256:89bdb258a0140d7313cf8f4031d816a042202faa61d0ab310a0a538baa1c24b6", size = 16332, upload-time = "2026-03-19T01:04:32.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/e2/c2e3abf398f80732e58b03be77bde9022550d221dd8781bf586bd4d97cc1/async_lru-2.3.0-py3-none-any.whl", hash = "sha256:eea27b01841909316f2cc739807acea1c623df2be8c5cfad7583286397bb8315", size = 8403, upload-time = "2026-03-19T01:04:30.883Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "babel" +version = "2.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.14.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" }, +] + +[[package]] +name = "bleach" +version = "6.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/18/3c8523962314be6bf4c8989c79ad9531c825210dd13a8669f6b84336e8bd/bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22", size = 203533, upload-time = "2025-10-27T17:57:39.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cd/3a/577b549de0cc09d95f11087ee63c739bba856cd3952697eec4c4bb91350a/bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6", size = 164437, upload-time = "2025-10-27T17:57:37.538Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2026.5.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/ce/ee2ecad540810a79593028e88299baeae54d346cc7a0d94b6199988b89b1/certifi-2026.5.20.tar.gz", hash = "sha256:69dea482ab64caa7b9f6aba1c6bf48bb6a5448d1c0f1b17ab42ad8c763a5344d", size = 135422, upload-time = "2026-05-20T11:46:50.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/59/8c/57e832b7af6d7c5abe66eb3fbe3a3a32f4d11ea23a1aa7131371035be991/certifi-2026.5.20-py3-none-any.whl", hash = "sha256:3c52e209ba0a4ad7aebe60436a4ab349c39e1e602e8c134221e546902ad25897", size = 134134, upload-time = "2026-05-20T11:46:48.578Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" }, + { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" }, + { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" }, + { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" }, + { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" }, + { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" }, + { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" }, + { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" }, + { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" }, + { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" }, + { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" }, + { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" }, + { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" }, + { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" }, + { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" }, + { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" }, +] + +[[package]] +name = "click" +version = "8.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" }, +] + +[[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, 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, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + +[[package]] +name = "cryptography" +version = "48.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/a9/db8f313fdcd85d767d4973515e1db101f9c71f95fced83233de224673757/cryptography-48.0.0.tar.gz", hash = "sha256:5c3932f4436d1cccb036cb0eaef46e6e2db91035166f1ad6505c3c9d5a635920", size = 832984, upload-time = "2026-05-04T22:59:38.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/3d/01f6dd9190170a5a241e0e98c2d04be3664a9e6f5b9b872cde63aff1c3dd/cryptography-48.0.0-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:0c558d2cdffd8f4bbb30fc7134c74d2ca9a476f830bb053074498fbc86f41ed6", size = 8001587, upload-time = "2026-05-04T22:57:36.803Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6e/e90527eef33f309beb811cf7c982c3aeffcce8e3edb178baa4ca3ae4a6fa/cryptography-48.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f5333311663ea94f75dd408665686aaf426563556bb5283554a3539177e03b8c", size = 4690433, upload-time = "2026-05-04T22:57:40.373Z" }, + { url = "https://files.pythonhosted.org/packages/90/04/673510ed51ddff56575f306cf1617d80411ee76831ccd3097599140efdfe/cryptography-48.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7995ef305d7165c3f11ae07f2517e5a4f1d5c18da1376a0a9ed496336b69e5f3", size = 4710620, upload-time = "2026-05-04T22:57:42.935Z" }, + { url = "https://files.pythonhosted.org/packages/14/d5/e9c4ef932c8d800490c34d8bd589d64a31d5890e27ec9e9ad532be893294/cryptography-48.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:40ba1f85eaa6959837b1d51c9767e230e14612eea4ef110ee8854ada22da1bf5", size = 4696283, upload-time = "2026-05-04T22:57:45.294Z" }, + { url = "https://files.pythonhosted.org/packages/0c/29/174b9dfb60b12d59ecfc6cfa04bc88c21b42a54f01b8aae09bb6e51e4c7f/cryptography-48.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:369a6348999f94bbd53435c894377b20ab95f25a9065c283570e70150d8abc3c", size = 5296573, upload-time = "2026-05-04T22:57:47.933Z" }, + { url = "https://files.pythonhosted.org/packages/95/38/0d29a6fd7d0d1373f0c0c88a04ba20e359b257753ac497564cd660fc1d55/cryptography-48.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a0e692c683f4df67815a2d258b324e66f4738bd7a96a218c826dce4f4bd05d8f", size = 4743677, upload-time = "2026-05-04T22:57:50.067Z" }, + { url = "https://files.pythonhosted.org/packages/30/be/eef653013d5c63b6a490529e0316f9ac14a37602965d4903efed1399f32b/cryptography-48.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:18349bbc56f4743c8b12dc32e2bccb2cf83ee8b69a3bba74ef8ae857e26b3d25", size = 4330808, upload-time = "2026-05-04T22:57:52.301Z" }, + { url = "https://files.pythonhosted.org/packages/84/9e/500463e87abb7a0a0f9f256ec21123ecde0a7b5541a15e840ea54551fd81/cryptography-48.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e8eac43dfca5c4cccc6dad9a80504436fca53bb9bc3100a2386d730fbe6b602", size = 4695941, upload-time = "2026-05-04T22:57:54.603Z" }, + { url = "https://files.pythonhosted.org/packages/e3/dc/7303087450c2ec9e7fbb750e17c2abfbc658f23cbd0e54009509b7cc4091/cryptography-48.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9ccdac7d40688ecb5a3b4a604b8a88c8002e3442d6c60aead1db2a89a041560c", size = 5252579, upload-time = "2026-05-04T22:57:57.207Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c0/7101d3b7215edcdc90c45da544961fd8ed2d6448f77577460fa75a8443f7/cryptography-48.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:bd72e68b06bb1e96913f97dd4901119bc17f39d4586a5adf2d3e47bc2b9d58b5", size = 4743326, upload-time = "2026-05-04T22:57:59.535Z" }, + { url = "https://files.pythonhosted.org/packages/ac/d8/5b833bad13016f562ab9d063d68199a4bd121d18458e439515601d3357ec/cryptography-48.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:59baa2cb386c4f0b9905bd6eb4c2a79a69a128408fd31d32ca4d7102d4156321", size = 4826672, upload-time = "2026-05-04T22:58:01.996Z" }, + { url = "https://files.pythonhosted.org/packages/98/e1/7074eb8bf3c135558c73fc2bcf0f5633f912e6fb87e868a55c454080ef09/cryptography-48.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9249e3cd978541d665967ac2cb2787fd6a62bddf1e75b3e347a594d7dacf4f74", size = 4972574, upload-time = "2026-05-04T22:58:03.968Z" }, + { url = "https://files.pythonhosted.org/packages/04/70/e5a1b41d325f797f39427aa44ef8baf0be500065ab6d8e10369d850d4a4f/cryptography-48.0.0-cp311-abi3-win32.whl", hash = "sha256:9c459db21422be75e2809370b829a87eb37f74cd785fc4aa9ea1e5f43b47cda4", size = 3294868, upload-time = "2026-05-04T22:58:06.467Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ac/8ac51b4a5fc5932eb7ee5c517ba7dc8cd834f0048962b6b352f00f41ebf9/cryptography-48.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:5b012212e08b8dd5edc78ef54da83dd9892fd9105323b3993eff6bea65dc21d7", size = 3817107, upload-time = "2026-05-04T22:58:08.845Z" }, + { url = "https://files.pythonhosted.org/packages/6b/84/70e3feea9feea87fd7cbe77efb2712ae1e3e6edf10749dc6e95f4e60e455/cryptography-48.0.0-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:3cb07a3ed6431663cd321ea8a000a1314c74211f823e4177fefa2255e057d1ec", size = 7986556, upload-time = "2026-05-04T22:58:11.172Z" }, + { url = "https://files.pythonhosted.org/packages/89/6e/18e07a618bb5442ba10cf4df16e99c071365528aa570dfcb8c02e25a303b/cryptography-48.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8c7378637d7d88016fa6791c159f698b3d3eed28ebf844ac36b9dc04a14dae18", size = 4684776, upload-time = "2026-05-04T22:58:13.712Z" }, + { url = "https://files.pythonhosted.org/packages/be/6a/4ea3b4c6c6759794d5ee2103c304a5076dc4b19ae1f9fe47dba439e159e9/cryptography-48.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc90c0b39b2e3c65ef52c804b72e3c58f8a04ab2a1871272798e5f9572c17d20", size = 4698121, upload-time = "2026-05-04T22:58:16.448Z" }, + { url = "https://files.pythonhosted.org/packages/2f/59/6ff6ad6cae03bb887da2a5860b2c9805f8dac969ef01ce563336c49bd1d1/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:76341972e1eff8b4bea859f09c0d3e64b96ce931b084f9b9b7db8ef364c30eff", size = 4690042, upload-time = "2026-05-04T22:58:18.544Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b4/fc334ed8cfd705aca282fe4d8f5ae64a8e0f74932e9feecb344610cf6e4d/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:55b7718303bf06a5753dcdccf2f3945cf18ad7bffde41b61226e4db31ab89a9c", size = 5282526, upload-time = "2026-05-04T22:58:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/11/08/9f8c5386cc4cd90d8255c7cdd0f5baf459a08502a09de30dc51f553d38dc/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:a64697c641c7b1b2178e573cbc31c7c6684cd56883a478d75143dbb7118036db", size = 4733116, upload-time = "2026-05-04T22:58:23.627Z" }, + { url = "https://files.pythonhosted.org/packages/b8/77/99307d7574045699f8805aa500fa0fb83422d115b5400a064ddd306d7750/cryptography-48.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:561215ea3879cb1cbbf272867e2efda62476f240fb58c64de6b393ae19246741", size = 4316030, upload-time = "2026-05-04T22:58:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/fd/36/a608b98337af3cb2aff4818e406649d30572b7031918b04c87d979495348/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:ad64688338ed4bc1a6618076ba75fd7194a5f1797ac60b47afe926285adb3166", size = 4689640, upload-time = "2026-05-04T22:58:27.747Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a6/825010a291b4438aecc1f568bc428189fc1175515223632477c07dc0a6df/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:906cbf0670286c6e0044156bc7d4af9cbb0ef6db9f73e52c3ec56ba6bdde5336", size = 5237657, upload-time = "2026-05-04T22:58:29.848Z" }, + { url = "https://files.pythonhosted.org/packages/b9/09/4e76a09b4caa29aad535ddc806f5d4c5d01885bd978bd984fbc6ca032cae/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:ea8990436d914540a40ab24b6a77c0969695ed52f4a4874c5137ccf7045a7057", size = 4732362, upload-time = "2026-05-04T22:58:32.009Z" }, + { url = "https://files.pythonhosted.org/packages/18/78/444fa04a77d0cb95f417dda20d450e13c56ba8e5220fc892a1658f44f882/cryptography-48.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c18684a7f0cc9a3cb60328f496b8e3372def7c5d2df39ac267878b05565aaaae", size = 4819580, upload-time = "2026-05-04T22:58:34.254Z" }, + { url = "https://files.pythonhosted.org/packages/38/85/ea67067c70a1fd4be2c63d35eeed82658023021affccc7b17705f8527dd2/cryptography-48.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9be5aafa5736574f8f15f262adc81b2a9869e2cfe9014d52a44633905b40d52c", size = 4963283, upload-time = "2026-05-04T22:58:36.376Z" }, + { url = "https://files.pythonhosted.org/packages/75/54/cc6d0f3deac3e81c7f847e8a189a12b6cdd65059b43dad25d4316abd849a/cryptography-48.0.0-cp314-cp314t-win32.whl", hash = "sha256:c17dfe85494deaeddc5ce251aebd1d60bbe6afc8b62071bb0b469431a000124f", size = 3270954, upload-time = "2026-05-04T22:58:38.791Z" }, + { url = "https://files.pythonhosted.org/packages/49/67/cc947e288c0758a4e5473d1dcb743037ab7785541265a969240b8885441a/cryptography-48.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27241b1dc9962e056062a8eef1991d02c3a24569c95975bd2322a8a52c6e5e12", size = 3797313, upload-time = "2026-05-04T22:58:40.746Z" }, + { url = "https://files.pythonhosted.org/packages/f2/63/61d4a4e1c6b6bab6ce1e213cd36a24c415d90e76d78c5eb8577c5541d2e8/cryptography-48.0.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:58d00498e8933e4a194f3076aee1b4a97dfec1a6da444535755822fe5d8b0b86", size = 7983482, upload-time = "2026-05-04T22:58:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ac/f5b5995b87770c693e2596559ffafe195b4033a57f14a82268a2842953f3/cryptography-48.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:614d0949f4790582d2cc25553abd09dd723025f0c0e7c67376a1d77196743d6e", size = 4683266, upload-time = "2026-05-04T22:58:46.064Z" }, + { url = "https://files.pythonhosted.org/packages/ec/c6/8b14f67e18338fbc4adb76f66c001f5c3610b3e2d1837f268f47a347dbbb/cryptography-48.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ce4bfae76319a532a2dc68f82cc32f5676ee792a983187dac07183690e5c66f", size = 4696228, upload-time = "2026-05-04T22:58:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/ea/73/f808fbae9514bd91b47875b003f13e284c8c6bdfd904b7944e803937eec1/cryptography-48.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:2eb992bbd4661238c5a397594c83f5b4dc2bc5b848c365c8f991b6780efcc5c7", size = 4689097, upload-time = "2026-05-04T22:58:50.9Z" }, + { url = "https://files.pythonhosted.org/packages/93/01/d86632d7d28db8ae83221995752eeb6639ffb374c2d22955648cf8d52797/cryptography-48.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:22a5cb272895dce158b2cacdfdc3debd299019659f42947dbdac6f32d68fe832", size = 5283582, upload-time = "2026-05-04T22:58:53.017Z" }, + { url = "https://files.pythonhosted.org/packages/02/e1/50edc7a50334807cc4791fc4a0ce7468b4a1416d9138eab358bfc9a3d70b/cryptography-48.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2b4d59804e8408e2fea7d1fbaf218e5ec984325221db76e6a241a9abd6cdd95c", size = 4730479, upload-time = "2026-05-04T22:58:55.611Z" }, + { url = "https://files.pythonhosted.org/packages/6f/af/99a582b1b1641ff5911ac559beb45097cf79efd4ead4657f578ef1af2d47/cryptography-48.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:984a20b0f62a26f48a3396c72e4bc34c66e356d356bf370053066b3b6d54634a", size = 4326481, upload-time = "2026-05-04T22:58:57.607Z" }, + { url = "https://files.pythonhosted.org/packages/90/ee/89aa26a06ef0a7d7611788ffd571a7c50e368cc6a4d5eef8b4884e866edb/cryptography-48.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5a5ed8fde7a1d09376ca0b40e68cd59c69fe23b1f9768bd5824f54681626032a", size = 4688713, upload-time = "2026-05-04T22:59:00.077Z" }, + { url = "https://files.pythonhosted.org/packages/70/ba/bcb1b0bb7a33d4c7c0c4d4c7874b4a62ae4f56113a5f4baefa362dfb1f0f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:8cd666227ef7af430aa5914a9910e0ddd703e75f039cef0825cd0da71b6b711a", size = 5238165, upload-time = "2026-05-04T22:59:02.317Z" }, + { url = "https://files.pythonhosted.org/packages/c9/70/ca4003b1ce5ca3dc3186ada51908c8a9b9ff7d5cab83cc0d43ee14ec144f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9071196d81abc88b3516ac8cdfad32e2b66dd4a5393a8e68a961e9161ddc6239", size = 4729947, upload-time = "2026-05-04T22:59:05.255Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/4ec7cf774207905aef1a8d11c3750d5a1db805eb380ee4e16df317870128/cryptography-48.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1e2d54c8be6152856a36f0882ab231e70f8ec7f14e93cf87db8a2ed056bf160c", size = 4822059, upload-time = "2026-05-04T22:59:07.802Z" }, + { url = "https://files.pythonhosted.org/packages/1e/75/a2e55f99c16fcac7b5d6c1eb19ad8e00799854d6be5ca845f9259eae1681/cryptography-48.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a5da777e32ffed6f85a7b2b3f7c5cbc88c146bfcd0a1d7baf5fcc6c52ee35dd4", size = 4960575, upload-time = "2026-05-04T22:59:09.851Z" }, + { url = "https://files.pythonhosted.org/packages/b8/23/6e6f32143ab5d8b36ca848a502c4bcd477ae75b9e1677e3530d669062578/cryptography-48.0.0-cp39-abi3-win32.whl", hash = "sha256:77a2ccbbe917f6710e05ba9adaa25fb5075620bf3ea6fb751997875aff4ae4bd", size = 3279117, upload-time = "2026-05-04T22:59:12.019Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9a/0fea98a70cf1749d41d738836f6349d97945f7c89433a259a6c2642eefeb/cryptography-48.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:16cd65b9330583e4619939b3a3843eec1e6e789744bb01e7c7e2e62e33c239c8", size = 3792100, upload-time = "2026-05-04T22:59:14.884Z" }, +] + +[[package]] +name = "cuda-bindings" +version = "13.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cuda-pathfinder", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/a0/156efe7816699c2de1ea2395031db7d010b7af23c243563a3ee6f0ecc1de/cuda_bindings-13.3.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7698fcc4577aa96372866f4d0c9a6cf686cd5c90eab94581c29d37fe6600542", size = 5914803, upload-time = "2026-05-27T03:59:14.011Z" }, + { url = "https://files.pythonhosted.org/packages/51/91/510aae64d53227b5b36db6bfaea41514b66d92cd65ddc43aa49566f18313/cuda_bindings-13.3.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:abd908f651160d12c45c5714a38ee102a1173a55433c0d1509ec0e8293beb4a6", size = 6472506, upload-time = "2026-05-27T03:59:16.551Z" }, + { url = "https://files.pythonhosted.org/packages/01/53/2ef49e5b3734a5531b2ba5d726cba724d9cbb262404e586ed61070604826/cuda_bindings-13.3.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a801fa30e75d25b74252123aefc746b6c4275624d2b8640632dd1dfeeaa1f88", size = 6008814, upload-time = "2026-05-27T03:59:20.921Z" }, + { url = "https://files.pythonhosted.org/packages/2f/cb/3a9fcf0651e0a49b4d0f1955837ce079245b27086c22fb2f253039bdf324/cuda_bindings-13.3.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94d40ef7b4bdd9dce0244a1baa132e0e538f1eb2c0d162fb3648a15e48515365", size = 6531477, upload-time = "2026-05-27T03:59:23.391Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/6987c5ee98f117317a85650ddc79480a3fa59a573ae1c923d0722b56ae71/cuda_bindings-13.3.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e5911bea15810b749a8077f8c45423ed785d51618b8e8664dea1fc8f5a2a76c8", size = 5807073, upload-time = "2026-05-27T03:59:28.218Z" }, + { url = "https://files.pythonhosted.org/packages/f6/ab/46ceee07dc19f18a5d1c28d592750ed9dbdc803077eb083576a442c9938c/cuda_bindings-13.3.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2870fed7707a37f8af0c02364b05f355ebe8921604e8c68eb56cf66867e0798", size = 6354325, upload-time = "2026-05-27T03:59:30.715Z" }, +] + +[[package]] +name = "cuda-pathfinder" +version = "1.5.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/c8/26f2e4aae92f11522a96043892ba39a90eac610d5242523aa863212bc1c7/cuda_pathfinder-1.5.5-py3-none-any.whl", hash = "sha256:0228c023f95d1480f143ef5c8922d27a2ab052087a942e81dc289c9eb8f91689", size = 51671, upload-time = "2026-05-27T01:21:25.413Z" }, +] + +[[package]] +name = "cuda-toolkit" +version = "13.0.2" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b2/453099f5f3b698d7d0eab38916aac44c7f76229f451709e2eb9db6615dcd/cuda_toolkit-13.0.2-py2.py3-none-any.whl", hash = "sha256:b198824cf2f54003f50d64ada3a0f184b42ca0846c1c94192fa269ecd97a66eb", size = 2364, upload-time = "2025-12-19T23:24:07.328Z" }, +] + +[package.optional-dependencies] +cudart = [ + { name = "nvidia-cuda-runtime", marker = "sys_platform == 'linux'" }, +] +cufft = [ + { name = "nvidia-cufft", marker = "sys_platform == 'linux'" }, +] +cufile = [ + { name = "nvidia-cufile", marker = "sys_platform == 'linux'" }, +] +cupti = [ + { name = "nvidia-cuda-cupti", marker = "sys_platform == 'linux'" }, +] +curand = [ + { name = "nvidia-curand", marker = "sys_platform == 'linux'" }, +] +cusolver = [ + { name = "nvidia-cusolver", marker = "sys_platform == 'linux'" }, +] +cusparse = [ + { name = "nvidia-cusparse", marker = "sys_platform == 'linux'" }, +] +nvjitlink = [ + { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" }, +] +nvrtc = [ + { name = "nvidia-cuda-nvrtc", marker = "sys_platform == 'linux'" }, +] +nvtx = [ + { name = "nvidia-nvtx", marker = "sys_platform == 'linux'" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/b7/cd8080344452e4874aae67c40d8940e2b4d47b01601a8fd9f44786c757c7/debugpy-1.8.20.tar.gz", hash = "sha256:55bc8701714969f1ab89a6d5f2f3d40c36f91b2cbe2f65d98bf8196f6a6a2c33", size = 1645207, upload-time = "2026-01-29T23:03:28.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/e2/fc500524cc6f104a9d049abc85a0a8b3f0d14c0a39b9c140511c61e5b40b/debugpy-1.8.20-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:5dff4bb27027821fdfcc9e8f87309a28988231165147c31730128b1c983e282a", size = 2539560, upload-time = "2026-01-29T23:03:48.738Z" }, + { url = "https://files.pythonhosted.org/packages/90/83/fb33dcea789ed6018f8da20c5a9bc9d82adc65c0c990faed43f7c955da46/debugpy-1.8.20-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:84562982dd7cf5ebebfdea667ca20a064e096099997b175fe204e86817f64eaf", size = 4293272, upload-time = "2026-01-29T23:03:50.169Z" }, + { url = "https://files.pythonhosted.org/packages/a6/25/b1e4a01bfb824d79a6af24b99ef291e24189080c93576dfd9b1a2815cd0f/debugpy-1.8.20-cp313-cp313-win32.whl", hash = "sha256:da11dea6447b2cadbf8ce2bec59ecea87cc18d2c574980f643f2d2dfe4862393", size = 5331208, upload-time = "2026-01-29T23:03:51.547Z" }, + { url = "https://files.pythonhosted.org/packages/13/f7/a0b368ce54ffff9e9028c098bd2d28cfc5b54f9f6c186929083d4c60ba58/debugpy-1.8.20-cp313-cp313-win_amd64.whl", hash = "sha256:eb506e45943cab2efb7c6eafdd65b842f3ae779f020c82221f55aca9de135ed7", size = 5372930, upload-time = "2026-01-29T23:03:53.585Z" }, + { url = "https://files.pythonhosted.org/packages/33/2e/f6cb9a8a13f5058f0a20fe09711a7b726232cd5a78c6a7c05b2ec726cff9/debugpy-1.8.20-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9c74df62fc064cd5e5eaca1353a3ef5a5d50da5eb8058fcef63106f7bebe6173", size = 2538066, upload-time = "2026-01-29T23:03:54.999Z" }, + { url = "https://files.pythonhosted.org/packages/c5/56/6ddca50b53624e1ca3ce1d1e49ff22db46c47ea5fb4c0cc5c9b90a616364/debugpy-1.8.20-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:077a7447589ee9bc1ff0cdf443566d0ecf540ac8aa7333b775ebcb8ce9f4ecad", size = 4269425, upload-time = "2026-01-29T23:03:56.518Z" }, + { url = "https://files.pythonhosted.org/packages/c5/d9/d64199c14a0d4c476df46c82470a3ce45c8d183a6796cfb5e66533b3663c/debugpy-1.8.20-cp314-cp314-win32.whl", hash = "sha256:352036a99dd35053b37b7803f748efc456076f929c6a895556932eaf2d23b07f", size = 5331407, upload-time = "2026-01-29T23:03:58.481Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d9/1f07395b54413432624d61524dfd98c1a7c7827d2abfdb8829ac92638205/debugpy-1.8.20-cp314-cp314-win_amd64.whl", hash = "sha256:a98eec61135465b062846112e5ecf2eebb855305acc1dfbae43b72903b8ab5be", size = 5372521, upload-time = "2026-01-29T23:03:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/e0/c3/7f67dea8ccf8fdcb9c99033bbe3e90b9e7395415843accb81428c441be2d/debugpy-1.8.20-py2.py3-none-any.whl", hash = "sha256:5be9bed9ae3be00665a06acaa48f8329d2b9632f15fd09f6a9a8c8d9907e54d7", size = 5337658, upload-time = "2026-01-29T23:04:17.404Z" }, +] + +[[package]] +name = "decorator" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "diffusers" +version = "0.37.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "importlib-metadata" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/5c/f4c2eb8d481fe8784a7e2331fbaab820079c06676185fa6d2177b386d590/diffusers-0.37.1.tar.gz", hash = "sha256:2346c21f77f835f273b7aacbaada1c34a596a3a2cc6ddc99d149efcd0ec298fa", size = 4135139, upload-time = "2026-03-25T08:04:04.515Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/dd/51c38785ce5e1c287b5ad17ba550edaaaffce0deb0da4857019c6700fbaf/diffusers-0.37.1-py3-none-any.whl", hash = "sha256:0537c0b28cb53cf39d6195489bcf8f833986df556c10f5e28ab7427b86fc8b90", size = 5001536, upload-time = "2026-03-25T08:04:02.385Z" }, +] + +[[package]] +name = "einops" +version = "0.8.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827", size = 56261, upload-time = "2026-01-26T04:13:17.638Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193", size = 65638, upload-time = "2026-01-26T04:13:18.546Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "fastapi" +version = "0.136.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/81/2d/ff8d91d7b564d464629a0fd50a4489c97fcb836ac230bf3a7269232a9b1f/fastapi-0.136.3.tar.gz", hash = "sha256:e487fae93ad408e6f47641ee4dfe389864fd7bec92e547ea8498fc13f43e83ab", size = 396410, upload-time = "2026-05-23T18:53:15.192Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/82/45359b62a067409bd929ae8a56b8ed13e5a8c8a61194b3c236920999ab83/fastapi-0.136.3-py3-none-any.whl", hash = "sha256:3d2a69bdf04b7e9f3afa292c3bc7a98816bbfafa10bc9b45f3f3700d2f761620", size = 117481, upload-time = "2026-05-23T18:53:16.924Z" }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, +] + +[[package]] +name = "filelock" +version = "3.29.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", hash = "sha256:69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90", size = 57571, upload-time = "2026-04-19T15:39:10.068Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" }, +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, +] + +[[package]] +name = "fonttools" +version = "4.63.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/8d/d8fec3dcde2963f8c908fb315e5ff2cd0ac34f82394bbbf73a2aa5145ce3/fonttools-4.63.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd7e9857e5e63738b9d9fd707bc1f59c8b09e5177726d23664db393c59bb08bd", size = 2876062, upload-time = "2026-05-14T12:03:32.554Z" }, + { url = "https://files.pythonhosted.org/packages/ef/71/d935dc54e4ff121bfdd11e08702db63a7e6f25af21d8a3d7b7212df53641/fonttools-4.63.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c2a2a42198b696a6f48fad91709afb55176e66a5e566131219dba372fb7f8c59", size = 2424594, upload-time = "2026-05-14T12:03:34.86Z" }, + { url = "https://files.pythonhosted.org/packages/8e/40/e76320afa1df918e146155ef239b1719ee266092e96f5423bfd075affba1/fonttools-4.63.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e874792a8212b44583ea02189d9e693906b2f78b261f372f95d6c563210ac1d", size = 5024840, upload-time = "2026-05-14T12:03:36.745Z" }, + { url = "https://files.pythonhosted.org/packages/ce/36/0b805d8c485f872f65a509cbe3b58a5d0d17bee855333b54a150c79d3061/fonttools-4.63.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22135da48a348785c5e2d5d2d9d6bec5ed44adacbaeb9db12d9493bf6c6bfa68", size = 4975801, upload-time = "2026-05-14T12:03:38.833Z" }, + { url = "https://files.pythonhosted.org/packages/c8/26/2cee03d0aa083ab022da5c07aff9ed3f689da1defb81ad6917c9627896da/fonttools-4.63.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccf41f2efdf56994d22d73bef4ced1052161958169428d06ba9724ea9e9a64be", size = 4965009, upload-time = "2026-05-14T12:03:41.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" }, + { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" }, + { url = "https://files.pythonhosted.org/packages/27/d2/23d25e3f247b328be58d04a4c9f894178a0d1eda7d42867cfb388adaf416/fonttools-4.63.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fd1e3094f42d806d3d7c79162fc59e5910fcbe3a7360c385b8da969bc4493745", size = 2875338, upload-time = "2026-05-14T12:03:50.052Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/7dfa0c761cb3b2964e2a84c4dc986c926a87de0cb9fb60d5b28ded3f2914/fonttools-4.63.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6e528da43bc3791085f8cb6141b1d13e459226790240340fcbb4625649238b03", size = 2422661, upload-time = "2026-05-14T12:03:52.154Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/64cfa18a7a1621d17b7f4502b2b0ed8a135a90c3db51ea590ee99043e76b/fonttools-4.63.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b2248c5decb223562f7902ff6325077a073f608ee8e33e88ad88db734eb9f49", size = 5010526, upload-time = "2026-05-14T12:03:54.647Z" }, + { url = "https://files.pythonhosted.org/packages/36/e1/a8933a72c45a87177fbde2696e0d0755c8c9062f8c077a961c6215fa27b1/fonttools-4.63.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:308f957cdeaf8abe4e5f2f124902ef405448af92c90f80e302a3b771c2e6116b", size = 4923946, upload-time = "2026-05-14T12:03:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/872e6e233b8c5e8b41413796ff18b7fe479661bd40147e071b450dfad7a1/fonttools-4.63.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bf00f21eb5fb721dbaf73d1e9da6d02a1af7768f2ebcf9798be98beab8ba90f6", size = 4962489, upload-time = "2026-05-14T12:03:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/30/c4/83c24f2ec38b90cfda84bf4b1a1f49df80e84a1db4e7ac6e0d41bf23bc39/fonttools-4.63.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1aaa4b9c75798400ac043ce04d74e7830376c85095a5a6ed7cba2f17a266bf4", size = 5071870, upload-time = "2026-05-14T12:04:02.122Z" }, + { url = "https://files.pythonhosted.org/packages/de/40/3ae22b60ff1d41ce0bd044b31238cdc72cef99f28b976f1e128ebd618c9b/fonttools-4.63.0-cp314-cp314-win32.whl", hash = "sha256:22693918177bd9ceabec4736d338045f357769416fc6b0b2508eefef75b08616", size = 2295026, upload-time = "2026-05-14T12:04:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d4/98078064ccc76b45cb0f6c002452011e93c4bd26f6850344f0951cc1fe89/fonttools-4.63.0-cp314-cp314-win_amd64.whl", hash = "sha256:7d782fac32985914c351556f68ac0855391572bcd87de50e05970d3cd4c96fc5", size = 2347454, upload-time = "2026-05-14T12:04:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/49/4e/652d1580c5f4e39f7d103b0c793e4773129ad633dce4addd0cf4dfebde02/fonttools-4.63.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6db5140a60a5d731d21ec076745b40a310607731b0a565b50776393188649001", size = 2958152, upload-time = "2026-05-14T12:04:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/0e/55/ad864c9a9b219f552eb46b32cd7906c466e5a578ba0c3abfcc0fe7413eb6/fonttools-4.63.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d76edbff9014094dbf03bd2d074709dfa6ec7aba13d838c937a2b33d2d6a86e", size = 2460809, upload-time = "2026-05-14T12:04:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/0aa8db70f18cf52e49b4ed5ecec68547f981160bf5ded3b5aed6faa0a6f9/fonttools-4.63.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eac00b9118c3c2f87d272e45341871c5b3066baa3c86897fa634a7c3fb59096", size = 5148649, upload-time = "2026-05-14T12:04:12.747Z" }, + { url = "https://files.pythonhosted.org/packages/7f/63/18e4369c25043096f1048e0c9915951adc4f842bd81c6b18155824d6fa99/fonttools-4.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51394295f1a51de8b5f30bdb1e1b9a4231536c7064ef5c6e211eec19fa36036f", size = 4932147, upload-time = "2026-05-14T12:04:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/a1/3f/67f3eac2ffd8a98446c5022f8ed3864eac878a5ff7af8df4c8286dba16cc/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9e12f105d2b6342c559c298afb674006bb2893afc7102dcf8a1b55b0486b4e40", size = 5027237, upload-time = "2026-05-14T12:04:17.675Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ba/4e6214cb38a7b04779e97bb7636de9a5c7f20af7018d03dee0b64c08510a/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:796f27556dbe094c4824f75ca85267e4df776c79036c8441469a4df37038c196", size = 5053933, upload-time = "2026-05-14T12:04:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/34/3b/214dcc19ee31d3d38fb5ad2755c11ef0514e5dc300bbaf41c0b69f393799/fonttools-4.63.0-cp314-cp314t-win32.whl", hash = "sha256:948428a275741f0b64b113c955425a953314f4b9ab9997f73a72c83e68e569c8", size = 2359326, upload-time = "2026-05-14T12:04:24.22Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/3ff1a9b523058c2eeb6a9d50f5574e2a738200d0d94107d5bc4105e8da3f/fonttools-4.63.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6d4741eb179121cab9eea4cb2393d24492373a260d7945006358c08cfbf45419", size = 2425829, upload-time = "2026-05-14T12:04:26.829Z" }, + { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + +[[package]] +name = "fsspec" +version = "2026.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/8d/1c51c094345df128ca4a990d633fe1a0ff28726c9e6b3c41ba65087bba1d/fsspec-2026.4.0.tar.gz", hash = "sha256:301d8ac70ae90ef3ad05dcf94d6c3754a097f9b5fe4667d2787aa359ec7df7e4", size = 312760, upload-time = "2026-04-29T20:42:38.635Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/0c/043d5e551459da400957a1395e0febbf771446ff34291afcbe3d8be2a279/fsspec-2026.4.0-py3-none-any.whl", hash = "sha256:11ef7bb35dab8a394fde6e608221d5cf3e8499401c249bebaeaad760a1a8dec2", size = 203402, upload-time = "2026-04-29T20:42:36.842Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/74/d8/5c06fc76461418326a7decf8367480c35be11a41fd938633929c60a9ec6b/hf_xet-1.5.0.tar.gz", hash = "sha256:e0fb0a34d9f406eed88233e829a67ec016bec5af19e480eac65a233ea289a948", size = 837196, upload-time = "2026-05-06T06:18:15.583Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/9b/6912c99070915a4f28119e3c5b52a9abd1eec0ad5cb293b8c967a0c6f5a2/hf_xet-1.5.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:7d70fe2ce97b9db73b9c9b9c81fe3693640aec83416a966c446afea54acfae3c", size = 4023383, upload-time = "2026-05-06T06:17:53.947Z" }, + { url = "https://files.pythonhosted.org/packages/0f/6d/9563cfde59b5d8128a9c7ec972a087f4c782e4f7bac5a85234edfd5d5e49/hf_xet-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:73a0dae8c71de3b0633a45c73f4a4a5ed09e94b43441d82981a781d4f12baa42", size = 3792751, upload-time = "2026-05-06T06:17:51.791Z" }, + { url = "https://files.pythonhosted.org/packages/07/a5/ed5a0cf35b49a0571af5a8f53416dad1877a718c021c9937c3a53cb45781/hf_xet-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a60290ec57e9b71767fba7c3645ddafdd0759974b540441510c629c6db6db24a", size = 4456058, upload-time = "2026-05-06T06:17:40.735Z" }, + { url = "https://files.pythonhosted.org/packages/60/fb/3ae8bf2a7a37a4197d0195d7247fd25b3952e15cb8a599e285dfaa6f52b3/hf_xet-1.5.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:e5de0f6deada0dada870bb376a11bcd1f08abf3a968a6d118f33e72d1b1eb480", size = 4250783, upload-time = "2026-05-06T06:17:38.412Z" }, + { url = "https://files.pythonhosted.org/packages/a2/9b/8bae40d4d91525085137196e84eb0ed49cf65b5e96e5c3ecdadd8bd0fac2/hf_xet-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c799d49f1a5544a0ef7591c0ee75e0d6b93d6f56dc7a4979f59f7518d2872216", size = 4445594, upload-time = "2026-05-06T06:18:04.219Z" }, + { url = "https://files.pythonhosted.org/packages/13/59/c74efbbd4e8728172b2cc72a2bc014d2947a4b7bdced932fbd3f5da1a4e5/hf_xet-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2baea1b0b989e5c152fe81425f7745ddc8901280ba3d97c98d8cdece7b706c60", size = 4663995, upload-time = "2026-05-06T06:18:06.1Z" }, + { url = "https://files.pythonhosted.org/packages/73/32/8e1e0410af64cda9b139d1dcebdc993a8ff9c8c7c0e2696ae356d75ccc0d/hf_xet-1.5.0-cp313-cp313t-win_amd64.whl", hash = "sha256:526345b3ed45f374f6317349df489167606736c876241ba984105afe7fd4839d", size = 3966608, upload-time = "2026-05-06T06:18:19.74Z" }, + { url = "https://files.pythonhosted.org/packages/fc/34/a8febc8f4edbea8b3e21b02ebc8b628679b84ba7e45cde624a7736b51500/hf_xet-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:786d28e2eb8315d5035544b9d137b4a842d600c434bb91bf7d0d953cce906ad4", size = 3796946, upload-time = "2026-05-06T06:18:17.568Z" }, + { url = "https://files.pythonhosted.org/packages/2a/20/8fc8996afe5815fa1a6be8e9e5c02f24500f409d599e905800d498a4e14d/hf_xet-1.5.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:872d5601e6deea30d15865ede55d29eac6daf5a534ab417b99b6ef6b076dd96c", size = 4023495, upload-time = "2026-05-06T06:18:01.94Z" }, + { url = "https://files.pythonhosted.org/packages/32/6a/93d84463c00cecb561a7508aa6303e35ee2894294eac14245526924415fe/hf_xet-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9929561f5abf4581c8ea79587881dfef6b8abb2a0d8a51915936fc2a614f4e73", size = 3792731, upload-time = "2026-05-06T06:18:00.021Z" }, + { url = "https://files.pythonhosted.org/packages/9d/5a/8ec8e0c863b382d00b3c2e2af6ded6b06371be617144a625903a6d562f4b/hf_xet-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f7b7bbae318e583a86fb21e5a4a175d6721d628a2874f4bd022d0e660c32a682", size = 4456738, upload-time = "2026-05-06T06:17:49.574Z" }, + { url = "https://files.pythonhosted.org/packages/c5/ca/f7effa1a67717da2bcc6b6c28f71c6ca648c77acaec4e2c32f40cbe16d85/hf_xet-1.5.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:cf7b2dc6f31a4ea754bb50f74cde482dcf5d366d184076d8530b9872787f3761", size = 4251622, upload-time = "2026-05-06T06:17:47.096Z" }, + { url = "https://files.pythonhosted.org/packages/65/f2/19247dba3e231cf77dec59ddfb878f00057635ff773d099c9b59d37812c3/hf_xet-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8dbcbab554c9ef158ef2c991545c3e970ddd8cc7acdcd0a78c5a41095dab4ded", size = 4445667, upload-time = "2026-05-06T06:18:11.983Z" }, + { url = "https://files.pythonhosted.org/packages/7f/64/6f116801a3bcfb6f59f5c251f48cadc47ea54026441c4a385079286a94fa/hf_xet-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5906bf7718d3636dc13402914736abe723492cb730f744834f5f5b67d3a12702", size = 4664619, upload-time = "2026-05-06T06:18:13.771Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e8/069542d37946ed08669b127e1496fa99e78196d71de8d41eda5e9f1b7a58/hf_xet-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5f3dc2248fc01cc0a00cd392ab497f1ca373fcbc7e3f2da1f452480b384e839e", size = 3966802, upload-time = "2026-05-06T06:18:28.162Z" }, + { url = "https://files.pythonhosted.org/packages/f9/91/fc6fdec27b14d04e88c386ac0a0129732b53fa23f7c4a78f4b83a039c567/hf_xet-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b285cea1b5bab46b758772716ba8d6854a1a0310fed1c249d678a8b38601e5a0", size = 3797168, upload-time = "2026-05-06T06:18:26.287Z" }, + { url = "https://files.pythonhosted.org/packages/3d/fb/69ff198a82cae7eb1a69fb84d93b3a3e4816564d76817fe541ddc96874eb/hf_xet-1.5.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:dad0dc84e941b8ba3c860659fe1fdc35c049d47cce293f003287757e971a8f56", size = 4030814, upload-time = "2026-05-06T06:17:57.933Z" }, + { url = "https://files.pythonhosted.org/packages/9b/ff/edcc2b40162bef3ff78e14ab637e5f3b89243d6aee72f5949d3bb6a5af83/hf_xet-1.5.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:fd6e5a9b0fdac4ed03ed45ef79254a655b1aaab514a02202617fbf643f5fdf7a", size = 3798444, upload-time = "2026-05-06T06:17:55.79Z" }, + { url = "https://files.pythonhosted.org/packages/49/4d/103f76b04310e5e57656696cc184690d20c466af0bca3ca88f8c8ea5d4f3/hf_xet-1.5.0-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3531b1823a0e6d77d80f9ed15ca0e00f0d115094f8ac033d5cae88f4564cc949", size = 4465986, upload-time = "2026-05-06T06:17:44.886Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a2/546f47f464737b3edbab6f8ddb57f2599b93d2cbb66f06abb475ccb48651/hf_xet-1.5.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:9a0ee58cd18d5ea799f7ed11290bbccbe56bdd8b1d97ca74b9cc49a3945d7a3b", size = 4259865, upload-time = "2026-05-06T06:17:42.639Z" }, + { url = "https://files.pythonhosted.org/packages/95/7f/1be593c1f28613be2e196473481cd81bfc5910795e30a34e8f744f6cac4f/hf_xet-1.5.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1e60df5a42e9bed8628b6416af2cba4cba57ae9f02de226a06b020d98e1aab18", size = 4459835, upload-time = "2026-05-06T06:18:08.026Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b2/703569fc881f3284487e68cda7b42179978480da3c438042a6bbbb4a671c/hf_xet-1.5.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4b35549ce62601b84da4ff9b24d970032ace3d4430f52d91bcbb26c901d6c690", size = 4672414, upload-time = "2026-05-06T06:18:09.864Z" }, + { url = "https://files.pythonhosted.org/packages/af/37/1b6def445c567286b50aa3b33828158e135b1be44938dde59f11382a500c/hf_xet-1.5.0-cp37-abi3-win_amd64.whl", hash = "sha256:2806c7c17b4d23f8d88f7c4814f838c3b6150773fe339c20af23e1cfaf2797e4", size = 3977238, upload-time = "2026-05-06T06:18:23.621Z" }, + { url = "https://files.pythonhosted.org/packages/62/94/3b66b148778ee100dcfd69c2ca22b57b41b44d3063ceec934f209e9184ce/hf_xet-1.5.0-cp37-abi3-win_arm64.whl", hash = "sha256:b6c9df403040248c76d808d3e047d64db2d923bae593eb244c41e425cf6cd7be", size = 3806916, upload-time = "2026-05-06T06:18:21.7Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "httpx-sse" +version = "0.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" }, +] + +[[package]] +name = "huggingface-hub" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/b7/8cb61d2eece5fb05a83271da168186721c450eb74e3c31f7ef3169fa475b/huggingface_hub-0.36.2.tar.gz", hash = "sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a", size = 649782, upload-time = "2026-02-06T09:24:13.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/af/48ac8483240de756d2438c380746e7130d1c6f75802ef22f3c6d49982787/huggingface_hub-0.36.2-py3-none-any.whl", hash = "sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270", size = 566395, upload-time = "2026-02-06T09:24:11.133Z" }, +] + +[[package]] +name = "idna" +version = "3.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/88/bcf9709822fe69d02c2a6a77956c98ce6ea8ca8767a9aadcedc7eb6a2390/idna-3.16.tar.gz", hash = "sha256:d7a6da03db833450fca25d2358ac9ff06cd624577a4aea3a596d5c0f77b8e03d", size = 203770, upload-time = "2026-05-22T00:16:18.781Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/16/70255075a9859a0e3adb789b68ceb0e210dec03934245fd98d248226572f/idna-3.16-py3-none-any.whl", hash = "sha256:cc246e3a3f89580c3a951b5ad298ca4638078b2cdd4f115654332b5c26daded5", size = 74165, upload-time = "2026-05-22T00:16:16.698Z" }, +] + +[[package]] +name = "imageio" +version = "2.37.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/84/93bcd1300216ea50811cee96873b84a1bebf8d0489ffaf7f2a3756bab866/imageio-2.37.3.tar.gz", hash = "sha256:bbb37efbfc4c400fcd534b367b91fcd66d5da639aaa138034431a1c5e0a41451", size = 389673, upload-time = "2026-03-09T11:31:12.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/fa/391e437a34e55095173dca5f24070d89cbc233ff85bf1c29c93248c6588d/imageio-2.37.3-py3-none-any.whl", hash = "sha256:46f5bb8522cd421c0f5ae104d8268f569d856b29eb1a13b92829d1970f32c9f0", size = 317646, upload-time = "2026-03-09T11:31:10.771Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "9.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789, upload-time = "2026-03-20T06:42:55.665Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/8d/b68b728e2d06b9e0051019640a40a9eb7a88fcd82c2e1b5ce70bef5ff044/ipykernel-7.2.0.tar.gz", hash = "sha256:18ed160b6dee2cbb16e5f3575858bc19d8f1fe6046a9a680c708494ce31d909e", size = 176046, upload-time = "2026-02-06T16:43:27.403Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/b9/e73d5d9f405cba7706c539aa8b311b49d4c2f3d698d9c12f815231169c71/ipykernel-7.2.0-py3-none-any.whl", hash = "sha256:3bbd4420d2b3cc105cbdf3756bfc04500b1e52f090a90716851f3916c62e1661", size = 118788, upload-time = "2026-02-06T16:43:25.149Z" }, +] + +[[package]] +name = "ipython" +version = "9.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", hash = "sha256:7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967", size = 4430549, upload-time = "2026-04-24T12:24:55.221Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", hash = "sha256:57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201", size = 627274, upload-time = "2026-04-24T12:24:53.038Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4c/ae/c5ce1edc1afe042eadb445e95b0671b03cee61895264357956e61c0d2ac0/ipywidgets-8.1.8.tar.gz", hash = "sha256:61f969306b95f85fba6b6986b7fe45d73124d1d9e3023a8068710d47a22ea668", size = 116739, upload-time = "2025-11-01T21:18:12.393Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/6d/0d9848617b9f753b87f214f1c682592f7ca42de085f564352f10f0843026/ipywidgets-8.1.8-py3-none-any.whl", hash = "sha256:ecaca67aed704a338f88f67b1181b58f821ab5dc89c1f0f5ef99db43c1c2921e", size = 139808, upload-time = "2025-11-01T21:18:10.956Z" }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "json5" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9c/4b/6f8906aaf67d501e259b0adab4d312945bb7211e8b8d4dcc77c92320edaa/json5-0.14.0.tar.gz", hash = "sha256:b3f492fad9f6cdbced8b7d40b28b9b1c9701c5f561bef0d33b81c2ff433fefcb", size = 52656, upload-time = "2026-03-27T22:50:48.108Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/42/cf027b4ac873b076189d935b135397675dac80cb29acb13e1ab86ad6c631/json5-0.14.0-py3-none-any.whl", hash = "sha256:56cf861bab076b1178eb8c92e1311d273a9b9acea2ccc82c276abf839ebaef3a", size = 36271, upload-time = "2026-03-27T22:50:47.073Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" }, +] + +[[package]] +name = "jupyter-collaboration" +version = "4.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-collaboration-ui" }, + { name = "jupyter-docprovider" }, + { name = "jupyter-server-ydoc" }, + { name = "jupyterlab" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f0/4a/1f8ba60881f3ed86112e7d77a4098ee859dea729e854140a862f2b52df95/jupyter_collaboration-4.4.0.tar.gz", hash = "sha256:d492a2f69bd91d6f472991051b2df83dc2cdfaeecbfa2d75dabee5fc3178814d", size = 3727, upload-time = "2026-05-11T11:05:17.778Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/70/9d44957eef95c0e8ce80fbf90cacaa3dabd579fd811278dc517148e7b777/jupyter_collaboration-4.4.0-py3-none-any.whl", hash = "sha256:c10828d3e83e73448051dfceadb89bf61bcdd97c3000eaac878b39be5aa8358f", size = 4751, upload-time = "2026-05-11T11:05:15.924Z" }, +] + +[[package]] +name = "jupyter-collaboration-ui" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/34/bf/f6494fbba8d192d34dce04994fe43a7c1069d11e9d443c6988013c099afa/jupyter_collaboration_ui-2.4.0.tar.gz", hash = "sha256:9a1942ed90f8d98c83a1b6fbc0108bf5d1a4b1484668b634364868806caf5d7c", size = 79142, upload-time = "2026-05-11T11:04:52.467Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/97/585c550ed6349c9a9bfa8b217ebbac606eeeda45af812602803b8aef05e1/jupyter_collaboration_ui-2.4.0-py3-none-any.whl", hash = "sha256:543fd8d63106e00f50c9e3d0fd70e32d8242de8d7f887b503dcbcec6cb586e5c", size = 46696, upload-time = "2026-05-11T11:04:50.525Z" }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyter-docprovider" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/ce/1e48717f4f499b649cc9c0d3ff95b64efaf4c69142ecc7dee3caf011a681/jupyter_docprovider-2.4.0.tar.gz", hash = "sha256:7b901fb9d800599e2ab68557fd6391102a6888845286c4f7cbb6eb2bba3094e0", size = 51324, upload-time = "2026-05-11T11:05:04.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/cc/74b80ecbb804266f55cc82fb9242b49437572dcc4203bff5cfc7c449cbeb/jupyter_docprovider-2.4.0-py3-none-any.whl", hash = "sha256:cf0582cededc46bc5a055e31b4f4b9352f8d48bbb55fbea389e953b166dacf1b", size = 35927, upload-time = "2026-05-11T11:05:02.394Z" }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/f8/475c4241b2b75af0deaae453ed003c6c851766dbc44d332d8baf245dc931/jupyter_events-0.12.1.tar.gz", hash = "sha256:faff25f77218335752f35f23c5fe6e4a392a7bd99a5939ccb9b8fbf594636cf3", size = 62854, upload-time = "2026-04-20T23:17:50.66Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/6c/6fcde0c8f616ed360ffd3587f7db9e225a7e62b583a04494d2f069cf64ea/jupyter_events-0.12.1-py3-none-any.whl", hash = "sha256:c366585253f537a627da52fa7ca7410c5b5301fe893f511e7b077c2d93ec8bcf", size = 19512, upload-time = "2026-04-20T23:17:48.927Z" }, +] + +[[package]] +name = "jupyter-kernel-client" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-mimetypes" }, + { name = "requests" }, + { name = "traitlets" }, + { name = "typing-extensions" }, + { name = "websocket-client" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/68/287315ba355aa93bda2e344de5febc45e6de1b47d8f4a5b69400b24cfdfd/jupyter_kernel_client-0.9.0-py3-none-any.whl", hash = "sha256:77acb8f2f738d97625d6bd01ee8cf21c4d59790b7ba464108712db3870416f20", size = 40097, upload-time = "2026-02-11T06:42:05.133Z" }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/ff/1e4a61f5170a9a1d978f3ac3872449de6c01fc71eaf89657824c878b1549/jupyter_lsp-2.3.1.tar.gz", hash = "sha256:fdf8a4aa7d85813976d6e29e95e6a2c8f752701f926f2715305249a3829805a6", size = 55677, upload-time = "2026-04-02T08:10:06.749Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/e8/9d61dcbd1dce8ef418f06befd4ac084b4720429c26b0b1222bc218685eff/jupyter_lsp-2.3.1-py3-none-any.whl", hash = "sha256:71b954d834e85ff3096400554f2eefaf7fe37053036f9a782b0f7c5e42dadb81", size = 77513, upload-time = "2026-04-02T08:10:01.753Z" }, +] + +[[package]] +name = "jupyter-mcp-server" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "fastapi" }, + { name = "jupyter-kernel-client" }, + { name = "jupyter-mcp-tools" }, + { name = "jupyter-nbmodel-client" }, + { name = "jupyter-server" }, + { name = "jupyter-server-client" }, + { name = "jupyter-server-nbmodel" }, + { name = "mcp", extra = ["cli"] }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-sdk" }, + { name = "pydantic" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "uvicorn" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/ae/7843fe02bb57c5a2928fa830b01779a3c2395ca382e91e690aac987fa054/jupyter_mcp_server-1.0.2.tar.gz", hash = "sha256:a1e1b4816d4cbc53944a6f76385e0c3b6b4d8aa5c9f855cbce153fad1b18c3fe", size = 80102, upload-time = "2026-04-27T06:08:37.559Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/5e/f306a728502f2d26988c76a882121dd1bb1a87c59e6db8b096a9a7b35903/jupyter_mcp_server-1.0.2-py3-none-any.whl", hash = "sha256:6be3c923fc6469094856e329dd593e4cbd4938cedb068b65697b3b1bc8543538", size = 111133, upload-time = "2026-04-27T06:08:36.01Z" }, +] + +[[package]] +name = "jupyter-mcp-tools" +version = "0.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "jupyter-server" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/f4/28e9cbdd05d3146d5adedc474f64a2d669c21b0e672d09b0885a1cc7c85a/jupyter_mcp_tools-0.1.6-py3-none-any.whl", hash = "sha256:45cb18658d5853a62faccd5e8ea17becc3a1850482a43c49a9e4bb2c854effd7", size = 45664, upload-time = "2026-01-08T15:32:10.559Z" }, +] + +[[package]] +name = "jupyter-mimetypes" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyarrow" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/45/cb4671e13fed39f721066ad1a00714d4b607982b8d3e97a25f836198d1df/jupyter_mimetypes-0.2.0-py3-none-any.whl", hash = "sha256:e6dcd989258e3fc944365b656d9173191517e0e393bd878e97ce500e5b388527", size = 16724, upload-time = "2025-08-10T18:18:27.309Z" }, +] + +[[package]] +name = "jupyter-nbmodel-client" +version = "0.14.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-ydoc" }, + { name = "nbformat" }, + { name = "pycrdt" }, + { name = "requests" }, + { name = "websockets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c3/f9/bf5a0ba321a227ba4c94bafa3d3950f9e773658773a81e379381b8687e25/jupyter_nbmodel_client-0.14.7.tar.gz", hash = "sha256:c9ff959ea26f5b2876271dfe37882c4674551e0e2aafc7633a4ebc57c0260563", size = 25909, upload-time = "2026-04-25T10:40:46.108Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/61/5d6ada9177f164f3ca0394af899d09a7bb82b6ba9bb5f1d559a9d9f53758/jupyter_nbmodel_client-0.14.7-py3-none-any.whl", hash = "sha256:ff9371378608dd46f5cb58e394493aa6bde4efcbabbcb988fc331f55b5b7cef3", size = 23025, upload-time = "2026-04-25T10:40:44.046Z" }, +] + +[[package]] +name = "jupyter-server" +version = "2.18.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/15/1eacb0fcb79ef86e8a0a79a708e6ad7435f6f223097dd29a4ce861fabc44/jupyter_server-2.18.2.tar.gz", hash = "sha256:06b4f40d8a7a00bb39d5216859c81374a0e7cfefe6d8a5a7facc5a5c37c679a7", size = 753177, upload-time = "2026-05-06T07:04:36.274Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/50/ecf4f70d65bdb7519b28a33d1b2fee8a4b4ba1ae1a92f15d97e877c5de21/jupyter_server-2.18.2-py3-none-any.whl", hash = "sha256:fa5e46539ded65791838035a2b6001f13e54d5f64b8b3752eb1e91fdd641a5b8", size = 391907, upload-time = "2026-05-06T07:04:34.014Z" }, +] + +[[package]] +name = "jupyter-server-client" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "requests" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/2e/d22899abfdbc6fdd33860152f2108e6f377b11083e951bb67e6472e0247b/jupyter_server_client-0.1.1-py3-none-any.whl", hash = "sha256:5fc28099b95ea4b02e0bc85760507701c4c4315801897129e4b6c606582cf025", size = 19683, upload-time = "2025-10-22T11:19:29.907Z" }, +] + +[[package]] +name = "jupyter-server-fileid" +version = "0.9.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-events" }, + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/eb/7c2c09454bbf66b3727ba8c431d16159d642c0eb1aa179412a4f7af721cf/jupyter_server_fileid-0.9.3.tar.gz", hash = "sha256:521608bb87f606a8637fcbdce2f3d24a8b3cc89d2eef61751cb40e468d4e54be", size = 54959, upload-time = "2024-09-06T07:18:40.412Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/d6/5e5bca083664b1dd368e261107cbe2d350e3bdc62bdba8720fdbb9b9db39/jupyter_server_fileid-0.9.3-py3-none-any.whl", hash = "sha256:f73c01c19f90005d3fff93607b91b4955ba4e1dccdde9bfe8026646f94053791", size = 16922, upload-time = "2024-09-06T07:18:38.445Z" }, +] + +[[package]] +name = "jupyter-server-nbmodel" +version = "0.1.1a4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/2a/1d13aa10cd573f6b823acc833f6f4cf6d1c2bd3b201f066496b78f964ed6/jupyter_server_nbmodel-0.1.1a4.tar.gz", hash = "sha256:ee072daa1e6b09db53f20e8f2d180d4f5e68dbff40003ad14dddfea8addf5cc3", size = 207265, upload-time = "2025-10-30T15:12:02.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/70/23edf6756dd2ae7c81ce5c2add66d986674d58072192152b80d417efbc4d/jupyter_server_nbmodel-0.1.1a4-py3-none-any.whl", hash = "sha256:f1c40906aaf98d6b66c3c9d5ebd6cad1b278d00c09d0a9227b0c15d972ec399a", size = 35316, upload-time = "2025-10-30T15:11:59.987Z" }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" }, +] + +[[package]] +name = "jupyter-server-ydoc" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema" }, + { name = "jupyter-events" }, + { name = "jupyter-server" }, + { name = "jupyter-server-fileid" }, + { name = "jupyter-ydoc" }, + { name = "pycrdt" }, + { name = "pycrdt-websocket" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/fb/88a92c659864429342ab0d6c3b4829cdc6b008df10484820224e3871cf7b/jupyter_server_ydoc-2.4.0.tar.gz", hash = "sha256:74631f47a55d9dadf7dc918d78a083feaecc6c36af4d2fcdf26c0ee36bf70372", size = 33271, upload-time = "2026-05-11T11:04:41.019Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/6e/ec1dfa20b8efdf782a9fb162abc5e6a394bd122c21a0c9ff55e0e60f5a35/jupyter_server_ydoc-2.4.0-py3-none-any.whl", hash = "sha256:0442bf1e2ef8da16d7f0fb541db5080b249b43f098616cf8cd7dd173e4ae6cef", size = 34151, upload-time = "2026-05-11T11:04:39.135Z" }, +] + +[[package]] +name = "jupyter-ydoc" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "pycrdt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f7/400e8ee54adb2396f7a70a85a8951bc696303a9bd413c5e35cc6c0c5c214/jupyter_ydoc-3.4.1.tar.gz", hash = "sha256:fb31f0e7033b8a5bf8920334e2b3dd9bdaba3052de3164de28e14525fd0bc4d8", size = 973504, upload-time = "2026-04-14T12:14:19.967Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/ff/15eca734d96277895573026dff14edd63d9d1709c02363f5902ea9767d71/jupyter_ydoc-3.4.1-py3-none-any.whl", hash = "sha256:848e5a9f37403846b7554b87d71495a38b6249579af64b1bde8de650b2e49d65", size = 14534, upload-time = "2026-04-14T12:14:18.439Z" }, +] + +[[package]] +name = "jupyterlab" +version = "4.5.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2b/22/8440ec827762146e7cdecf04335bd348795899d29dc6ae82238707353a2c/jupyterlab-4.5.7.tar.gz", hash = "sha256:55a9822c4754da305f41e113452c68383e214dcf96de760146af89ce5d5117b0", size = 23992763, upload-time = "2026-04-29T16:43:51.328Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/aa/537b8f7d80e799af19af35fb3ddfc970b951088a13c57dd9387dcfbb7f61/jupyterlab-4.5.7-py3-none-any.whl", hash = "sha256:fba4cb0e2c44a52859669d8c98b45de029d5e515f8407bf8534d2a8fc5f0964d", size = 12450123, upload-time = "2026-04-29T16:43:46.639Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.28.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" }, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/2d/ef58fed122b268c69c0aa099da20bc67657cdfb2e222688d5731bd5b971d/jupyterlab_widgets-3.0.16.tar.gz", hash = "sha256:423da05071d55cf27a9e602216d35a3a65a3e41cdf9c5d3b643b814ce38c19e0", size = 897423, upload-time = "2025-11-01T21:11:29.724Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl", hash = "sha256:45fa36d9c6422cf2559198e4db481aa243c7a32d9926b500781c830c80f7ecf8", size = 914926, upload-time = "2025-11-01T21:11:28.008Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, +] + +[[package]] +name = "lark" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, +] + +[[package]] +name = "lazy-loader" +version = "0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/ac/21a1f8aa3777f5658576777ea76bfb124b702c520bbe90edf4ae9915eafa/lazy_loader-0.5.tar.gz", hash = "sha256:717f9179a0dbed357012ddad50a5ad3d5e4d9a0b8712680d4e687f5e6e6ed9b3", size = 15294, upload-time = "2026-03-06T15:45:09.054Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/a1/8d812e53a5da1687abb10445275d41a8b13adb781bbf7196ddbcf8d88505/lazy_loader-0.5-py3-none-any.whl", hash = "sha256:ab0ea149e9c554d4ffeeb21105ac60bed7f3b4fd69b1d2360a4add51b170b005", size = 8044, upload-time = "2026-03-06T15:45:07.668Z" }, +] + +[[package]] +name = "llvmlite" +version = "0.47.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/88/a8952b6d5c21e74cbf158515b779666f692846502623e9e3c39d8e8ba25f/llvmlite-0.47.0.tar.gz", hash = "sha256:62031ce968ec74e95092184d4b0e857e444f8fdff0b8f9213707699570c33ccc", size = 193614, upload-time = "2026-03-31T18:29:53.497Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/6f/4615353e016799f80fa52ccb270a843c413b22361fadda2589b2922fb9b0/llvmlite-0.47.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a3c6a735d4e1041808434f9d440faa3d78d9b4af2ee64d05a66f351883b6ceec", size = 37232771, upload-time = "2026-03-31T18:29:01.324Z" }, + { url = "https://files.pythonhosted.org/packages/31/b8/69f5565f1a280d032525878a86511eebed0645818492feeb169dfb20ae8e/llvmlite-0.47.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2699a74321189e812d476a43d6d7f652f51811e7b5aad9d9bba842a1c7927acb", size = 56275178, upload-time = "2026-03-31T18:29:05.748Z" }, + { url = "https://files.pythonhosted.org/packages/d6/da/b32cafcb926fb0ce2aa25553bf32cb8764af31438f40e2481df08884c947/llvmlite-0.47.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c6951e2b29930227963e53ee152441f0e14be92e9d4231852102d986c761e40", size = 55128632, upload-time = "2026-03-31T18:29:11.235Z" }, + { url = "https://files.pythonhosted.org/packages/46/9f/4898b44e4042c60fafcb1162dfb7014f6f15b1ec19bf29cfea6bf26df90d/llvmlite-0.47.0-cp313-cp313-win_amd64.whl", hash = "sha256:c2e9adf8698d813a9a5efb2d4370caf344dbc1e145019851fee6a6f319ba760e", size = 38138695, upload-time = "2026-03-31T18:29:15.43Z" }, + { url = "https://files.pythonhosted.org/packages/1c/d4/33c8af00f0bf6f552d74f3a054f648af2c5bc6bece97972f3bfadce4f5ec/llvmlite-0.47.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:de966c626c35c9dff5ae7bf12db25637738d0df83fc370cf793bc94d43d92d14", size = 37232773, upload-time = "2026-03-31T18:29:19.453Z" }, + { url = "https://files.pythonhosted.org/packages/64/1d/a760e993e0c0ba6db38d46b9f48f6c7dceb8ac838824997fb9e25f97bc04/llvmlite-0.47.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ddbccff2aeaff8670368340a158abefc032fe9b3ccf7d9c496639263d00151aa", size = 56275176, upload-time = "2026-03-31T18:29:24.149Z" }, + { url = "https://files.pythonhosted.org/packages/84/3b/e679bc3b29127182a7f4aa2d2e9e5bea42adb93fb840484147d59c236299/llvmlite-0.47.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4a7b778a2e144fc64468fb9bf509ac1226c9813a00b4d7afea5d988c4e22fca", size = 55128631, upload-time = "2026-03-31T18:29:29.536Z" }, + { url = "https://files.pythonhosted.org/packages/be/f7/19e2a09c62809c9e63bbd14ce71fb92c6ff7b7b3045741bb00c781efc3c9/llvmlite-0.47.0-cp314-cp314-win_amd64.whl", hash = "sha256:694e3c2cdc472ed2bd8bd4555ca002eec4310961dd58ef791d508f57b5cc4c94", size = 39153826, upload-time = "2026-03-31T18:29:33.681Z" }, + { url = "https://files.pythonhosted.org/packages/40/a1/581a8c707b5e80efdbbe1dd94527404d33fe50bceb71f39d5a7e11bd57b7/llvmlite-0.47.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:92ec8a169a20b473c1c54d4695e371bde36489fc1efa3688e11e99beba0abf9c", size = 37232772, upload-time = "2026-03-31T18:29:37.952Z" }, + { url = "https://files.pythonhosted.org/packages/11/03/16090dd6f74ba2b8b922276047f15962fbeea0a75d5601607edb301ba945/llvmlite-0.47.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fa1cbd800edd3b20bc141521f7fd45a6185a5b84109aa6855134e81397ffe72b", size = 56275178, upload-time = "2026-03-31T18:29:42.58Z" }, + { url = "https://files.pythonhosted.org/packages/f5/cb/0abf1dd4c5286a95ffe0c1d8c67aec06b515894a0dd2ac97f5e27b82ab0b/llvmlite-0.47.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6725179b89f03b17dabe236ff3422cb8291b4c1bf40af152826dfd34e350ae8", size = 55128632, upload-time = "2026-03-31T18:29:46.939Z" }, + { url = "https://files.pythonhosted.org/packages/4f/79/d3bbab197e86e0ff4f9c07122895b66a3e0d024247fcff7f12c473cb36d9/llvmlite-0.47.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6842cf6f707ec4be3d985a385ad03f72b2d724439e118fcbe99b2929964f0453", size = 39153839, upload-time = "2026-03-31T18:29:51.004Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/d3/8d4f6afbecb49fc04e060a57c0fce39ea51cc163a6bd87303ccd698e4fa6/matplotlib-3.10.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b580440f1ff81a0e34122051a3dfabb7e4b7f9e380629929bde0eff9af72165f", size = 8320331, upload-time = "2026-04-24T00:12:39.688Z" }, + { url = "https://files.pythonhosted.org/packages/63/d9/9e14bc7564bf92d5ffa801ae5fac819ce74b925dfb55e3ebde61a3bbad3e/matplotlib-3.10.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b1b745c489cd1a77a0dc1120a05dc87af9798faebc913601feb8c73d89bf2d1e", size = 8216461, upload-time = "2026-04-24T00:12:42.494Z" }, + { url = "https://files.pythonhosted.org/packages/8a/17/4402d0d14ccf1dfc70932600b68097fbbf9c898a4871d2cbbe79c7801a32/matplotlib-3.10.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8f3bcac1ca5ed000a6f4337d47ba67dfddf37ed6a46c15fd7f014997f7bf865f", size = 8790091, upload-time = "2026-04-24T00:12:44.789Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0b/322aeec06dd9b91411f92028b37d447342770a24392aa4813e317064dad5/matplotlib-3.10.9-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a8d66a55def891c33147ba3ba9bfcabf0b526a43764c818acbb4525e5ed0838", size = 9605027, upload-time = "2026-04-24T00:12:47.583Z" }, + { url = "https://files.pythonhosted.org/packages/74/88/5f13482f55e7b00bcfc09838b093c2456e1379978d2a146844aae05350ad/matplotlib-3.10.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d843374407c4017a6403b59c6c81606773d136f3259d5b6da3131bc814542cc2", size = 9671269, upload-time = "2026-04-24T00:12:50.878Z" }, + { url = "https://files.pythonhosted.org/packages/c5/e0/0840fd2f93da988ec660b8ad1984abe9f25d2aed22a5e394ff1c68c88307/matplotlib-3.10.9-cp313-cp313-win_amd64.whl", hash = "sha256:f4399f64b3e94cd500195490972ae1ee81170df1636fa15364d157d5bdd7b921", size = 8217588, upload-time = "2026-04-24T00:12:53.784Z" }, + { url = "https://files.pythonhosted.org/packages/47/b9/d706d06dd605c49b9f83a2aed8c13e3e5db70697d7a80b7e3d7915de6b17/matplotlib-3.10.9-cp313-cp313-win_arm64.whl", hash = "sha256:ba7b3b8ef09eab7df0e86e9ae086faa433efbfbdb46afcb3aa16aabf779469a8", size = 8136913, upload-time = "2026-04-24T00:12:56.501Z" }, + { url = "https://files.pythonhosted.org/packages/9b/45/6e32d96978264c8ca8c4b1010adb955a1a49cfaf314e212bbc8908f04a61/matplotlib-3.10.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:09218df8a93712bd6ea133e83a153c755448cf7868316c531cffcc43f69d1cc9", size = 8368019, upload-time = "2026-04-24T00:12:58.896Z" }, + { url = "https://files.pythonhosted.org/packages/86/0a/c8e3d3bba245f0f7fc424937f8ff7ef77291a36af3edb97ccd78aa93d84f/matplotlib-3.10.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:82368699727bfb7b0182e1aa13082e3c08e092fa1a25d3e1fd92405bff96f6d4", size = 8264645, upload-time = "2026-04-24T00:13:01.406Z" }, + { url = "https://files.pythonhosted.org/packages/3d/aa/5bf5a14fe4fed73a4209a155606f8096ff797aad89c6c35179026571133e/matplotlib-3.10.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3225f4e1edcb8c86c884ddf79ebe20ecd0a67d30188f279897554ccd8fded4dc", size = 8802194, upload-time = "2026-04-24T00:13:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/dd/5e/b4be852d6bba6fd15893fadf91ff26ae49cb91aac789e95dde9d342e664f/matplotlib-3.10.9-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de2445a0c6690d21b7eb6ce071cebad6d40a2e9bdf10d039074a96ba19797b99", size = 9622684, upload-time = "2026-04-24T00:13:06.647Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/ed428c971139112ef730f62770654d609467346d09d4b62617e1afd68a5a/matplotlib-3.10.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b2b9516251cb89ff618d757daec0e2ed1bf21248013844a853d87ef85ab3081d", size = 9680790, upload-time = "2026-04-24T00:13:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/e7/09/052e884aaf2b985c63cb79f715f1d5b6a3eaa7de78f6a52b9dbc077d5b53/matplotlib-3.10.9-cp313-cp313t-win_amd64.whl", hash = "sha256:e9fae004b941b23ff2edcf1567a857ed77bafc8086ffa258190462328434faf8", size = 8287571, upload-time = "2026-04-24T00:13:13.087Z" }, + { url = "https://files.pythonhosted.org/packages/f4/38/ae27288e788c35a4250491422f3db7750366fc8c97d6f36fbdecfc1f5518/matplotlib-3.10.9-cp313-cp313t-win_arm64.whl", hash = "sha256:6b63d9c7c769b88ab81e10dc86e4e0607cf56817b9f9e6cf24b2a5f1693b8e38", size = 8188292, upload-time = "2026-04-24T00:13:15.546Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e6/3bd8afd04949f02eabc1c17115ea5255e19cacd4d06fc5abdde4eeb0052c/matplotlib-3.10.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:172db52c9e683f5d12eaf57f0f54834190e12581fe1cc2a19595a8f5acb4e77d", size = 8321276, upload-time = "2026-04-24T00:13:18.318Z" }, + { url = "https://files.pythonhosted.org/packages/41/86/86231232fff41c9f8e4a1a7d7a597d349a02527109c3af7d618366122139/matplotlib-3.10.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97e35e8d39ccc85859095e01a53847432ba9a53ddf7986f7a54a11b73d0e143f", size = 8218218, upload-time = "2026-04-24T00:13:20.974Z" }, + { url = "https://files.pythonhosted.org/packages/85/8f/becc9722cafc64f5d2eb0b7c1bf5f585271c618a45dbd8fabeb021f898b6/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aba1615dabe83188e19d4f75a253c6a08423e04c1425e64039f800050a69de6b", size = 9608145, upload-time = "2026-04-24T00:13:23.228Z" }, + { url = "https://files.pythonhosted.org/packages/32/5d/f7e914f7d9325abff4057cee62c0fa70263683189f774473cbfb534cd13b/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34cf8167e023ad956c15f36302911d5406bd99a9862c1a8499ea6f7c0e015dc2", size = 9885085, upload-time = "2026-04-24T00:13:25.849Z" }, + { url = "https://files.pythonhosted.org/packages/a5/fd/fa69f2221534e80cc5772ac2b7d222011a2acafc2ec7216d5dd174c864ae/matplotlib-3.10.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:59476c6d29d612b8e9bb6ce8c5b631be6ba8f9e3a2421f22a02b192c7dd28716", size = 9672358, upload-time = "2026-04-24T00:13:28.906Z" }, + { url = "https://files.pythonhosted.org/packages/ab/1a/5a4f747a8b271cbb024946d2dd3c913ab5032ba430626f8c3528ada96b4b/matplotlib-3.10.9-cp314-cp314-win_amd64.whl", hash = "sha256:336b9acc64d309063126edcdaca00db9373af3c476bb94388fe9c5a53ad13e6f", size = 8349970, upload-time = "2026-04-24T00:13:31.904Z" }, + { url = "https://files.pythonhosted.org/packages/64/dc/95d60ecaefe30680a154b52ea96ab4b0dab547f1fd6aa12f5fb655e89cae/matplotlib-3.10.9-cp314-cp314-win_arm64.whl", hash = "sha256:2dc9477819ffd78ad12a20df1d9d6a6bd4fec6aaa9072681465fddca052f1456", size = 8272785, upload-time = "2026-04-24T00:13:34.511Z" }, + { url = "https://files.pythonhosted.org/packages/70/a0/005d68bc8b8418300ce6591f18586910a8526806e2ab663933d9f20a41e9/matplotlib-3.10.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:da4e09638420548f31c354032a6250e473c68e5a4e96899b4844cf39ddea23fe", size = 8367999, upload-time = "2026-04-24T00:13:36.962Z" }, + { url = "https://files.pythonhosted.org/packages/22/05/1236cc9290be70b2498af20ca348add76e3fffe7f67b477db5133a84f3ea/matplotlib-3.10.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:345f6f68ecc8da0ca56fad2ea08fde1a115eda530079eca185d50a7bc3e146c6", size = 8264543, upload-time = "2026-04-24T00:13:39.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c2/071f5a5ff6c5bd63aaaf2f45c811d9bf2ced94bde188d9e1a519e21d0cba/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4edcfbd8565339aa62f1cd4012f7180926fdbe71850f7b0d3c379c175cd6b66c", size = 9622800, upload-time = "2026-04-24T00:13:42.296Z" }, + { url = "https://files.pythonhosted.org/packages/95/57/da7d1f10a85624b9e7db68e069dd94e58dc41dbf9463c5921632ecbe3661/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6be157fe17fc37cb95ac1d7374cf717ce9259616edec911a78d9d26dae8522d4", size = 9888561, upload-time = "2026-04-24T00:13:45.026Z" }, + { url = "https://files.pythonhosted.org/packages/67/b2/ef8d6bb59b0edb6c16c968b70f548aa13b54348972def5aa6ac85df67145/matplotlib-3.10.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4e42042d54db34fda4e95a7bd3e5789c2a995d2dad3eb8850232ee534092fbbf", size = 9680884, upload-time = "2026-04-24T00:13:48.066Z" }, + { url = "https://files.pythonhosted.org/packages/61/1c/d21bfeb9931881ebe96bcfcff27c7ae4b160ae0ec291a714c42641a56d75/matplotlib-3.10.9-cp314-cp314t-win_amd64.whl", hash = "sha256:c27df8b3848f32a83d1767566595e43cfaa4460380974da06f4279a7ec143c39", size = 8432333, upload-time = "2026-04-24T00:13:51.008Z" }, + { url = "https://files.pythonhosted.org/packages/78/23/92493c3e6e1b635ccfff146f7b99e674808787915420373ac399283764c2/matplotlib-3.10.9-cp314-cp314t-win_arm64.whl", hash = "sha256:a49f1eadc84ca85fd72fa4e89e70e61bf86452df6f971af04b12c60761a0772c", size = 8324785, upload-time = "2026-04-24T00:13:53.633Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, +] + +[[package]] +name = "mcp" +version = "1.27.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "httpx" }, + { name = "httpx-sse" }, + { name = "jsonschema" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "python-multipart" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "sse-starlette" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, + { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/83/d1efe7c2980d8a3afa476f4e3d42d53dd54c0ab94c27bee5d755b45c8b73/mcp-1.27.1.tar.gz", hash = "sha256:0f47e1820f8f8f941466b39749eb1d1839a04caddca2bc60e9d46e8a99914924", size = 608458, upload-time = "2026-05-08T16:50:12.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/73/42d9596facebdb533b7f0b86c1b0364ef350d1f8ba78b1052e8a58b48b65/mcp-1.27.1-py3-none-any.whl", hash = "sha256:1af3c4203b329430fde7a87b4fcb6392a041f5cb851fd68fc674016ab4e7c06f", size = 216260, upload-time = "2026-05-08T16:50:10.547Z" }, +] + +[package.optional-dependencies] +cli = [ + { name = "python-dotenv" }, + { name = "typer" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "mistune" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/84/620cc3f7e3adf6f5067e10f4dbae71295d8f9e16d5d3f9ef97c40f2f592c/mistune-3.2.1.tar.gz", hash = "sha256:7c8e5501d38bac1582e067e46c8343f17d57ea1aaa735823f3aba1fd59c88a28", size = 98003, upload-time = "2026-05-03T14:33:22.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/7f/a946aa4f8752b37102b41e64dca18a1976ac705c3a0d1dfe74d820a02552/mistune-3.2.1-py3-none-any.whl", hash = "sha256:78cdb0ba5e938053ccf63651b352508d2efa9411dc8810bfb05f2dc5140c0048", size = 53749, upload-time = "2026-05-03T14:33:20.551Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" }, + { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" }, + { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" }, + { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" }, + { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" }, + { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" }, + { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" }, + { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" }, + { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" }, + { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" }, + { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" }, + { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" }, + { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" }, + { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" }, + { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" }, + { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" }, + { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" }, + { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" }, + { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" }, + { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" }, + { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" }, + { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" }, + { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, +] + +[[package]] +name = "nbclient" +version = "0.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/56/91/1c1d5a4b9a9ebba2b4e32b8c852c2975c872aec1fe42ab5e516b2cecd193/nbclient-0.10.4.tar.gz", hash = "sha256:1e54091b16e6da39e297b0ece3e10f6f29f4ac4e8ee515d29f8a7099bd6553c9", size = 62554, upload-time = "2025-12-23T07:45:46.369Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/a0/5b0c2f11142ed1dddec842457d3f65eaf71a0080894eb6f018755b319c3a/nbclient-0.10.4-py3-none-any.whl", hash = "sha256:9162df5a7373d70d606527300a95a975a47c137776cd942e52d9c7e29ff83440", size = 25465, upload-time = "2025-12-23T07:45:44.51Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "networkx" +version = "3.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, +] + +[[package]] +name = "notebook" +version = "7.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/c2/cf59bd2e6f2c8b976b52477e3e53bf6f97bc714ed046a51821afb428eaee/notebook-7.5.6.tar.gz", hash = "sha256:621174aade80108f0020b0f00738000b215f75fa3cd90771ad7aa0f24536a4e1", size = 14170814, upload-time = "2026-04-30T11:46:26.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/d6/1fd0646b9bbd9efbb0b8ae21b2325fbef515769a5621c03e31d8eb8da587/notebook-7.5.6-py3-none-any.whl", hash = "sha256:4dde3f8fb55fa8fb7946d58c6e869ce9baf46d00fc070664f62604569d0faca0", size = 14581730, upload-time = "2026-04-30T11:46:22.342Z" }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, +] + +[[package]] +name = "numba" +version = "0.65.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "llvmlite" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f6/c5/db2ac3685833d626c0dcae6bd2330cd68433e1fd248d15f70998160d3ad7/numba-0.65.1.tar.gz", hash = "sha256:19357146c32fe9ed25059ab915e8465fb13951cf6b0aace3826b76886373ab23", size = 2765600, upload-time = "2026-04-24T02:02:56.551Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/37/14a4579049c1eb673afd0de0cb4842982acd55b9ce2643e763db858bcea0/numba-0.65.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:1735c15c1134a5108b4d6a5c77fc0947924ea066a738dc09a52008c13df9cad3", size = 2681344, upload-time = "2026-04-24T02:02:33.65Z" }, + { url = "https://files.pythonhosted.org/packages/a0/22/b8d873f6466b20aa563fc9b33acd48dec89a07803ddaa2f1c8ca1cd33126/numba-0.65.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c09f49117ef255e1f1c6dad0c7a1ed39868243862a73be5706793241a3755f1b", size = 3810619, upload-time = "2026-04-24T02:02:36.041Z" }, + { url = "https://files.pythonhosted.org/packages/62/08/e16a8b5d9a018962ebb5c66be662317cde32b9f5dab08441f90bed5522fb/numba-0.65.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:594a8680b3fadac99e97e489b1fd89007177e5336713745c3b769528c635a464", size = 3509783, upload-time = "2026-04-24T02:02:38.245Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a5/03c970d57f4c1741354837353ce39fb5206952ae1dba8922d29c86f64805/numba-0.65.1-cp313-cp313-win_amd64.whl", hash = "sha256:85be74c0d036842699a30058f82fb88fc5ffdc59f7615cab5792ea92914c9b62", size = 2750534, upload-time = "2026-04-24T02:02:39.903Z" }, + { url = "https://files.pythonhosted.org/packages/4f/2e/8aed9b726d9ba5f11ad287645fd479e88278db3060a25cb1225d730eb2b7/numba-0.65.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:33f5eb68eb1c843511615d14663ce60258525d6a4c65ab040e2c2b0c4cf17450", size = 2681554, upload-time = "2026-04-24T02:02:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/87/96/f3eb235fafa82a34e2ab5dd7dc9ffff998ebf5f0bbc23fa56a96aeb44da6/numba-0.65.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:71e73029bf53a62cc6afcf96be4bd942290d8b4c55f0a454fb536158115790f7", size = 3779602, upload-time = "2026-04-24T02:02:43.726Z" }, + { url = "https://files.pythonhosted.org/packages/09/90/b0f09b48752d23640b8284f22aa597737e8adaddc7fbfacc4708b7f73a4c/numba-0.65.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a07635e0be926b9bdbffb09137c230fb13f6ec0e564914ba937cee12ce3eb35", size = 3479532, upload-time = "2026-04-24T02:02:45.427Z" }, + { url = "https://files.pythonhosted.org/packages/56/46/3f7fc04fb853559e74b210e0b62c19974ec844cefec611f9e535f4da3761/numba-0.65.1-cp314-cp314-win_amd64.whl", hash = "sha256:2a20fcdabdefbdacf88d85caf70c3b18c4bcb7ebb8f82e6a19486383dd26ab63", size = 2752637, upload-time = "2026-04-24T02:02:47.664Z" }, + { url = "https://files.pythonhosted.org/packages/81/7b/c1a341a9067367778f4152a5f01061cf281fb09582c92c510ec4918cabf6/numba-0.65.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:548dd4b3a4508d5062768d1514b2cd7b015f9a25ec7af651c50dee243965e652", size = 2684600, upload-time = "2026-04-24T02:02:49.653Z" }, + { url = "https://files.pythonhosted.org/packages/03/36/98ddbcf3e4f04a6dd07e1c67249955920579ba4af6bb6868e3088f4ed282/numba-0.65.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:78abc28feff2c2ff8307fff3975b6438352759c9acb797ecd6b1fb6e7e39e31d", size = 3817198, upload-time = "2026-04-24T02:02:51.266Z" }, + { url = "https://files.pythonhosted.org/packages/a3/83/0dad21057ece5a835599f5d24099b091703995e23dbbf894f259e91c010b/numba-0.65.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee7676cb389555805f9b9a1840cbcd1ea6c8bd5376ab6918e3a29c5ea1dbda20", size = 3533862, upload-time = "2026-04-24T02:02:52.987Z" }, + { url = "https://files.pythonhosted.org/packages/32/36/8be7118ffd4c8440881046eac3d0982cc5ab42909508cf5d67024d62a2e4/numba-0.65.1-cp314-cp314t-win_amd64.whl", hash = "sha256:20609346e3bd75204950dcbbfe383a8d7dbf4902f442aedbf00f97fef4aa8f38", size = 2758237, upload-time = "2026-04-24T02:02:54.612Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" }, + { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" }, + { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" }, + { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" }, + { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" }, + { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" }, + { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" }, + { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" }, + { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" }, + { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" }, + { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" }, + { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" }, + { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" }, + { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" }, + { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" }, + { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" }, + { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" }, + { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" }, + { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" }, + { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" }, + { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" }, + { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" }, + { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" }, + { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" }, + { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" }, + { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" }, + { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" }, +] + +[[package]] +name = "nvidia-cublas" +version = "13.1.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cuda-nvrtc", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/a1/0bd24ee8c8d03adac032fd2909426a00c88f8c57961b1277ded97f91119f/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b7a210458267ac818974c53038fbec2e969d5c99f305ab15c72522fa9f001dd5", size = 542848918, upload-time = "2026-04-08T18:46:22.985Z" }, + { url = "https://files.pythonhosted.org/packages/3b/cd/154ca20c38269e05eff77c1464e6c1da89f50a6390b565e9d82e06bc11e1/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:37936a16db8fe4ac1f065c2139360608a543a09275cb1a1af612e08cfa065436", size = 423138758, upload-time = "2026-04-08T18:46:58.655Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti" +version = "13.0.85" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" }, + { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc" +version = "13.0.88" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" }, + { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime" +version = "13.0.96" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" }, + { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu13" +version = "9.20.0.48" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/c5/83384d846b2fd17c44bd499b36c75a45ed4f095fbbb2252294e89cea5c5c/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:e31454ae00094b0c55319d9d15b6fa2fc50a9e1c0f5c8c80fb75258234e731e1", size = 444574296, upload-time = "2026-03-09T19:28:27.751Z" }, + { url = "https://files.pythonhosted.org/packages/6e/5e/edb9c0ae051602c3ccaffe424256463636d639e27d7f302dde9975ef9e7a/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0c45dd8eeb50b603f07995b1b300c62ffe6a1980482b82b3bcf94a4ca9d49304", size = 366173588, upload-time = "2026-03-09T19:29:34.474Z" }, +] + +[[package]] +name = "nvidia-cufft" +version = "12.0.0.61" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" }, +] + +[[package]] +name = "nvidia-cufile" +version = "1.15.1.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" }, + { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" }, +] + +[[package]] +name = "nvidia-curand" +version = "10.4.0.35" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" }, +] + +[[package]] +name = "nvidia-cusolver" +version = "12.0.4.66" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cusparse", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" }, +] + +[[package]] +name = "nvidia-cusparse" +version = "12.6.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, + { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu13" +version = "0.8.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/e1/cdc1797eadf82d3a9a575a19b33fdc871a97edbec42c00b5b5e914f4aff4/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4dca476c50bf4780d46cd0bfbd82e2bc10a08e4fef7950917ce8d7578d22a23f", size = 221051344, upload-time = "2025-09-05T18:49:51.289Z" }, + { url = "https://files.pythonhosted.org/packages/34/7d/2661f2fb3ac4302f3a246f5fc030213ac60c1fe0bce84f9783dbd831dbb7/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:786ce87568c303fadb5afcc7102d454cd3040d75f6f8626f5db460d1871f4dd0", size = 170148586, upload-time = "2025-09-05T18:50:50.248Z" }, +] + +[[package]] +name = "nvidia-nccl-cu13" +version = "2.29.7" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/0d/daf50d44177ee0cbc7ff0a0c91eb5ff676c82be42f9a970bc7597f440c3a/nvidia_nccl_cu13-2.29.7-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:674a12383e3c38a1bcccae7d4f3633b37852230b6047883cb2f4c2d1b36d9bf5", size = 206014712, upload-time = "2026-03-03T05:34:20.843Z" }, + { url = "https://files.pythonhosted.org/packages/67/f4/58e4e91b6919367c7aafb8e36fce9aad1a3047e536bf7e2fd560927d3a4c/nvidia_nccl_cu13-2.29.7-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:edd81538446786ec3b73972543e53bb43bcaf0bfc8ef76cb679fcc390ffe136d", size = 205976000, upload-time = "2026-03-03T05:36:24.472Z" }, +] + +[[package]] +name = "nvidia-nvjitlink" +version = "13.0.88" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/7a/123e033aaff487c77107195fa5a2b8686795ca537935a24efae476c41f05/nvidia_nvjitlink-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:13a74f429e23b921c1109976abefacc69835f2f433ebd323d3946e11d804e47b", size = 40713933, upload-time = "2025-09-04T08:35:43.553Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2c/93c5250e64df4f894f1cbb397c6fd71f79813f9fd79d7cd61de3f97b3c2d/nvidia_nvjitlink-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e931536ccc7d467a98ba1d8b89ff7fa7f1fa3b13f2b0069118cd7f47bff07d0c", size = 38768748, upload-time = "2025-09-04T08:35:20.008Z" }, +] + +[[package]] +name = "nvidia-nvshmem-cu13" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" }, + { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" }, +] + +[[package]] +name = "nvidia-nvtx" +version = "13.0.85" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" }, + { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" }, +] + +[[package]] +name = "omegaconf" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "antlr4-python3-runtime" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7", size = 3298120, upload-time = "2022-12-08T20:59:22.753Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b", size = 79500, upload-time = "2022-12-08T20:59:19.686Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "flatbuffers" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/a2/c801242685e0ce48a4ca51dfafbb588765e0446397e123be53ba5598f3f5/onnxruntime-1.26.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccce19c5f771b8268902f77d9fed9e88f9499465d6780808faa6611a789d33f0", size = 18016563, upload-time = "2026-05-08T19:07:28.081Z" }, + { url = "https://files.pythonhosted.org/packages/e2/64/0492c0b1db04e29b2630c87cfa36f9d6872b1ca8614b90c5cad58fac7d76/onnxruntime-1.26.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bdbed8cf3b672b66acb032f33a253bc27f42bce6ece48ae3fab4fa483a5e96e0", size = 16052634, upload-time = "2026-05-08T19:07:16.885Z" }, + { url = "https://files.pythonhosted.org/packages/3d/26/4d09ddc755a84fc8d5e192991626b0e0680e8f6c5d58f4f1d05c42bc48cf/onnxruntime-1.26.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c07af6fc6d5557835f2b6ee7a96d8b3235d0c57a8e230efdedaee106a8a3cbc6", size = 18185632, upload-time = "2026-05-08T19:07:38.756Z" }, + { url = "https://files.pythonhosted.org/packages/77/89/3e52249aa08fa301e217ecba07b5246a8338fa2b401e109326e3fc5be0f9/onnxruntime-1.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:61bec80655efa460591c2bc655392d57d2650ce85533a6b9b3b7a790d7ea7916", size = 13026751, upload-time = "2026-05-08T19:08:06.2Z" }, + { url = "https://files.pythonhosted.org/packages/06/b3/c1c8782b14af6797c303de132d6eef26a9fb80dfacd3750ce57911d11c6b/onnxruntime-1.26.0-cp313-cp313-win_arm64.whl", hash = "sha256:a6677545ff451e3539a02746d2f207d8c5baa4a0a818886bb9d6a6eb9511ee89", size = 12796807, upload-time = "2026-05-08T19:07:54.879Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f5/47b0676408abec652c14b84d7173e389837832d850c24f87184277313e8d/onnxruntime-1.26.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e016edc15d3c19f36807e1c6b10be5b27807688c32720f91b5ae480a95215d0", size = 16057265, upload-time = "2026-05-08T19:07:19.603Z" }, + { url = "https://files.pythonhosted.org/packages/3b/45/33ab6deeef010ca844c877dd618cebc079590bbe52d2a3678e7223b1b908/onnxruntime-1.26.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5fc48a91a046a6a5c9b147f83fb41d65d24d24923373b222cdd248f0f4f4aac", size = 18197590, upload-time = "2026-05-08T19:07:41.422Z" }, + { url = "https://files.pythonhosted.org/packages/40/89/17546c1c20f6bfc3ae41c22152378a26edfea918af3129e2139dcd7c99f3/onnxruntime-1.26.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:33a791f31432a3af1a96db5e54818b37aba5e5eefc2e6af5794c10a9118a9993", size = 18019724, upload-time = "2026-05-08T19:07:30.723Z" }, + { url = "https://files.pythonhosted.org/packages/bb/24/89457a35f6af29538a76647f2c18c3a28277e6c19234c847e7b4b7c19860/onnxruntime-1.26.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e90c00732c4553618103149d93f688e8c3063017938f8983e21a71d9f3b6d22e", size = 16054821, upload-time = "2026-05-08T19:07:22.348Z" }, + { url = "https://files.pythonhosted.org/packages/12/f9/15b2e1815cf570d238e0135529f80d2dce64e8e8818a1489cae83823c5c6/onnxruntime-1.26.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01498e80ba8988428d08c2d51b1338f89e3de2a93e6ffe555f79c68f26a5c06b", size = 18185815, upload-time = "2026-05-08T19:07:44.179Z" }, + { url = "https://files.pythonhosted.org/packages/d7/65/2e11055faf015e4b07f45b513fa49b391baf2e19d92d77d73ebee13c1004/onnxruntime-1.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:7ead61450d8405167c87dd3a31d8da1d576b490a57dab1aa8b82a7da6825f5aa", size = 13349887, upload-time = "2026-05-08T19:08:08.671Z" }, + { url = "https://files.pythonhosted.org/packages/19/e4/0f9d1a5718b1781c610c1e354765a3820597081754277a6a9a2b50705702/onnxruntime-1.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:31d71a53490e46910877d0902b5ad99c69a5955e5c7ea6c82863519410e1ba7c", size = 13140121, upload-time = "2026-05-08T19:07:57.804Z" }, + { url = "https://files.pythonhosted.org/packages/1c/42/3b8e635f067d06d9f45bede470b8d539d101a4166c272213158dfd08b6ce/onnxruntime-1.26.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7b6d258fb78fdfcf049795bcfaa74dcb90ae7baa277afd21e6fd28b83f2c496", size = 16057240, upload-time = "2026-05-08T19:07:25.163Z" }, + { url = "https://files.pythonhosted.org/packages/93/99/f2be40a31b908d96b861ae0ce98582fa376c18a7f816b9d5eb4cd6aa0a4c/onnxruntime-1.26.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4eefd386a45202aefb7a5132b94f32df9d506c9edcc7faf2fc60d65183f4b183", size = 18197382, upload-time = "2026-05-08T19:07:46.965Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.42.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b4/1c/125e1c936c0873796771b7f04f6c93b9f1bf5d424cea90fda94a99f61da8/opentelemetry_api-1.42.1.tar.gz", hash = "sha256:56c63bea9f77b62856be8c47600474acad853b2924b99b1687c4cb6297166716", size = 72296, upload-time = "2026-05-21T16:32:49.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/ca/9520cc1f3dfbbd03ac5903bbf55833e257bc64b1cf30fa8b0d6df374d821/opentelemetry_api-1.42.1-py3-none-any.whl", hash = "sha256:51a69edacadbc03a8950ace1c4c21099cacc538820ac2c9e36277e78cebba714", size = 61311, upload-time = "2026-05-21T16:32:28.822Z" }, +] + +[[package]] +name = "opentelemetry-sdk" +version = "1.42.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "opentelemetry-semantic-conventions" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/f7/b390bd9bfd703bf98a68fea1f27786c6872331fd617164a54b8a59bdc008/opentelemetry_sdk-1.42.1.tar.gz", hash = "sha256:8c834e8f8c9ba4171d4ec843d0cb8a67e4c7394d3f9e9297e582cbd9456ddbf7", size = 239262, upload-time = "2026-05-21T16:33:04.641Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/6b/4287766cfbde577ae2272e8884abac325aeaac0d64f41c61d5b8cc595105/opentelemetry_sdk-1.42.1-py3-none-any.whl", hash = "sha256:083cd4bbfaa5aa7b5a9e552430d9951219967cfb27aa61feb13a77aba1fc839d", size = 170907, upload-time = "2026-05-21T16:32:45.894Z" }, +] + +[[package]] +name = "opentelemetry-semantic-conventions" +version = "0.63b1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/93/99/4d7dd6df64795951413ce6e815f8cf1eb191daf7196ae86574589643d5f3/opentelemetry_semantic_conventions-0.63b1.tar.gz", hash = "sha256:3daf963611334b365e98a57438183eb012d3bfb40b2d931a9af613476b8701a9", size = 148340, upload-time = "2026-05-21T16:33:05.455Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/7a/7fe66f5f3682b1dd47d88cc4e11f1c6c0966b737de2d16671146e23c39a5/opentelemetry_semantic_conventions-0.63b1-py3-none-any.whl", hash = "sha256:dfe5ef4dee82586b746f522b818ceb298d00b3d59f660042bd79404bff8d0682", size = 203713, upload-time = "2026-05-21T16:32:47.016Z" }, +] + +[[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]] +name = "pandas" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/90/62d8302883c44308c477e222c3daf7c813a34c8e96985882fbd53d964352/pandas-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:67b3b64c11910cfa29f4e94a14d3bff9ee693b6fc76055e7cad549cee0aec5fa", size = 10331071, upload-time = "2026-05-11T18:52:58.838Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ae/6a6493c783a101f165e4356953ba3c74d6f77f0042fa7d753da9dfbb640c/pandas-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:39436b377d56d2a2e52d0395bdbee171f01068e99af5250509aceeb929f765c7", size = 9875690, upload-time = "2026-05-11T18:53:01.431Z" }, + { url = "https://files.pythonhosted.org/packages/62/7c/5df8e9f56c69a2769fbe9382a5ef8f2658c007e376434e1e2cbb57ad895f/pandas-3.0.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4be06d68f9ddcfc645b87534911da79a8fbffc7573c80e0edcf42a5020624d8", size = 10381634, upload-time = "2026-05-11T18:53:04.393Z" }, + { url = "https://files.pythonhosted.org/packages/99/68/1237369725aa617bb358263d535803e3053fdbc593513ec5ed9c9896b5b6/pandas-3.0.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a4eeb6830daf35a71cc09649bd823e2b542dac246cdee9614c6e4bd65028cd6a", size = 10891243, upload-time = "2026-05-11T18:53:07.643Z" }, + { url = "https://files.pythonhosted.org/packages/25/93/77d108e8af7222b4a503ebde0e30215b1c2e4f8e53a526431890f22d5586/pandas-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1928e07221f82db493cd4af1e23c1bfca524a19a4699887975bff68f49a72bfb", size = 11388659, upload-time = "2026-05-11T18:53:10.634Z" }, + { url = "https://files.pythonhosted.org/packages/d0/bd/eff5b4399f332ac386c853f6cd2bd3fa2ca0061b9f36ecd9c4d7c4265649/pandas-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51b1fe551acb77dac643c6fda86084d8d446c10fe64b06a9cc29c4cc8540e7f2", size = 11942880, upload-time = "2026-05-11T18:53:13.536Z" }, + { url = "https://files.pythonhosted.org/packages/2c/20/559ace4200982c3887d0b86bfd0d856a2143ef8ddab63cc07934951a964c/pandas-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:a82d532a3351d435432cd913edbccaf8b8e01d4dd0e5ced5a8d2e8ecd94c7e44", size = 9757091, upload-time = "2026-05-11T18:53:16.306Z" }, + { url = "https://files.pythonhosted.org/packages/3a/66/69055a09fe200f29f922a3eeec4804611900b95f52d932ece3393c3c0c19/pandas-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:275c14e0fce14a2ec20eee474aecd305478ea3c1e6f6a9d8fe219a165542717e", size = 9057282, upload-time = "2026-05-11T18:53:18.768Z" }, + { url = "https://files.pythonhosted.org/packages/57/0e/efe801b0e6811e8e650cd21b7f2608e30f08a7067e2bf6e8752b0d56ee3c/pandas-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:46997386d528eb40376ecd6b033cf4a8a1e5282580f68f43de875b78cba2199d", size = 10767016, upload-time = "2026-05-11T18:53:21.227Z" }, + { url = "https://files.pythonhosted.org/packages/ea/dc/eb55135a1d5f0f0519f28da1f609a206d2cad1f9c35c32d51e38dd7261ae/pandas-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:261e308dfb22448384b7580cf719d2f998fe2966c92893c3e77d14008af1f066", size = 10420210, upload-time = "2026-05-11T18:53:23.982Z" }, + { url = "https://files.pythonhosted.org/packages/c6/3e/b1d5d955ce33ffecb407465a60bc32769d74fcf68224b7ae67ae11d4dea4/pandas-3.0.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd1a5d1def6a46002e964510bdc67c368aa0951df5d1d9f8365336f5a1f490cd", size = 10336126, upload-time = "2026-05-11T18:53:26.731Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/a01261711ab60a22d71b862f0de20e4c504bf80457270ad8cb42110f6abc/pandas-3.0.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d72828c20c6d6e83e1e22a6a3b47b326b71664112fa9705dcbccfd7a39b62085", size = 10728051, upload-time = "2026-05-11T18:53:29.125Z" }, + { url = "https://files.pythonhosted.org/packages/e9/21/ea191195e587b18cf682e97f433f81b2d0fbe341380e80a3e0d6e4403c8e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d26cbe1fcfc12e8fd900e2454163e466b2d3af84f7c75481df7683ffc073d870", size = 11350796, upload-time = "2026-05-11T18:53:32.056Z" }, + { url = "https://files.pythonhosted.org/packages/64/69/f0eaaf54939f0e8c6768fd06be9af2cef9b36048b96dfb9e1b2c685a807e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e91cec1879ada0624fc3dc9953c5cbd60208e59c0db28f540c5d6d47502422f", size = 11799741, upload-time = "2026-05-11T18:53:34.985Z" }, + { url = "https://files.pythonhosted.org/packages/45/a4/865e0e510cae5fc2194de4db28be638952de942571ba9125934fd9c01d47/pandas-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:08d789b41f87e0905880e293cedf6197ce71fe67cc081358b1e148a491b9bd13", size = 10499958, upload-time = "2026-05-11T18:53:37.857Z" }, + { url = "https://files.pythonhosted.org/packages/86/54/effdcc3c0ff7a08037889200e148ebe94c16c4f653be078c7b3675955df1/pandas-3.0.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3650109c0f22879df8bd6179ab9ee3d7f1d1d4e7e0094a3f0032d9f51e2e64ac", size = 10336065, upload-time = "2026-05-11T18:53:41.099Z" }, + { url = "https://files.pythonhosted.org/packages/68/10/bf2d6738d72748b961a3751ab89522d58c54efc36a8e1a12161216cd45cf/pandas-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:bab900348131a7db1f69a7309ef141fd5680f1487094193bcbbb61791573bf8f", size = 9926101, upload-time = "2026-05-11T18:53:43.515Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e9/e35cf11c8a136e757b956f5f0efdcaa50aecde85ea055f1898dfc68262f3/pandas-3.0.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba7e08b9ac1d54569cd1e256e3668975ed624d6826f7b68df0342b012007bddb", size = 10457553, upload-time = "2026-05-11T18:53:46.394Z" }, + { url = "https://files.pythonhosted.org/packages/58/3b/1cdec6772bdbaf7b25dab360c59f03cadf05492dd724c6540af905389b07/pandas-3.0.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d71c63ae4ebdbf70209742096f1fc46a83a0613c99d4b23766cced9ff8cd62a", size = 10914065, upload-time = "2026-05-11T18:53:49.134Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/1ef644445fcd72e3627bceec77e3560636f87ddce4ed841afe76b83b5bf9/pandas-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3a2ec42c98ffa2565a67e08e218d06d72576d758d90facb7c00805194d8f360", size = 11459188, upload-time = "2026-05-11T18:53:52.527Z" }, + { url = "https://files.pythonhosted.org/packages/7e/49/4d8d4f42cbc9c4adc7a1870f269c02cbd6cd40d059622c06fb298addcbad/pandas-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:335f62418ed562cfc3c49e9e196375c28b729dcef8543abf4f9438e381bf3c76", size = 11982966, upload-time = "2026-05-11T18:53:55.043Z" }, + { url = "https://files.pythonhosted.org/packages/38/55/792619469bab9882d8bbd5865d45a72f6478762d04a9af4bf0d08c503e95/pandas-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:3c20a521bbb85902f79f7270c80a59e1b5452d96d170c034f207181870f97ac5", size = 9876755, upload-time = "2026-05-11T18:53:58.067Z" }, + { url = "https://files.pythonhosted.org/packages/2a/af/33c469653b0ba03b50c3a98192d4c07f0c75c66b263ceb097fce0ee97d31/pandas-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:a2d2dff8a04f3917b55ab3910c32990f8ddf7eceba114947838cefa976a68977", size = 9198658, upload-time = "2026-05-11T18:54:00.733Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/b8c257bd76b8bd060c3a9151c1fca05e9b9c5e3af5d0f549c0356f6d143d/pandas-3.0.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0d589105b3c14645af1738ff279b2995102d8f7a03b0a66dc8d95550eb513e04", size = 10787242, upload-time = "2026-05-11T18:54:03.564Z" }, + { url = "https://files.pythonhosted.org/packages/54/eb/f19206ffb0bf1919002969aa448b4702c6594845156a6f8050674855aac3/pandas-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:13fc1e853d9e04743d11ba75a985ccbc2a317fe07d8af61e445a6fd24dacd6a6", size = 10436369, upload-time = "2026-05-11T18:54:06.311Z" }, + { url = "https://files.pythonhosted.org/packages/fd/24/c7c39fb4fe22b71a0c2d78bf0c585c600092d85f94f086d2b3b2f6ca27e2/pandas-3.0.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:819959dab7bbd0049c15623fbac4e29a191b9528160a61fb1032242d8ced2d9c", size = 10358306, upload-time = "2026-05-11T18:54:09.085Z" }, + { url = "https://files.pythonhosted.org/packages/16/ec/dd2a9eb7fa1204df88c0864164e35b228ac581062ac612ba0a67fd812e4c/pandas-3.0.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:60ae316d3fd75d1858d450d0db0103ea2be3e7d4a95ec2f064f7e2ae63f7b028", size = 10758394, upload-time = "2026-05-11T18:54:11.956Z" }, + { url = "https://files.pythonhosted.org/packages/95/6e/00c61ea8e85b4f6d8d35e11852a1a4998fc7fafc91c6a602d1cc9c972d64/pandas-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd3a518890b400d32f9023722dc9a9a5c969f00b415419a3c06c043f09bb5d7d", size = 11375717, upload-time = "2026-05-11T18:54:14.539Z" }, + { url = "https://files.pythonhosted.org/packages/31/89/8fc1c268969fac43688d65fd92e67df24bd128d53cb4d2eee534cd307399/pandas-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c39be2d709d01fa972a0cabc522389fceca4f3969332ba25a7d6c5802cf976a", size = 11828897, upload-time = "2026-05-11T18:54:17.146Z" }, + { url = "https://files.pythonhosted.org/packages/56/3b/e7d20dea247a3e6dc0bd8a6953854afbedc03951def4e7371e05e7263e25/pandas-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4db8c527972a821cf5286b40ccc57642a39bc62e62022b42f99f8a67fca8c3a1", size = 10900855, upload-time = "2026-05-11T18:54:19.72Z" }, + { url = "https://files.pythonhosted.org/packages/0f/54/68a0978d1ef8502b8492099beaa6e7a0c1b32e3b5d4f677f5810cb08711c/pandas-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1", size = 9466464, upload-time = "2026-05-11T18:54:22.754Z" }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.9.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" }, +] + +[[package]] +name = "pooch" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "platformdirs" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/43/85ef45e8b36c6a48546af7b266592dc32d7f67837a6514d111bced6d7d75/pooch-1.9.0.tar.gz", hash = "sha256:de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed", size = 61788, upload-time = "2026-01-30T19:15:09.649Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl", hash = "sha256:f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b", size = 67175, upload-time = "2026-01-30T19:15:08.36Z" }, +] + +[[package]] +name = "prometheus-client" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/fb/d9aa83ffe43ce1f19e557c0971d04b90561b0cfd50762aafb01968285553/prometheus_client-0.25.0.tar.gz", hash = "sha256:5e373b75c31afb3c86f1a52fa1ad470c9aace18082d39ec0d2f918d11cc9ba28", size = 86035, upload-time = "2026-04-09T19:53:42.359Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/9b/d4b1e644385499c8346fa9b622a3f030dce14cd6ef8a1871c221a17a67e7/prometheus_client-0.25.0-py3-none-any.whl", hash = "sha256:d5aec89e349a6ec230805d0df882f3807f74fd6c1a2fa86864e3c2279059fed1", size = 64154, upload-time = "2026-04-09T19:53:41.324Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "propcache" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/09/f049e45385503fe67db75a6b6186a7b9f0c3930366dc960522c312a825b1/propcache-0.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a", size = 94457, upload-time = "2026-05-08T21:00:36.355Z" }, + { url = "https://files.pythonhosted.org/packages/6b/65/83d1d05655baf63113731bd5a1008435e14f8d1e5a06cbe4ec5b23ad7a31/propcache-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117", size = 53835, upload-time = "2026-05-08T21:00:38.072Z" }, + { url = "https://files.pythonhosted.org/packages/a9/12/a6ba6482bb5ea3260c000c9b20881c95fa11c6b30173715668259f844ed7/propcache-0.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098", size = 54545, upload-time = "2026-05-08T21:00:39.319Z" }, + { url = "https://files.pythonhosted.org/packages/a9/19/7fa086f5764c59ec8a8e157cd93aa8497acc00aba9dcdec56bfffb32602d/propcache-0.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6ae2198be502c10f09b2516e7b5d019816924bc3183a43ce792a7bd6625e6f4", size = 59886, upload-time = "2026-05-08T21:00:40.621Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e4/5d7663dc8235956c8f5281698a3af1d351d8820341ddd890f59d9a9127f2/propcache-0.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6041d31504dc1779d700e1edcfb08eea334b357620b06681a4eabb57a74e574e", size = 63261, upload-time = "2026-05-08T21:00:41.775Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4a/15a03adee24d6350da4292caeac44c34c033d2afe5e87eb370f38854560f/propcache-0.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7eabc04151c78a9f4d5bbb5f1faf571e4defeb4b585e0fe95b60ff2dbe4d3d7", size = 64184, upload-time = "2026-05-08T21:00:43.018Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c6/979176efdaa3d239e36d503d5af63a0a773b36662ed8f52e5b6a6d9fd40e/propcache-0.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4db0ba63d693afd40d249bd93f842b5f144f8fcbb83de05660373bcf30517b1d", size = 61534, upload-time = "2026-05-08T21:00:44.507Z" }, + { url = "https://files.pythonhosted.org/packages/c8/22/63e8cd1bae4c2d2be6493b6b7d10566ddafad88137cfbc99964a1119853c/propcache-0.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1dbcf7675229b35d31abb6547d8ebc8c27a830ac3f9a794edff6254873ec7c0a", size = 61500, upload-time = "2026-05-08T21:00:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/60/5a/28e5d9acbac1cc9ccb67045e8c1b943aa8d79fdf39c93bd73cacd68008ea/propcache-0.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d310c013aad2c72f1c3f2f8dd3279d460a858c551f97aeb8c63e4693cca7b4d2", size = 59994, upload-time = "2026-05-08T21:00:47.093Z" }, + { url = "https://files.pythonhosted.org/packages/f3/40/db650677f554a95b9c01a7c9d93d629e93a15562f5deb4573c9ee136fed2/propcache-0.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:06187263ddad280d05b4d8a8b3bb7d164cbebd469236544a42e6d9b28ac6a4fa", size = 56884, upload-time = "2026-05-08T21:00:48.376Z" }, + { url = "https://files.pythonhosted.org/packages/80/45/70b39b89516ff8b96bf732fa6fded8cef20f293cb1508690101c3c07ec51/propcache-0.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3115559b8effafd63b142ea5ed53d63a16ea6469cbc63dce4ee194b42db5d853", size = 63464, upload-time = "2026-05-08T21:00:49.954Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e2/fa59d3a89eac5534293124af4f1d0d0ada091ce4a0ab4610ce03fd2bdd8d/propcache-0.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c60462af8e6dc30c35407c7237ea908d777b22862bbee27bc4699c0d8bcdc45a", size = 61588, upload-time = "2026-05-08T21:00:51.281Z" }, + { url = "https://files.pythonhosted.org/packages/0b/97/efb547a55c4bc7381cfb202d6a2239ac621045277bc1ea5dfd3a7f0516c0/propcache-0.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40314bca9ac559716fe374094fc81c11dcc34b64fd6c585360f5775690505704", size = 64667, upload-time = "2026-05-08T21:00:52.602Z" }, + { url = "https://files.pythonhosted.org/packages/92/56/f5c7d9b4b7595d5127da38974d791b2153f3d1eae6c674af3583ace92ad3/propcache-0.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cfa21e036ce1e1db2be04ba3b85d2df1bb1702fa01932d984c5464c665228ff4", size = 62463, upload-time = "2026-05-08T21:00:54.303Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3b/484a3a65fc9f9f60c41dcd17b428bace5389544e2c680994534a20755066/propcache-0.5.2-cp313-cp313-win32.whl", hash = "sha256:f156a3529f38063b6dbaf356e15602a7f95f8055b1295a438433a6386f10463d", size = 38621, upload-time = "2026-05-08T21:00:55.808Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fd/3f0f10dba4dabad3bf53102be007abf55481067952bde0fdddff439e7c61/propcache-0.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:dfed59d0a5aeb01e242e66ff0300bc4a265a7c05f612d30016f0b60b1017d757", size = 41649, upload-time = "2026-05-08T21:00:57.061Z" }, + { url = "https://files.pythonhosted.org/packages/90/ec/6ce619cc32bb500a482f811f9cd509368b4e58e638d13f2c68f370d6b475/propcache-0.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:ba338430e87ceb9c8f0cf754de38a9860560261e56c00376debd628698a7364f", size = 37636, upload-time = "2026-05-08T21:00:58.646Z" }, + { url = "https://files.pythonhosted.org/packages/1b/82/c1d268bbbf2ef981c5bf0fbbe746db617c66e3bcefe431a1aa8943fbe23a/propcache-0.5.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a592f5f3da71c8691c788c13cb6734b6d17663d2e1cb8caddf0673d01ef8847d", size = 98872, upload-time = "2026-05-08T21:00:59.889Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d4/52c871e73e864e6b34c0e2d58ac1ec5ccd149497ddc7ad2137ae98323a35/propcache-0.5.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6a997d0489e9668a384fcfd5061b857aa5361de73191cac204d04b889cfbbafa", size = 56257, upload-time = "2026-05-08T21:01:01.195Z" }, + { url = "https://files.pythonhosted.org/packages/67/f0/9b90ca2a210b3d09bcfcd96ecd0f55545c091535abce2a45de2775cfd357/propcache-0.5.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:10734b5484ea113152ee25a91dccedf81631791805d2c9ccb054958e51842c94", size = 56696, upload-time = "2026-05-08T21:01:02.941Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0e/6e9d4ba07c8e56e21ddec1e75f12148142b21ca83a51871babce095334f4/propcache-0.5.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cafca7e56c12bb02ae16d283742bef25a61122e9dab2b5b3f2ccbe589ce32164", size = 62378, upload-time = "2026-05-08T21:01:04.475Z" }, + { url = "https://files.pythonhosted.org/packages/65/19/c10badaa463dde8a27ce884f8ee2ec37e6035b7c9f5ff0c8f74f06f08dac/propcache-0.5.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f064f8d2b59177878b7615df1735cd8fe3462ed6be8c7b217d17a276489c2b7f", size = 65283, upload-time = "2026-05-08T21:01:05.959Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b6/93bea99ca80e19cef6512a8580e5b7857bbe09422d9daa7fd4ef5723306c/propcache-0.5.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f78abfa8dfc32376fd1aacf597b2f2fbbe0ea751419aee718af5d4f82537ef8c", size = 66616, upload-time = "2026-05-08T21:01:07.228Z" }, + { url = "https://files.pythonhosted.org/packages/83/e4/5c7462e50625f051f37fb38b8224f7639f667184bbd34424ec83819bb1b7/propcache-0.5.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7467da8a9822bf1a55336f877340c5bcbd3c482afc43a99771169f74a26dedc", size = 63773, upload-time = "2026-05-08T21:01:08.514Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b6/99238894047b13c823be25027e736626cd414a52a5e30d2c3347c2733529/propcache-0.5.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a6ddc6ac9e25de626c1f129c1b467d7ecd33ce2237d3fd0c4e429feef0a7ee1f", size = 63664, upload-time = "2026-05-08T21:01:09.874Z" }, + { url = "https://files.pythonhosted.org/packages/85/1e/a3a1a63116a2b8edb415a8bb9a6f0c34bd03830b1e18e8ce2904e1dc1cf4/propcache-0.5.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f22cbbac9e26a8e864c0985ff1268d5d939d53d9d9411a9824279097e03a2cb", size = 62643, upload-time = "2026-05-08T21:01:11.132Z" }, + { url = "https://files.pythonhosted.org/packages/e4/03/893cf147de2fc6543c5eaa07ad833170e7e2a2385725bbebe8c0503723bb/propcache-0.5.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:fc76378c62a0f04d0cd82fbb1a2cd2d7e28fcb40d5873f28a6c44e388aaa2751", size = 59595, upload-time = "2026-05-08T21:01:12.387Z" }, + { url = "https://files.pythonhosted.org/packages/86/3b/04c1a2e12c57766568ba75ba72b3bf2042818d4c1425fab6fc07155c7cff/propcache-0.5.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:acd2c8edba48e31e58a363b8cf4e5c7db3b04b3f9e371f601df30d9b0d244836", size = 65711, upload-time = "2026-05-08T21:01:13.676Z" }, + { url = "https://files.pythonhosted.org/packages/1c/34/80f8d0099f8d6bacc4de1624c85672681c8cd1149ca2da0e38fd120b817f/propcache-0.5.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:452b5065457eb9991ec5eb38ff41d6cd4c991c9ac7c531c4d5849ae473a9a13f", size = 64247, upload-time = "2026-05-08T21:01:14.936Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1a/8b08f3a5f1037e9e370c55883ceeeee0f6dd0416fb2d2d67b8bfc91f2a79/propcache-0.5.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3430bb2bfe1331885c427745a751e774ee679fd4344f80b97bf879815fe8fa55", size = 67102, upload-time = "2026-05-08T21:01:16.281Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/8bdb7bb7756d76e005490649d10e4a8369e610c74d619f71e1aedf889e9c/propcache-0.5.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cef6cea3922890dd6c9654971001fa797b526c16ab5e1e46c05fd6f877be7568", size = 64964, upload-time = "2026-05-08T21:01:17.57Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/50fb0b5d3968b61a510926ff8b8465f1d6e976b3ab74496d7a4b9fc42515/propcache-0.5.2-cp313-cp313t-win32.whl", hash = "sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191", size = 42546, upload-time = "2026-05-08T21:01:18.946Z" }, + { url = "https://files.pythonhosted.org/packages/ae/4c/0ddbae64321bd4a95bcbfc19307238016b5b1fee645c84626c8d539e5b74/propcache-0.5.2-cp313-cp313t-win_amd64.whl", hash = "sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7", size = 46330, upload-time = "2026-05-08T21:01:20.162Z" }, + { url = "https://files.pythonhosted.org/packages/00/d9/9cddc8efb78d8af264c5ec9f6d10b62f57c515feda8d321595f56010fb23/propcache-0.5.2-cp313-cp313t-win_arm64.whl", hash = "sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96", size = 40521, upload-time = "2026-05-08T21:01:21.399Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ea/23ee535d90ce8bcc465a3028eb3cc0ce3bd1005f4bb27710b30587de798d/propcache-0.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:46088abff4cba581dea21ae0467a480526cb25aa5f3c269e909f800328bc3999", size = 94662, upload-time = "2026-05-08T21:01:22.683Z" }, + { url = "https://files.pythonhosted.org/packages/b5/06/c5a52f419b5d8972f8d46a7577476090d8e3263ff589ce40b5ca4968d5be/propcache-0.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fc88b26f08d634f7bc819a7852e5214f5802641ab8d9fd5326892292eee1993e", size = 53928, upload-time = "2026-05-08T21:01:23.986Z" }, + { url = "https://files.pythonhosted.org/packages/63/b1/4260d67d6bd85e58a66b72d54ce15d5de789b6f3870cc6bedf8ff9667401/propcache-0.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97797ebb098e670a2f92dd66f32897e30d7615b14e7f59711de23e30a9072539", size = 54650, upload-time = "2026-05-08T21:01:25.305Z" }, + { url = "https://files.pythonhosted.org/packages/70/06/2f46c318e3307cd7a6a7481def374ce838c0fe20084b39dd54b0879d0e99/propcache-0.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba57fffe4ac99c5d30076161b5866336d97600769bad35cc68f7774b15298a4e", size = 59912, upload-time = "2026-05-08T21:01:26.545Z" }, + { url = "https://files.pythonhosted.org/packages/4c/29/fe1aebec2ce57ab985a9c382bded1124431f85078113aa222c5d278430d4/propcache-0.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:583c19759d9eec1e5b69e2fbef36a7d9c326041be9746cb822d335c8cedc2979", size = 63300, upload-time = "2026-05-08T21:01:27.937Z" }, + { url = "https://files.pythonhosted.org/packages/b4/18/2334b26768b6c82be8c69e83671b767d5ef426aa09b0cba6c2ea47816774/propcache-0.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d0326e2e5e1f3163fa306c834e48e8d490e5fae607a097a40c0648109b47ba80", size = 64208, upload-time = "2026-05-08T21:01:29.484Z" }, + { url = "https://files.pythonhosted.org/packages/2b/76/7f1bfd6afff4c5e38e36a3c6d68eb5f4b7311ea80baf693db78d95b603c4/propcache-0.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e00820e192c8dbebcafb383ebbf99030895f09905e7a0eb2e0340a0bcc2bc825", size = 61633, upload-time = "2026-05-08T21:01:31.068Z" }, + { url = "https://files.pythonhosted.org/packages/c4/46/b3ff8aba2b4953a3e50de2cf72f1b5748b8eca93b15f3dc2c84339084c09/propcache-0.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c66afea89b1e43725731d2004732a046fe6fe955d51f952c3e95a7314a284a39", size = 61724, upload-time = "2026-05-08T21:01:32.374Z" }, + { url = "https://files.pythonhosted.org/packages/c5/01/814cfcafbcff954f94c01cf30e097ddc88a076b5440fbcf4570753437d40/propcache-0.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d4dc37dec6c6cdad0b57881a5658fd14fbf53e333b1a86cf86559f190e1d9ec4", size = 60069, upload-time = "2026-05-08T21:01:33.67Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/5c6f7622d510cc666a300687e06fd060c1a43361c0c9b20d284f06d8096a/propcache-0.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5570dbcc97571c15f68068e529c92715a12f8d54030e272d264b377e22bd17a5", size = 57099, upload-time = "2026-05-08T21:01:34.915Z" }, + { url = "https://files.pythonhosted.org/packages/55/27/9cb0b4c679124085327957d42521c99dba04c88c90c3e55a6f0b633ebccc/propcache-0.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f814362777a9f841adddb200ecdf8f5cb1e5a3c4b7a86378edbd6ccb26edd702", size = 63391, upload-time = "2026-05-08T21:01:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/f0/9d/7258aaa5bdf60fc6f27591eef6fe52768cb0beda7140be477c8b12c9794a/propcache-0.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:196913dea116aeb5a2ba95af4ddcb7ea85559ae07d8eee8751688310d09168c3", size = 61626, upload-time = "2026-05-08T21:01:37.545Z" }, + { url = "https://files.pythonhosted.org/packages/8e/0d/41c602003e8a9b16fe1e7eadf62c7bfba9d5474370b24200bf48b315f45f/propcache-0.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6e7b8719005dd1175be4ab1cd25e9b98659a5e0347331506ec6760d2773a7fb5", size = 64781, upload-time = "2026-05-08T21:01:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f3/38e66b1856e9bd079deea015bc4a55f7767c0e4db2f7dcf69e7e680ba4ce/propcache-0.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:51f96d685ab16e88cab128cd37a52c5da540809c8b879fa047731bfcb4ad35a4", size = 62570, upload-time = "2026-05-08T21:01:40.415Z" }, + { url = "https://files.pythonhosted.org/packages/95/ca/bbfe9b910ce57dde8bb4876b4520fc02a4e89497c10de26be936758a3aaa/propcache-0.5.2-cp314-cp314-win32.whl", hash = "sha256:cc6fc3cc62e8501d3ed62894425040d2728ecddb1ed072737a5c70bd537aa9f0", size = 39436, upload-time = "2026-05-08T21:01:41.654Z" }, + { url = "https://files.pythonhosted.org/packages/61/d2/45c9defbaa1ea297035d9d4cce9e8f80daafbf19319c6007f157c6256ea9/propcache-0.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:81e3a30b0bb60caa22033dd0f8a3618d1d67356212514f62c57db75cb0ef410c", size = 42373, upload-time = "2026-05-08T21:01:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/44/68/9ea5103f41d5217d7d6ec24db90018e23aebec070c3f9a6e54d12b841fd8/propcache-0.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:0d2c9bf8528f135dbb805ce027567e09164f7efa51a2be07458a2c0420f292d0", size = 38554, upload-time = "2026-05-08T21:01:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/8a/81/fadf555f42d3b762eea8a53950b0489fdc0aa9da5f8ed9e10ce0a4e01b48/propcache-0.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4bc8ff1feffc6a61c7002ffe84634c41b822e104990ae009f44a0834430070bb", size = 99395, upload-time = "2026-05-08T21:01:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c9/c61e134a686949cf7971af3a390148b1156f7be81c73bc0cd12c873e2d48/propcache-0.5.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79aa3ff0a9b566633b642fa9caf7e21ed1c13d6feca718187873f199e1514078", size = 56653, upload-time = "2026-05-08T21:01:47.307Z" }, + { url = "https://files.pythonhosted.org/packages/cb/73/daf935ea7048ddd7ec8eec5345b4a40b619d2d178b3c0a0900796bc3c794/propcache-0.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1b31822f4474c4036bae62de9402710051d431a606d6a0f907fec79935a071aa", size = 56914, upload-time = "2026-05-08T21:01:48.573Z" }, + { url = "https://files.pythonhosted.org/packages/79/9f/aba959b435ea18617edd7cf0a7ad0b9c574b8fc7e3d2cd55fb59cb255d33/propcache-0.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fef48778b5a2a756523fdb781326b028ca75e32858b04f2cdd19f394564917", size = 62567, upload-time = "2026-05-08T21:01:49.903Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a1/859942de9a791ff42f6141736f5b37749b8f53e65edfa49638c67dd67e6a/propcache-0.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8b73ab70f1a3351fbc71f663b3e645af6dd0329100c353081cf69c37433fc6fe", size = 65542, upload-time = "2026-05-08T21:01:51.204Z" }, + { url = "https://files.pythonhosted.org/packages/b5/61/315bc0fd6c0fc7f80a528b8afd209e5fc4a875ea79571b91b8f50f442907/propcache-0.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5538d2c13d93e4698af7e092b57bc7298fd35d1d58e656ae18f23ee0d0378e03", size = 66845, upload-time = "2026-05-08T21:01:52.539Z" }, + { url = "https://files.pythonhosted.org/packages/47/f7/9f8122e3132e8e354ac41975ef8f1099be7d5a16bc7ae562734e993665c0/propcache-0.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd645f03898405cabe694fb8bc35241e3a9c332ec85627584fe3de201452b335", size = 63985, upload-time = "2026-05-08T21:01:53.847Z" }, + { url = "https://files.pythonhosted.org/packages/c8/54/c317819ec157cbf6f35df9df9657a6f82daf34d5faf15948b2f639c2192e/propcache-0.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a473b3440261e0c60706e732b2ed2f517857344fc21bf48fdfe211e2d98eb285", size = 63999, upload-time = "2026-05-08T21:01:55.179Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/387e3f7dfce0a9233df41fb888aa1c30222cb4bbbf09537c02dd9bd85fe2/propcache-0.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7afa37062e6650640e932e4cc9297d81f9f42d9944029cc386b8247dea4da837", size = 62779, upload-time = "2026-05-08T21:01:57.489Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9c/596784cb5824ed61ee960d3f8655a3f0993e107c6e98ab6c818b7fb92ccb/propcache-0.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8a90efd5777e996e42d568db9ac740b944d691e565cbfd31b2f7832f9184b2b8", size = 59796, upload-time = "2026-05-08T21:01:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/c2/3d/1a6cfa1726a48542c1e8784a0761421476a5b68e09b7f36bf95eb954aaba/propcache-0.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f19bb891234d72535764d703bfed1153cc34f4214d5bd7150aee1eec9e8f4366", size = 66023, upload-time = "2026-05-08T21:02:00.228Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0e/05fd6990369477076e4e280bcb970de760fddf0161a46e988bc95f7940ec/propcache-0.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:32775082acd2d807ee3db715c7770d38767b817870acfa08c29e057f3c4d5b56", size = 64448, upload-time = "2026-05-08T21:02:01.888Z" }, + { url = "https://files.pythonhosted.org/packages/cd/86/5f8da315a4309c62c10c0b2516b17492d5d3bbe1bb862b96604db67e2a37/propcache-0.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9282fb1a3bccd038da9f768b927b24a0c753e466c086b7c4f3c6982851eefb2d", size = 67329, upload-time = "2026-05-08T21:02:03.484Z" }, + { url = "https://files.pythonhosted.org/packages/da/d3/3368efe79ab21f0cdf86ef49895811c9cc933131d4cde1f28a624e22e712/propcache-0.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc49723e2f60d6b32a0f0b08a3fd6d13203c07f1cd9566cfce0f12a917c967a2", size = 65172, upload-time = "2026-05-08T21:02:04.745Z" }, + { url = "https://files.pythonhosted.org/packages/d5/07/127e8b0bacfb325396196f9d976a22453049b89b9b2b08477cc3145faa44/propcache-0.5.2-cp314-cp314t-win32.whl", hash = "sha256:2d7aa89ebca5acc98cba9d1472d976e394782f587bad6661003602a619fd1821", size = 43813, upload-time = "2026-05-08T21:02:06.025Z" }, + { url = "https://files.pythonhosted.org/packages/88/fb/46dad6c0ae49ed230ab1b16c890c2b6314e2403e6c412976f4a72d64a527/propcache-0.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:d447bb0b3054be5818458fbb171208b1d9ff11eba14e18ca18b90cbb45767370", size = 47764, upload-time = "2026-05-08T21:02:07.353Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/a47d0a63aa309d10d59ede6e9d4cff03a344a79d1f0f4cd0cd74997b53e0/propcache-0.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:fe67a3d11cd9b4efabfa45c3d00ffba2b26811442a73a581a94b67c2b5faccf6", size = 41140, upload-time = "2026-05-08T21:02:09.065Z" }, + { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" }, +] + +[[package]] +name = "protobuf" +version = "7.35.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/60/fd/5b1491d9e4b586d621c54f4c36b888714164b6875f8d6afa3f9072906a51/protobuf-7.35.0.tar.gz", hash = "sha256:a2efd84605f41e559f1881b0912b44099d0a2ac9bf46b3474823f10fb393b0e6", size = 458677, upload-time = "2026-05-19T23:02:29.197Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/ee/93d06e358a4aa32280b00e722d3ea0a1f25fc3cc5778d80581c9cca2c10e/protobuf-7.35.0-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:66be6c513931c794fa92c080ffee41671390da3d79da219cf9c0c0907f035dda", size = 433225, upload-time = "2026-05-19T23:02:19.884Z" }, + { url = "https://files.pythonhosted.org/packages/8b/39/1c76c2da93f3c507e958e0aecee2391cc44d4625de6c728bbc555195b5a8/protobuf-7.35.0-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:fcbe42a4ac09d3ec9c987ddfcd956afd0b15f1ff613bd8371bde9405ffd5c8e5", size = 328847, upload-time = "2026-05-19T23:02:22.3Z" }, + { url = "https://files.pythonhosted.org/packages/91/1a/39f7ce90a238c1a987a4d81ec26379e02ca0aff367de68e4a1fa474215b9/protobuf-7.35.0-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:4cbf5cc286130e06a6c9bbefac442431173906dfcc979712183d4adcc01b37ee", size = 344030, upload-time = "2026-05-19T23:02:23.591Z" }, + { url = "https://files.pythonhosted.org/packages/70/5b/6baf9008817964454055ff3fe65f1de0b5f1e26c80c82f7fb108b7cd4ea3/protobuf-7.35.0-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:6c0f98f10c8a05ea30f8993dfef2de093d27b490fdae78bb60c8343795d55011", size = 327130, upload-time = "2026-05-19T23:02:24.637Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e5/e46adb0badc388bfb84877a5f9f026aff63f60e611016cf64dbe77e05446/protobuf-7.35.0-cp310-abi3-win32.whl", hash = "sha256:4c4617b83ade0e279d1d2bfe04025a1adb87f9ed657de038620dc0ff959357f6", size = 428946, upload-time = "2026-05-19T23:02:25.741Z" }, + { url = "https://files.pythonhosted.org/packages/a7/ab/547fbd9e16d879dd13c167478f8ae0a83a428008ca07a5e06acdc23ad473/protobuf-7.35.0-cp310-abi3-win_amd64.whl", hash = "sha256:f05bcadf9a2a6b8dda047007075135fb7d08c73d9177aabc067e1be46881a201", size = 439996, upload-time = "2026-05-19T23:02:26.808Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ef/50433d346c56657a70d27f156c7b349ac59a068b01de4eb796e747eecc43/protobuf-7.35.0-py3-none-any.whl", hash = "sha256:c13f325cf242bad135c350629eeb5d54b24228eb472fb3e2e9ebbd4c5dc20ca0", size = 171659, upload-time = "2026-05-19T23:02:27.842Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pyarrow" +version = "24.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/d3/a1abf004482026ddc17f4503db227787fa3cfe41ec5091ff20e4fea55e57/pyarrow-24.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:02b001b3ed4723caa44f6cd1af2d5c86aa2cf9971dacc2ffa55b21237713dfba", size = 34976759, upload-time = "2026-04-21T10:48:07.258Z" }, + { url = "https://files.pythonhosted.org/packages/4f/4a/34f0a36d28a2dd32225301b79daad44e243dc1a2bb77d43b60749be255c4/pyarrow-24.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:04920d6a71aabd08a0417709efce97d45ea8e6fb733d9ca9ecffb13c67839f68", size = 36658471, upload-time = "2026-04-21T10:48:13.347Z" }, + { url = "https://files.pythonhosted.org/packages/1f/78/543b94712ae8bb1a6023bcc1acf1a740fbff8286747c289cd9468fced2a5/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a964266397740257f16f7bb2e4f08a0c81454004beab8ff59dd531b73610e9f2", size = 45675981, upload-time = "2026-04-21T10:48:20.201Z" }, + { url = "https://files.pythonhosted.org/packages/84/9f/8fb7c222b100d314137fa40ec050de56cd8c6d957d1cfff685ce72f15b17/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6f066b179d68c413374294bc1735f68475457c933258df594443bb9d88ddc2a0", size = 48859172, upload-time = "2026-04-21T10:48:27.541Z" }, + { url = "https://files.pythonhosted.org/packages/a7/d3/1ea72538e6c8b3b475ed78d1049a2c518e655761ea50fe1171fc855fcab7/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1183baeb14c5f587b1ec52831e665718ce632caab84b7cd6b85fd44f96114495", size = 49385733, upload-time = "2026-04-21T10:48:34.7Z" }, + { url = "https://files.pythonhosted.org/packages/c3/be/c3d8b06a1ba35f2260f8e1f771abbee7d5e345c0937aab90675706b1690a/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:806f24b4085453c197a5078218d1ee08783ebbba271badd153d1ae22a3ee804f", size = 51934335, upload-time = "2026-04-21T10:48:42.099Z" }, + { url = "https://files.pythonhosted.org/packages/9c/62/89e07a1e7329d2cde3e3c6994ba0839a24977a2beda8be6005ea3d860b99/pyarrow-24.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4505fc6583f7b05ab854934896bcac8253b04ac1171a77dfb73efef92076d91", size = 27271748, upload-time = "2026-04-21T10:49:42.532Z" }, + { url = "https://files.pythonhosted.org/packages/17/1a/cff3a59f80b5b1658549d46611b67163f65e0664431c076ad728bf9d5af4/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:1a4e45017efbf115032e4475ee876d525e0e36c742214fbe405332480ecd6275", size = 35238554, upload-time = "2026-04-21T10:48:48.526Z" }, + { url = "https://files.pythonhosted.org/packages/a8/99/cce0f42a327bfef2c420fb6078a3eb834826e5d6697bf3009fe11d2ad051/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:7986f1fa71cee060ad00758bcc79d3a93bab8559bf978fab9e53472a2e25a17b", size = 36782301, upload-time = "2026-04-21T10:48:55.181Z" }, + { url = "https://files.pythonhosted.org/packages/2a/66/8e560d5ff6793ca29aca213c53eec0dd482dd46cb93b2819e5aab52e4252/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d3e0b61e8efb24ed38898e5cdc5fffa9124be480008d401a1f8071500494ae42", size = 45721929, upload-time = "2026-04-21T10:49:03.676Z" }, + { url = "https://files.pythonhosted.org/packages/27/0c/a26e25505d030716e078d9f16eb74973cbf0b33b672884e9f9da1c83b871/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:55a3bc1e3df3b5567b7d27ef551b2283f0c68a5e86f1cd56abc569da4f31335b", size = 48825365, upload-time = "2026-04-21T10:49:11.714Z" }, + { url = "https://files.pythonhosted.org/packages/5f/eb/771f9ecb0c65e73fe9dccdd1717901b9594f08c4515d000c7c62df573811/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:641f795b361874ac9da5294f8f443dfdbee355cf2bd9e3b8d97aaac2306b9b37", size = 49451819, upload-time = "2026-04-21T10:49:21.474Z" }, + { url = "https://files.pythonhosted.org/packages/48/da/61ae89a88732f5a785646f3ec6125dbb640fa98a540eb2b9889caa561403/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8adc8e6ce5fccf5dc707046ae4914fd537def529709cc0d285d37a7f9cd442ca", size = 51909252, upload-time = "2026-04-21T10:49:31.164Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1a/8dd5cafab7b66573fa91c03d06d213356ad4edd71813aa75e08ce2b3a844/pyarrow-24.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:9b18371ad2f44044b81a8d23bc2d8a9b6a6226dca775e8e16cfee640473d6c5d", size = 27388127, upload-time = "2026-04-21T10:49:37.334Z" }, + { url = "https://files.pythonhosted.org/packages/ad/80/d022a34ff05d2cbedd8ccf841fc1f532ecfa9eb5ed1711b56d0e0ea71fc9/pyarrow-24.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:1cc9057f0319e26333b357e17f3c2c022f1a83739b48a88b25bfd5fa2dc18838", size = 35007997, upload-time = "2026-04-21T10:49:48.796Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ff/f01485fda6f4e5d441afb8dd5e7681e4db18826c1e271852f5d3957d6a80/pyarrow-24.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e6f1278ee4785b6db21229374a1c9e54ec7c549de5d1efc9630b6207de7e170b", size = 36678720, upload-time = "2026-04-21T10:49:55.858Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c2/2d2d5fea814237923f71b36495211f20b43a1576f9a4d6da7e751a64ec6f/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:adbbedc55506cbdabb830890444fb856bfb0060c46c6f8026c6c2f2cf86ae795", size = 45741852, upload-time = "2026-04-21T10:50:04.624Z" }, + { url = "https://files.pythonhosted.org/packages/8e/3a/28ba9c1c1ebdbb5f1b94dfebb46f207e52e6a554b7fe4132540fde29a3a0/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ae8a1145af31d903fa9bb166824d7abe9b4681a000b0159c9fb99c11bc11ad26", size = 48889852, upload-time = "2026-04-21T10:50:12.293Z" }, + { url = "https://files.pythonhosted.org/packages/df/51/4a389acfd31dca009f8fb82d7f510bb4130f2b3a8e18cf00194d0687d8ac/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d7027eba1df3b2069e2e8d80f644fa0918b68c46432af3d088ddd390d063ecde", size = 49445207, upload-time = "2026-04-21T10:50:20.677Z" }, + { url = "https://files.pythonhosted.org/packages/19/4b/0bab2b23d2ae901b1b9a03c0efd4b2d070256f8ce3fc43f6e58c167b2081/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e56a1ffe9bf7b727432b89104cc0849c21582949dd7bdcb34f17b2001a351a76", size = 51954117, upload-time = "2026-04-21T10:50:29.14Z" }, + { url = "https://files.pythonhosted.org/packages/29/88/f4e9145da0417b3d2c12035a8492b35ff4a3dbc653e614fcfb51d9dedb38/pyarrow-24.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:38be1808cdd068605b787e6ca9119b27eb275a0234e50212c3492331680c3b1e", size = 28001155, upload-time = "2026-04-21T10:51:22.337Z" }, + { url = "https://files.pythonhosted.org/packages/79/4f/46a49a63f43526da895b1a45bbb51d5baf8e4d77159f8528fc3e5490007f/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:418e48ce50a45a6a6c73c454677203a9c75c966cb1e92ca3370959185f197a05", size = 35250387, upload-time = "2026-04-21T10:50:35.552Z" }, + { url = "https://files.pythonhosted.org/packages/a0/da/d5e0cd5ef00796922404806d5f00325cdadc3441ce2c13fe7115f2df9a64/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:2f16197705a230a78270cdd4ea8a1d57e86b2fdcbc34a1f6aebc72e65c986f9a", size = 36797102, upload-time = "2026-04-21T10:50:42.417Z" }, + { url = "https://files.pythonhosted.org/packages/34/c7/5904145b0a593a05236c882933d439b5720f0a145381179063722fbfc123/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:fb24ac194bfc5e86839d7dcd52092ee31e5fe6733fe11f5e3b06ef0812b20072", size = 45745118, upload-time = "2026-04-21T10:50:49.324Z" }, + { url = "https://files.pythonhosted.org/packages/13/d3/cca42fe166d1c6e4d5b80e530b7949104d10e17508a90ae202dac205ce2a/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9700ebd9a51f5895ce75ff4ac4b3c47a7d4b42bc618be8e713e5d56bacf5f931", size = 48844765, upload-time = "2026-04-21T10:50:55.579Z" }, + { url = "https://files.pythonhosted.org/packages/b0/49/942c3b79878ba928324d1e17c274ed84581db8c0a749b24bcf4cbdf15bd3/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d8ddd2768da81d3ee08cfea9b597f4abb4e8e1dc8ae7e204b608d23a0d3ab699", size = 49471890, upload-time = "2026-04-21T10:51:02.439Z" }, + { url = "https://files.pythonhosted.org/packages/76/97/ff71431000a75d84135a1ace5ca4ba11726a231a8007bbb320a4c54075d5/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:61a3d7eaa97a14768b542f3d284dc6400dd2470d9f080708b13cd46b6ae18136", size = 51932250, upload-time = "2026-04-21T10:51:10.576Z" }, + { url = "https://files.pythonhosted.org/packages/51/be/6f79d55816d5c22557cf27533543d5d70dfe692adfbee4b99f2760674f38/pyarrow-24.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91d00057f23b8d353039520dc3a6c09d8608164c692e9f59a175a42b2ae0c19", size = 28131282, upload-time = "2026-04-21T10:51:16.815Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pycrdt" +version = "0.12.50" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5d/bd/6e049694ad7fed0baf45a62629ff2c7aa1c26e0581a4d4987e0fd39fe951/pycrdt-0.12.50.tar.gz", hash = "sha256:506d4bc00d7d566de4018dca52998ab7cf97c787363bc59440d3a3bb3336d1a0", size = 84528, upload-time = "2026-03-16T09:39:15.924Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/ea/cdc543c51971c513f3b23c34d17ae672dd2fab40977b8d94344c6e8099be/pycrdt-0.12.50-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:f75c95335cacc459dbb3c4e55afbd231f8befd333c617ffad1bbe348018021de", size = 1721432, upload-time = "2026-03-16T09:38:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/b6/30/cde0c58cdfb0f2e4d523443637b11b9bb5963024f5f3cd9e889b8195eab4/pycrdt-0.12.50-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3842dff93946c1b46ea8c508f7d79f07f0a8c54fe8f8e83e6cbb1f9f35a62899", size = 944575, upload-time = "2026-03-16T09:38:18.574Z" }, + { url = "https://files.pythonhosted.org/packages/df/a8/b36e98bca96b9c9b3d554ce6984128dff076a47cb350462efb122a09613e/pycrdt-0.12.50-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fba48534acb7ba22a975c38ff531178d25a01c29d5d4ec2ecfe1c45754cde181", size = 962165, upload-time = "2026-03-16T09:38:20.112Z" }, + { url = "https://files.pythonhosted.org/packages/69/c2/38e0055416466feb9b33cfc96a95c3bd3985cdb547fdc0e556d8903e074f/pycrdt-0.12.50-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a5ca809926c3e08965b201b277c26d319c47078ba4b22178976f0455b351155b", size = 1135011, upload-time = "2026-03-16T09:38:21.952Z" }, + { url = "https://files.pythonhosted.org/packages/fe/5f/9597d1b2fcd8f1bff78308352dc8568012e1e2c2ef44a0e5ca11cd04aa81/pycrdt-0.12.50-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bffe6a7e6a59ea1c74a53a0ffa2fee27ff54e454cff333ef952922535c7c8ffa", size = 987535, upload-time = "2026-03-16T09:38:23.459Z" }, + { url = "https://files.pythonhosted.org/packages/ed/f8/882da205925f147610ca790304a025232c164256421655e19cd9eabfca06/pycrdt-0.12.50-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:688d8cb017a729719be8f9ecf488daba24781c05a1635f725ca257aa9a90acfd", size = 956238, upload-time = "2026-03-16T09:38:25.473Z" }, + { url = "https://files.pythonhosted.org/packages/78/91/6cf0db29eebdafe8d3a27ec0a9ece583acab0959d0de22968fcc43f51d75/pycrdt-0.12.50-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:71f9dfc24636dc9789246dae4c8db39f5b9b419c1a1f6f53b782ae22e8febbef", size = 1046621, upload-time = "2026-03-16T09:38:27.349Z" }, + { url = "https://files.pythonhosted.org/packages/b4/40/f1e79a74c12439a595f1986a403e08a35abedce5929c4f464be5f2ec8109/pycrdt-0.12.50-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a33635da609afe467e4ae644766416454535161ec7e1427294a59ed8a5e80015", size = 1121675, upload-time = "2026-03-16T09:38:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/03/7f/b966b7c489e306070eef305b3f591e7ce7a34ee445cb55d1b8fd4fa6e338/pycrdt-0.12.50-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:f48c78ef3710c033d07d5de326362826eda8fa941859f06c146007d6122b3bb4", size = 1235939, upload-time = "2026-03-16T09:38:30.721Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7a/0a4a74c68349ee72c3e92baad0cb9fbc6a94f2c122a228489357b8ad3507/pycrdt-0.12.50-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c714c1582b804bd296f9b8530353bfab54386a145164e9693443e38b23392d69", size = 1222964, upload-time = "2026-03-16T09:38:32.323Z" }, + { url = "https://files.pythonhosted.org/packages/be/54/c96b470ebc5eaf355beeb8ffaf0235976e3e1fb9d4bc8a1169138c7e5063/pycrdt-0.12.50-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d88a146090d9d6fc64687574c6014b26be1673b8b54b450fca23f115068c2852", size = 1165811, upload-time = "2026-03-16T09:38:34.05Z" }, + { url = "https://files.pythonhosted.org/packages/78/e4/070a16212142bda9cb585571066e1aa48ffcdc2ffb3540759d96dcebd141/pycrdt-0.12.50-cp313-cp313-win32.whl", hash = "sha256:a149f0f080f19b1c9a5614885e134ebbe159ee8add9fce96b81fcb3ea261df94", size = 695256, upload-time = "2026-03-16T09:38:35.705Z" }, + { url = "https://files.pythonhosted.org/packages/03/63/e0beaeabc4bb32901cff77ac9bc0edfa1b2e81a739cc5cd3990896759f94/pycrdt-0.12.50-cp313-cp313-win_amd64.whl", hash = "sha256:96db3bff011f0f85e2c95ad3337abf9553dc08d2cafb2bba6ee4b30b53a585d0", size = 748447, upload-time = "2026-03-16T09:38:37.483Z" }, + { url = "https://files.pythonhosted.org/packages/f7/5d/ae92c859ec5ee4f63d2df3702ce7a782cb054d1cef9a72d17b15a0f787f9/pycrdt-0.12.50-cp314-cp314-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:382cf259b848db979f2cc8f37c8b1c20c46de8df10142383e8502c8eb40589ba", size = 1720667, upload-time = "2026-03-16T09:38:39.222Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d7/03d5a6d806eec5cc880d17d88a2f8868bd3ddf20aea988ce9238d433cfb4/pycrdt-0.12.50-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:022450e769b8ec37027504602f3dcfc4171d0d27ebe0f04c28d9eb5a3641fdff", size = 946541, upload-time = "2026-03-16T09:38:40.918Z" }, + { url = "https://files.pythonhosted.org/packages/9a/af/4700d71886afeb406b5b6d16d36dbd15fd0d3caa37af60894aca75dc8f3e/pycrdt-0.12.50-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:41c5470f1fe5426e81986664e786508935d00050f061a5eb341af596c67c0bc7", size = 960844, upload-time = "2026-03-16T09:38:42.605Z" }, + { url = "https://files.pythonhosted.org/packages/e9/95/b3640697e6e7dd6675e8fb41c95fba89d84cf435249ed0b8c310ae7eaa10/pycrdt-0.12.50-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bccb80466c7bcaafa1591cdd44b4f4302993324dd09b16a1c4b05f6153a0a458", size = 1136447, upload-time = "2026-03-16T09:38:44.254Z" }, + { url = "https://files.pythonhosted.org/packages/f8/50/fec4bf7fdd8b82e295be28c890a856a2d80e94d4d49098e660bb2c4520bd/pycrdt-0.12.50-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7b2061ad56d4305fce05ddfa269a662e1137997494f74f3f0633052f8beccd4", size = 986746, upload-time = "2026-03-16T09:38:45.88Z" }, + { url = "https://files.pythonhosted.org/packages/70/40/3f82b3bc35adc4ad194a2a397d0518892516e2c40663035401eca05d9bec/pycrdt-0.12.50-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b1d6a3aa808e3996cec15c2ec7d1613c39d872627eb1953877d21720e91b002", size = 957198, upload-time = "2026-03-16T09:38:47.609Z" }, + { url = "https://files.pythonhosted.org/packages/5e/5c/dfd19e979812e455add5942857a08ce2c28547fb68824dda44d4eb83c08b/pycrdt-0.12.50-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8ba83048dc394e8c0d0edf5fdee073eba5d566f372bd3cc24dc8f0f4c24a36d4", size = 1048567, upload-time = "2026-03-16T09:38:49.882Z" }, + { url = "https://files.pythonhosted.org/packages/ac/02/153f511fb0f0dd32d889aede169ea0eda52d62935728b685b6815425ce9d/pycrdt-0.12.50-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8fbf1f7b6c8200193b602ed3307b526a9cf3db7acb63191632f77d071fb595ec", size = 1122383, upload-time = "2026-03-16T09:38:51.581Z" }, + { url = "https://files.pythonhosted.org/packages/ea/fa/3fcdb4502ced4b7795516acbb12997ec7aaf726187e360494182f533a1a1/pycrdt-0.12.50-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6776ad64c8a6b270683cdecd1327289587160228401af454f570a9d971eec9a3", size = 1235274, upload-time = "2026-03-16T09:38:53.598Z" }, + { url = "https://files.pythonhosted.org/packages/69/e9/1a50a55b2b2424646e61b648a1bee42f73c1830479cb8095df428bb56b2a/pycrdt-0.12.50-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:f4218a1e568f9b33fd676adc1d3a92fdf4c1c5b6ec3c885f227db7b7fb680b3b", size = 1224841, upload-time = "2026-03-16T09:38:55.528Z" }, + { url = "https://files.pythonhosted.org/packages/a4/62/bd919a4cf7265b4b01c2365820a5423dbe9744880a83a680339a1bf34875/pycrdt-0.12.50-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cde948e70e3e246638e5cd8b0156c714961fba41cd44374e7c5066e797e8ec3f", size = 1168590, upload-time = "2026-03-16T09:38:57.478Z" }, + { url = "https://files.pythonhosted.org/packages/d0/b3/d0b97dbaf7c60c6e3f6d5c9ae2cd8cca3655d8fa397c41c24c44d92dc8d2/pycrdt-0.12.50-cp314-cp314-win32.whl", hash = "sha256:1d42d7f29c1e8459cd80aefd37595e8c7062817f48c59c5e5568401527718d19", size = 694709, upload-time = "2026-03-16T09:38:59.68Z" }, + { url = "https://files.pythonhosted.org/packages/72/fc/acdb8c238f9f4a6c2757b7c2cfdb39aa3c779ac465e0b6c6862c564e6350/pycrdt-0.12.50-cp314-cp314-win_amd64.whl", hash = "sha256:a4d294295120e33fef32d51e1a7a92eab444d20c07d5bde55a5a75afe58a5d41", size = 747251, upload-time = "2026-03-16T09:39:01.435Z" }, +] + +[[package]] +name = "pycrdt-store" +version = "0.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "pycrdt" }, + { name = "sqlite-anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/61/dfecafdc0c23f56d5bacc67de620b77a68f86085df21a8007628d6045248/pycrdt_store-0.1.3.tar.gz", hash = "sha256:12a0e263b2c07eb18bbe7203c828b88ba953cb93094ad37d22aeb6c619df2ef0", size = 14847, upload-time = "2025-12-11T13:29:11.454Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/2d/85a1b3d6e65048c0553e0d06e21b235610ff4db0ea94cbae1bd34de385d7/pycrdt_store-0.1.3-py3-none-any.whl", hash = "sha256:2e74afc856c162706d178d23d57fd3706accbe79d849e73dd413646a7025afba", size = 11948, upload-time = "2025-12-11T13:29:10.522Z" }, +] + +[[package]] +name = "pycrdt-websocket" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "pycrdt" }, + { name = "pycrdt-store" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4f/91/a412af8792af22e7e67a7424e7b6c64baada4897777fed885a2cb825155d/pycrdt_websocket-0.16.0.tar.gz", hash = "sha256:89d4d830f41028c55cc9877635f73f94f49131ca73ffac7353d0be421150d0fd", size = 23152, upload-time = "2025-06-11T07:15:54.298Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/b7/a1dd4d149fa6279f321bd7dacab66ac31e728fbae175a7d75cf8211b1f30/pycrdt_websocket-0.16.0-py3-none-any.whl", hash = "sha256:4b9ffe47c40867b7e637922680e93471fd801b6e8d6c9f6aa688fd2a17351141", size = 14568, upload-time = "2025-06-11T07:15:52.364Z" }, +] + +[[package]] +name = "pydantic" +version = "2.13.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.46.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" }, + { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" }, + { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" }, + { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" }, + { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" }, + { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" }, + { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" }, + { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" }, + { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" }, + { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" }, + { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" }, + { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" }, + { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" }, + { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" }, + { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" }, + { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" }, + { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" }, + { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" }, + { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" }, + { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" }, + { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" }, + { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" }, + { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" }, + { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" }, + { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" }, + { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" }, + { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" }, + { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" }, +] + +[[package]] +name = "pydantic-settings" +version = "2.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/60/1d1e59c9c90d54591469ada7d268251f71c24bdb765f1a8a832cee8c6653/pydantic_settings-2.14.1.tar.gz", hash = "sha256:e874d3bec7e787b0c9958277956ed9b4dd5de6a80e162188fdaff7c5e26fd5fa", size = 235551, upload-time = "2026-05-08T13:40:06.542Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/8d/f1af3832f5e6eb13ba94ee809e72b8ecb5eef226d27ee0bef7d963d943c7/pydantic_settings-2.14.1-py3-none-any.whl", hash = "sha256:6e3c7edfd8277687cdc598f56e5cff0e9bfff0910a3749deaa8d4401c3a2b9de", size = 60964, upload-time = "2026-05-08T13:40:04.958Z" }, +] + +[[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 = "pyjwt" +version = "2.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" }, +] + +[package.optional-dependencies] +crypto = [ + { name = "cryptography" }, +] + +[[package]] +name = "pymatting" +version = "1.1.15" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numba" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9a/f5/83955aa915ea5e04cecb32612d419e8341604d0b898c2ebe4277adbc4c6b/pymatting-1.1.15.tar.gz", hash = "sha256:67cbadd68d04696357461ad1861bcb3c2adc9ec5fcd38d524db606addabe745a", size = 44424, upload-time = "2026-01-26T09:27:22.395Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/59/87a27f2539b0a9436853484e80f6a3ef96c30caa0316dce85f1f29d9e953/pymatting-1.1.15-py3-none-any.whl", hash = "sha256:1bd7f04651f1e02b390b88b84cf97c7f4c871ad8568945e4303746bf3ab48ecc", size = 54862, upload-time = "2026-01-26T09:27:20.856Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, 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, 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 = "python-json-logger" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f7/ff/3cc9165fd44106973cd7ac9facb674a65ed853494592541d339bdc9a30eb/python_json_logger-4.1.0.tar.gz", hash = "sha256:b396b9e3ed782b09ff9d6e4f1683d46c83ad0d35d2e407c09a9ebbf038f88195", size = 17573, upload-time = "2026-03-29T04:39:56.805Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/be/0631a861af4d1c875f096c07d34e9a63639560a717130e7a87cbc82b7e3f/python_json_logger-4.1.0-py3-none-any.whl", hash = "sha256:132994765cf75bf44554be9aa49b06ef2345d23661a96720262716438141b6b2", size = 15021, upload-time = "2026-03-29T04:39:55.266Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.29" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/fe/70bd71a6738b09a0bdf6480ca6436b167469ca4578b2a0efbe390b4b0e70/python_multipart-0.0.29.tar.gz", hash = "sha256:643e93849196645e2dbdd81a0f8829a23123ad7f797a84a364c6fb3563f18904", size = 45678, upload-time = "2026-05-17T17:29:47.654Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/cb/769cfc37177252872a45a71f3fbdde9d51b471a3f3c14bfe95dde3407386/python_multipart-0.0.29-py3-none-any.whl", hash = "sha256:2ddcc971cef266225f54f552d8fa10bcfbb1f14446caec199060daac59ff2d69", size = 29640, upload-time = "2026-05-17T17:29:45.69Z" }, +] + +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, +] + +[[package]] +name = "pywinpty" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f7/54/37c7370ba91f579235049dc26cd2c5e657d2a943e01820844ffc81f32176/pywinpty-3.0.3.tar.gz", hash = "sha256:523441dc34d231fb361b4b00f8c99d3f16de02f5005fd544a0183112bcc22412", size = 31309, upload-time = "2026-02-04T21:51:09.524Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/cb/58d6ed3fd429c96a90ef01ac9a617af10a6d41469219c25e7dc162abbb71/pywinpty-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9c91dbb026050c77bdcef964e63a4f10f01a639113c4d3658332614544c467ab", size = 2112686, upload-time = "2026-02-04T21:52:03.035Z" }, + { url = "https://files.pythonhosted.org/packages/fd/50/724ed5c38c504d4e58a88a072776a1e880d970789deaeb2b9f7bd9a5141a/pywinpty-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:fe1f7911805127c94cf51f89ab14096c6f91ffdcacf993d2da6082b2142a2523", size = 234591, upload-time = "2026-02-04T21:52:29.821Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ad/90a110538696b12b39fd8758a06d70ded899308198ad2305ac68e361126e/pywinpty-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:3f07a6cf1c1d470d284e614733c3d0f726d2c85e78508ea10a403140c3c0c18a", size = 2112360, upload-time = "2026-02-04T21:55:33.397Z" }, + { url = "https://files.pythonhosted.org/packages/44/0f/7ffa221757a220402bc79fda44044c3f2cc57338d878ab7d622add6f4581/pywinpty-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:15c7c0b6f8e9d87aabbaff76468dabf6e6121332c40fc1d83548d02a9d6a3759", size = 233107, upload-time = "2026-02-04T21:51:45.455Z" }, + { url = "https://files.pythonhosted.org/packages/28/88/2ff917caff61e55f38bcdb27de06ee30597881b2cae44fbba7627be015c4/pywinpty-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:d4b6b7b0fe0cdcd02e956bd57cfe9f4e5a06514eecf3b5ae174da4f951b58be9", size = 2113282, upload-time = "2026-02-04T21:52:08.188Z" }, + { url = "https://files.pythonhosted.org/packages/63/32/40a775343ace542cc43ece3f1d1fce454021521ecac41c4c4573081c2336/pywinpty-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:34789d685fc0d547ce0c8a65e5a70e56f77d732fa6e03c8f74fefb8cbb252019", size = 234207, upload-time = "2026-02-04T21:51:58.687Z" }, + { url = "https://files.pythonhosted.org/packages/8d/54/5d5e52f4cb75028104ca6faf36c10f9692389b1986d34471663b4ebebd6d/pywinpty-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0c37e224a47a971d1a6e08649a1714dac4f63c11920780977829ed5c8cadead1", size = 2112910, upload-time = "2026-02-04T21:52:30.976Z" }, + { url = "https://files.pythonhosted.org/packages/0a/44/dcd184824e21d4620b06c7db9fbb15c3ad0a0f1fa2e6de79969fb82647ec/pywinpty-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c4e9c3dff7d86ba81937438d5819f19f385a39d8f592d4e8af67148ceb4f6ab5", size = 233425, upload-time = "2026-02-04T21:51:56.754Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "regex" +version = "2026.5.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/0e/49aee608ad09480e7fd276898c99ec6192985fa331abe4eb3a986094490b/regex-2026.5.9.tar.gz", hash = "sha256:a8234aa23ec39894bfe4a3f1b85616a7032481964a13ac6fc9f10de4f6fca270", size = 416074, upload-time = "2026-05-09T23:15:19.37Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/da/797e91ecec6f84135da778ddce78c20e0af5d2a15c26f87a81bc3eadb6db/regex-2026.5.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d626b84406444b165fc0ba981604edea39f0588ff1f92baa23fe50799ea9afdb", size = 490303, upload-time = "2026-05-09T23:13:04.382Z" }, + { url = "https://files.pythonhosted.org/packages/44/da/bf30abaaa737b58f4a4b8c4a03659e02fd92092c822e0197ed9e0daab917/regex-2026.5.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d7bdc0ab8f3dd7e1b4f9ab88634e13374669db86bb3c72e8292f07ae313f539f", size = 292019, upload-time = "2026-05-09T23:13:06.022Z" }, + { url = "https://files.pythonhosted.org/packages/2d/e7/d0eaf5713828417b9e5648cf81fa9bacd4961f6ab98c380c2034f8716e35/regex-2026.5.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a8820737949116ffff55fe18f9fc644530063ba6ebfcb8314239416e78f1347c", size = 289468, upload-time = "2026-05-09T23:13:08.214Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9b/b3fdd62b003baa1a9b593cd8c8699c9651c2e80cc21a5c715707983c42d7/regex-2026.5.9-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0fbdbac82cb3e4450d0ccde7d7a35607f4cb2dd9fba4b8b69bfaf8c9fa6aed", size = 796749, upload-time = "2026-05-09T23:13:10.573Z" }, + { url = "https://files.pythonhosted.org/packages/d4/30/66ab84588765f5b4b271a9ca09ef7ce2b87caa95176ec3d2ad65d7bc4902/regex-2026.5.9-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:57e8915c7986aa33d25e4d3629cef711cd2863f2961b10409f0c04cb8b7d9020", size = 865445, upload-time = "2026-05-09T23:13:12.523Z" }, + { url = "https://files.pythonhosted.org/packages/1a/89/f05169e8588aac365f35ffc7f3bc3184f095ef4cfded7cfaa3c7fd5dbd89/regex-2026.5.9-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:508f56a89ba9cb26e4168cbc37dbd60a28d82430a9e18ad1d25fe0883c314ca2", size = 912322, upload-time = "2026-05-09T23:13:14.281Z" }, + { url = "https://files.pythonhosted.org/packages/30/e1/c93444052cf41581f3c884ab3fb5823daf0992f11cd4388d4275ca610558/regex-2026.5.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6d189041f15691cfa2b6c4290448ec221244d225b3f5fe9e7771b34ffcdf6e2", size = 801269, upload-time = "2026-05-09T23:13:16.569Z" }, + { url = "https://files.pythonhosted.org/packages/50/fe/0cf96b882f540e62e8b9956599798203d599c44cf4c77917ca27400ff69b/regex-2026.5.9-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e82db382b44d0111b22601c509c89f64434816c9e0eef9d1989cda8cc6ff1c04", size = 777085, upload-time = "2026-05-09T23:13:18.675Z" }, + { url = "https://files.pythonhosted.org/packages/23/5c/d78d4924e7fc875557b9e9b768423925fdfaac5549d06da7810019a9bd26/regex-2026.5.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2acfb48634f64996b57f90f39afa692ff362162722581921fe92239a59960f3c", size = 785153, upload-time = "2026-05-09T23:13:20.525Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e0/5214774090e7b4524dcea3e3c4aa74141d43043f8beb49c1599db1c8b53a/regex-2026.5.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d29eebfc9525db68cad3c97eedd7f754fa265aa5cd0cf4f863b2421e1b48fc9f", size = 860164, upload-time = "2026-05-09T23:13:22.263Z" }, + { url = "https://files.pythonhosted.org/packages/6e/e1/4a57a83350319b1271f0d7a249b8672513ed928b237a741631270de6caea/regex-2026.5.9-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:debb893095e944091c16e641a6e33c1b0f4cb61ab945ec5afbf53ce7068834d8", size = 765731, upload-time = "2026-05-09T23:13:24.277Z" }, + { url = "https://files.pythonhosted.org/packages/12/f4/499e74a20c156fc75836ee04a72a38d1a063978f600937f9760467beb1b0/regex-2026.5.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d659eee77986549c9ea45b861c7567e44d6287c3dc9a4565478853f7b9fe2ff6", size = 852062, upload-time = "2026-05-09T23:13:26.125Z" }, + { url = "https://files.pythonhosted.org/packages/5b/92/7eebc0d0a01e78629695f342ba17e0deaff8fb45e79cc0d7b98287da6e3e/regex-2026.5.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2efa205e6d98b24d1f3ab395c11aa15cdf10935bca283d0285e0499c284fba21", size = 789577, upload-time = "2026-05-09T23:13:27.814Z" }, + { url = "https://files.pythonhosted.org/packages/05/a4/018e71f7d2ad48c1ebe6d3ae0026f9b7cb4802fd15c7cc02fdf724355102/regex-2026.5.9-cp313-cp313-win32.whl", hash = "sha256:f3844f134e834076677dd369976e9f5068679fcb8e50102fdf6b7ac96a3ec127", size = 266691, upload-time = "2026-05-09T23:13:29.549Z" }, + { url = "https://files.pythonhosted.org/packages/e6/1d/861a93719fb9ee7dbfc3761b3797b7a3e112a5d42c6129459d2d741be9b5/regex-2026.5.9-cp313-cp313-win_amd64.whl", hash = "sha256:3527bb4942d2c14552155406cdedd906567456821848aed1cb4933a391bf5eca", size = 277747, upload-time = "2026-05-09T23:13:31.859Z" }, + { url = "https://files.pythonhosted.org/packages/d9/c6/0a2436ae4da1ba76e51cb98943c6838a9a721faa40ebe2dce07694ae34e3/regex-2026.5.9-cp313-cp313-win_arm64.whl", hash = "sha256:56a33f191f17d8c417f99945ebdc1e691d3af9605d86ec68c7e54a57e3e17af6", size = 270500, upload-time = "2026-05-09T23:13:33.525Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e9/d21346f7b60ed58789371358ed66b09d00f832e1bd7c06e55d9da5679882/regex-2026.5.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:01f28d868834624c934b8d2e0aa1c8341337e37831f4a012f18a5afcba4cbaf3", size = 494172, upload-time = "2026-05-09T23:13:35.935Z" }, + { url = "https://files.pythonhosted.org/packages/c4/43/fd1177a2032037c681baecdb3422ee4e1424aec4e4f470ef47793d325274/regex-2026.5.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:48036f6374aaa79eb3b754ec29c61d1c6b1606749d705a13f8854fa2539671f6", size = 293952, upload-time = "2026-05-09T23:13:38.307Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7d/9fbf919768368d3f8a4f6c692cf2aa61e482b2b81ec6a298ace4cbf02480/regex-2026.5.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b96350aa424e79d4fd6b567b344dcbe2b2d6bfc48dfe7717587e1fa6d43da6ff", size = 292314, upload-time = "2026-05-09T23:13:40.353Z" }, + { url = "https://files.pythonhosted.org/packages/e2/6c/e41bfeecb589716843e7c4df09ba46ff2a42961457afece19059d85caeef/regex-2026.5.9-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f3af7a4903c5c04a11a196a5aa75cdd7dd3f8508132f9fb3259d9f5908e3b88", size = 811681, upload-time = "2026-05-09T23:13:42.543Z" }, + { url = "https://files.pythonhosted.org/packages/87/83/a5c1c525fba0aa656e88ad0face0b1829788ef4c2fb6b26df58aa1151b84/regex-2026.5.9-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e87577720152d2caae19fe2baaf1f8d5ca12091e9e229f03915c37d1e4b9178", size = 871135, upload-time = "2026-05-09T23:13:44.326Z" }, + { url = "https://files.pythonhosted.org/packages/18/d4/80882e799e440dd878b0979cbebf8fa4d54624a332c83037c7a701649e3f/regex-2026.5.9-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c8b9b9d294cfea3cd19c718ade7cc93492b2c4991abd9a68d0b3477ae6d8e100", size = 917265, upload-time = "2026-05-09T23:13:47.295Z" }, + { url = "https://files.pythonhosted.org/packages/ae/ff/8db60211e2286e396aad7dc7725356c502bff0901ea05bd6cdc2e1a042b9/regex-2026.5.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:728d8bfd28a8845c8b6bc5dc7ce010453d206396786c0765c2740cb65f37791e", size = 816311, upload-time = "2026-05-09T23:13:49.885Z" }, + { url = "https://files.pythonhosted.org/packages/4c/47/742ef579c61730f8d268e5cf1f9ce0e37e2ea041ad0f5644724f2378e463/regex-2026.5.9-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7e30b874d341fac767d7df5a0870540541c2c054b80cfaac116e8d367a8a7ff2", size = 785498, upload-time = "2026-05-09T23:13:52.25Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ab/cb0999802dcb0fb95b1ab005e8d4163d8afdd67efc2cb6b6630ac13f8cb1/regex-2026.5.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fd190e88a895a8901325fad284a3f74ea52b1da8525b76cc811fa9b1edf0ce2b", size = 801348, upload-time = "2026-05-09T23:13:54.127Z" }, + { url = "https://files.pythonhosted.org/packages/7d/62/8ca59a24c55bc34d166eefaf3717bd77772f329fdbf984d86581e0a3571c/regex-2026.5.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:8e76e8161ad00694cfce6767d5dea860c6391ac5b83e5c3a39661e696f11fc7e", size = 866493, upload-time = "2026-05-09T23:13:56.067Z" }, + { url = "https://files.pythonhosted.org/packages/8d/3d/30f2ae62cef3278bb5bb821f467277a55fb73f01032cf85997e15e8289a8/regex-2026.5.9-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ddda5340e6c01a293027dd46232fa79eaff1b48058ce7a98f572b6445b088041", size = 772811, upload-time = "2026-05-09T23:13:57.867Z" }, + { url = "https://files.pythonhosted.org/packages/d8/ae/7d2089bcd78ad0c0161bc684339df50032acb438a7bd3305e7ddb1193cec/regex-2026.5.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:205109e96b3cf5adf8f4cd62bedde9487feb282b9497a3535451e5a24cd706a0", size = 856584, upload-time = "2026-05-09T23:13:59.679Z" }, + { url = "https://files.pythonhosted.org/packages/a9/29/92ff47f75990131ea4f24ba17819e5a9d141e10819807e09addd73409af6/regex-2026.5.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbe4579b9f08036aa7d101d1835437a20783574ac66327e6b29b4018a138081", size = 803453, upload-time = "2026-05-09T23:14:01.978Z" }, + { url = "https://files.pythonhosted.org/packages/04/99/eff29f1037dcab36702c9ee5d6858cf1ce2336ea8ea2987f64245b99ea5e/regex-2026.5.9-cp313-cp313t-win32.whl", hash = "sha256:ed2c9e8068b614c574d8d30e543d617cf5379b0535d46f97ef00e904745a08b5", size = 269951, upload-time = "2026-05-09T23:14:03.661Z" }, + { url = "https://files.pythonhosted.org/packages/0e/9d/8870b8981d27b22cda77bb26a5ac7ebfa9c7d9e0dea195a834a82380e748/regex-2026.5.9-cp313-cp313t-win_amd64.whl", hash = "sha256:b46b0f094dc1d3b90356c85a0bd2c9bafc4a6a190b9d6f8ddd5a033b6e088ed4", size = 281240, upload-time = "2026-05-09T23:14:05.56Z" }, + { url = "https://files.pythonhosted.org/packages/72/b1/3379415e8f135c13ac551353397cc4fe97b4978f3cac73c5fcbcded548b8/regex-2026.5.9-cp313-cp313t-win_arm64.whl", hash = "sha256:872acc074bd29ffc9913ecdfedf6ea77502312ca44a4aa0d3779089c6069d8de", size = 272383, upload-time = "2026-05-09T23:14:07.843Z" }, + { url = "https://files.pythonhosted.org/packages/13/3e/9c3cd292d8808b3645a2ce517e200179b6d0e903f176300bd8b542e14de5/regex-2026.5.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:1bd7587a2948b4085195d5a3374eaf4a425dc3e55784c038175355ecf3bbbf8a", size = 490376, upload-time = "2026-05-09T23:14:09.64Z" }, + { url = "https://files.pythonhosted.org/packages/60/70/d43ee8a2ca0a8b68d167f21658b85520ac0574617c7f320367c5047f7556/regex-2026.5.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:dea2e88e1cce4522496cce630e11e67b98b7076620bc4336c3f674bc21a375f4", size = 291964, upload-time = "2026-05-09T23:14:11.424Z" }, + { url = "https://files.pythonhosted.org/packages/21/91/9d50b433828d8e74196904e168a43abf1e6e88b2a15d47ed742456720c37/regex-2026.5.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2099f7e7ff7b6aa3192312650a56e91cc091e49d50b04e4f6f8b6e28b3b27f1c", size = 289682, upload-time = "2026-05-09T23:14:13.123Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d2/b835e3cafbb9d977736912436259ff551d60919f7d7b3d37d46659c63564/regex-2026.5.9-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecd353045824e4477562a2ac718c25799cdaaa41f7aa925a806a8a3e6848a5b9", size = 796996, upload-time = "2026-05-09T23:14:14.923Z" }, + { url = "https://files.pythonhosted.org/packages/2c/a6/9f992d00019166b9de01c546dd4549bc679f2a68df11b877740b0760b7c2/regex-2026.5.9-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65c8c8c37377794bd5b2f3ebe51919042bf17aec802e23c833d89782ed0c78af", size = 866089, upload-time = "2026-05-09T23:14:17.757Z" }, + { url = "https://files.pythonhosted.org/packages/e0/08/4d32af657e049b19cb62b02e46e38fe1518797bfb2203ee93a510b21b0dc/regex-2026.5.9-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b73ab8afcf66c622db143d1c6fda4e58e4d537ee4f125229ad47b1ab80f34c0", size = 911530, upload-time = "2026-05-09T23:14:20.353Z" }, + { url = "https://files.pythonhosted.org/packages/d9/27/2af43dd1dc201d1fecefda64a45f4ad0995855b92724f795a777b402ee69/regex-2026.5.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0de5cf193997384ed2ca6f1cd4f78055b255d93d82d5a8cd6ba0d11c10b167e4", size = 800643, upload-time = "2026-05-09T23:14:22.265Z" }, + { url = "https://files.pythonhosted.org/packages/a4/dd/23a249047013b5321d4a60c4d2437462086f601b061776a525e5fba2a59f/regex-2026.5.9-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d641a8c9a61618047796d572a39a79b26167b0411d2c3031937b2fe2d081e2cf", size = 777223, upload-time = "2026-05-09T23:14:24.179Z" }, + { url = "https://files.pythonhosted.org/packages/94/6a/e85ed9538cd19586d0465076a4578a12e093ce776d15f3f8ce92733a8dd6/regex-2026.5.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:24b2355ef5cc9aa5b8f07d17704face1c166fdcc2290fa7bd6e6c925655a8346", size = 785760, upload-time = "2026-05-09T23:14:26.065Z" }, + { url = "https://files.pythonhosted.org/packages/2a/c4/f25473209438638e947c55f9156fd8f236f74169229028cc99116380868e/regex-2026.5.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a24852d3c29ad9e47593593d8a247c44ccc3d0548ef12c822d6ed0810affe676", size = 860891, upload-time = "2026-05-09T23:14:28.17Z" }, + { url = "https://files.pythonhosted.org/packages/f9/f7/f4f86e3c74419c37370e91f150ae0c2ef7d34b2e0e4cdd5da046a02e4022/regex-2026.5.9-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:916714069da19329ef7de197dcbc77bb3104145c7c2c864dbfbe318f46b88b14", size = 765891, upload-time = "2026-05-09T23:14:30.06Z" }, + { url = "https://files.pythonhosted.org/packages/26/70/704d8e13765939146b1cd0ef4e2feb71d7929727d2290f026eed10095955/regex-2026.5.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:fa411799ca8da32a8d38d020a88faa5b6f91657d284761352940ecf9f7c3bbdd", size = 851380, upload-time = "2026-05-09T23:14:32.123Z" }, + { url = "https://files.pythonhosted.org/packages/26/29/1a13582a8460038edc38e49f64ceb0dd7c60f5caba77571f4bf6601965d9/regex-2026.5.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1e6da47d679b7010ef27556b6e0f99771b744936db1792a10ceac6547ae1503e", size = 789350, upload-time = "2026-05-09T23:14:34.799Z" }, + { url = "https://files.pythonhosted.org/packages/73/56/3dcafe34fc72e271d62ad9a291801e88a1457bb251c132f15fcc2e5aad1a/regex-2026.5.9-cp314-cp314-win32.whl", hash = "sha256:98bd73080e8756255137e1bd3f3f00295bbc5aa383c0e0f973920e9134d7c4ad", size = 272130, upload-time = "2026-05-09T23:14:36.729Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9c/02eebf0be95efe416c664db7fb8b6b05b7a0b06a7544f2884f2558b0526f/regex-2026.5.9-cp314-cp314-win_amd64.whl", hash = "sha256:ff8d372ac2acdc048d1c19916f27ee61bc5722728458ba6ca5052f2c72d51763", size = 280999, upload-time = "2026-05-09T23:14:39.126Z" }, + { url = "https://files.pythonhosted.org/packages/70/5a/1dd1abee76cb7a846a0bcf42fdc87e5720c3c33c24f3e37814310a513d9f/regex-2026.5.9-cp314-cp314-win_arm64.whl", hash = "sha256:e1d93bf647916292e8edcec150c07ddf3dc50179ccaf770c04a7f9e452155372", size = 273500, upload-time = "2026-05-09T23:14:41.059Z" }, + { url = "https://files.pythonhosted.org/packages/86/c1/c5f619b0057a7965cb78ec559c1d7a45ce8c99a35bea95483d64959a93d9/regex-2026.5.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:83d0ee4a57d1c87cb549e195ec300b8f0ec3a82eba66d835e4e2ed8634fe4499", size = 494269, upload-time = "2026-05-09T23:14:42.869Z" }, + { url = "https://files.pythonhosted.org/packages/05/2c/5d01f1aee33de4bbe60c8452945bfc8477ca7c5ae4450f6bfe711036cb36/regex-2026.5.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d3d7eb5c9a7f6df82ed3cfac9beb93882a5cbcb5b8b157b56cb2b3b276574ac1", size = 293954, upload-time = "2026-05-09T23:14:44.822Z" }, + { url = "https://files.pythonhosted.org/packages/7a/fe/e8988b2ae2108c6ef71bd4aa8d87fbe257976dd0810e826cd75f701c68b6/regex-2026.5.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:075160bf16658e16d35233300b8453aac25de4cbea808d22348b6979668e924d", size = 292405, upload-time = "2026-05-09T23:14:47.211Z" }, + { url = "https://files.pythonhosted.org/packages/79/34/d2b0937faa7859263f7f0a3c6b103a1296306be6952dc173d0154e9a2f49/regex-2026.5.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45375819235558a4ff1c4971dc32881f022613abdb180128f5cb4768c1765a1c", size = 811855, upload-time = "2026-05-09T23:14:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/80/fe/daf53a47457a8486db66c66c01ceb9c2303eecee3f87197f1e77eb1a736d/regex-2026.5.9-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ead4b163ac30a29574510cd4b3e2e985ac5290c05fc7095557d6a5f403fc31b5", size = 871189, upload-time = "2026-05-09T23:14:51.555Z" }, + { url = "https://files.pythonhosted.org/packages/1c/75/058fc4470cbfbf57d800aff1a0022b929a3f9fa553ee10a0cdf2070eb31f/regex-2026.5.9-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c6e4218fbdfbcd4f6c19efca40930d24a621bf4b48cb76bc6640543bd28ef20", size = 917485, upload-time = "2026-05-09T23:14:53.633Z" }, + { url = "https://files.pythonhosted.org/packages/88/e7/179cfda3a28bc843b5c6cfe7f79f23489c791ed95f151083803660878432/regex-2026.5.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6351571c8a42b505eb555c0dc47d740d0fb66977dc142919eea6f4325b7c56a0", size = 816369, upload-time = "2026-05-09T23:14:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/41/90/6f0cc422071688266d344fca8462d787cba0a2c144acb25721f9a61ec265/regex-2026.5.9-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:002205cafd2a9e78c6290c7d1df277bf3277b3b7a30e0b4bb0dac2e2e3f7cb2d", size = 785869, upload-time = "2026-05-09T23:14:58.602Z" }, + { url = "https://files.pythonhosted.org/packages/02/67/a31f1760f09c27b251ef39e9beb541f462cf977381d067faa764c2c0e393/regex-2026.5.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8abd33fef90b2a9efac5557d6033ca82d1195ed3a15fea5af15ba7b463c6a63b", size = 801427, upload-time = "2026-05-09T23:15:00.642Z" }, + { url = "https://files.pythonhosted.org/packages/e3/c4/1a80654597b6bc1e1ea0494824c31200e8a956abe290afae9b19a166a148/regex-2026.5.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:31037c82eccb44b7ea2e9e221d7c01429430e989a1f4b91ea5a855f6017b509a", size = 866482, upload-time = "2026-05-09T23:15:03.384Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/960724e06482c08466ff5611e242e86f80062949cdf6b4b9cc317b9dd93d/regex-2026.5.9-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5604dfd046dc37eca90250fc3be938b076c8059fa772ac0ed6f499b0f0fb0415", size = 773022, upload-time = "2026-05-09T23:15:05.625Z" }, + { url = "https://files.pythonhosted.org/packages/50/a8/a9979c3e7918280e93159ebcab5ef1a65116dd4f3bd6091be0eae4a126e8/regex-2026.5.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e1b1b4e496afbb24f4a62aba855ee4f88f25578927697b340702e48c9ee6bc2", size = 856642, upload-time = "2026-05-09T23:15:07.966Z" }, + { url = "https://files.pythonhosted.org/packages/fe/d4/a9b732f2f0072c0ab12227483abb24fffcb9f73f8a2b203df0a6d0434735/regex-2026.5.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:be3372b9df6ddecff6486d37e19095a7b4973137caf5512407a89f4455361f41", size = 803552, upload-time = "2026-05-09T23:15:10.215Z" }, + { url = "https://files.pythonhosted.org/packages/d5/fe/1b3113817447a1d4155e4ac76d2e072f42c0bcba2f43fa8a0e756ea2cd91/regex-2026.5.9-cp314-cp314t-win32.whl", hash = "sha256:3ddd90103f9e5c471c49c7852ecc1fe27c7e45eb99e977aefe7caa4e779f4f58", size = 275746, upload-time = "2026-05-09T23:15:12.609Z" }, + { url = "https://files.pythonhosted.org/packages/92/73/93d42045302636c91f2e5ef588b65b84b01428f28ec77de256b1dfdfbe5c/regex-2026.5.9-cp314-cp314t-win_amd64.whl", hash = "sha256:ca518ed29c46eecba6010b15f1b9a479314d2de409536e71b6a13aa04e3b8a77", size = 285685, upload-time = "2026-05-09T23:15:15.086Z" }, + { url = "https://files.pythonhosted.org/packages/da/80/35b4c33c804a165a7f55289afda3ea9e3eb6d15800341a2d66455c0f1f30/regex-2026.5.9-cp314-cp314t-win_arm64.whl", hash = "sha256:5e41809d2683fcde7d5a8c87a6567ba1fb1ce0de9f31bff578de00a4b2d76daa", size = 275713, upload-time = "2026-05-09T23:15:16.98Z" }, +] + +[[package]] +name = "rembg" +version = "2.0.75" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "pooch" }, + { name = "pymatting" }, + { name = "scikit-image" }, + { name = "scipy" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/1c/4d9a81d452d44d914e8ab3e964809ff2388f6919324f005513aa61e1c378/rembg-2.0.75.tar.gz", hash = "sha256:e2143fb5838c8b2238fa45d765ce18d0710801d5aef73f2c4ac9377991d1f526", size = 30148, upload-time = "2026-04-08T11:45:15.42Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/09/60b6d1e6b07520a133ec4522cf7c1a6d684301b64bc7a7b96aad6baa1e21/rembg-2.0.75-py3-none-any.whl", hash = "sha256:536cc7aec597e6e17d805992f9014e6082b5bef76b1b68034d746e0690af3a94", size = 45011, upload-time = "2026-04-08T11:45:16.533Z" }, +] + +[package.optional-dependencies] +cpu = [ + { name = "onnxruntime" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "rpds-py" +version = "0.30.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" }, + { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" }, + { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" }, + { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" }, + { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" }, + { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" }, + { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" }, + { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" }, + { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" }, + { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" }, + { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" }, + { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" }, + { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" }, + { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" }, + { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" }, + { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" }, + { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" }, + { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" }, + { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" }, + { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" }, + { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" }, + { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" }, + { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" }, + { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" }, + { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" }, + { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" }, + { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" }, + { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" }, + { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" }, + { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" }, + { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" }, + { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" }, + { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" }, + { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" }, + { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" }, + { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" }, + { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" }, + { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" }, +] + +[[package]] +name = "safetensors" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", hash = "sha256:07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0", size = 200878, upload-time = "2025-11-19T15:18:43.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/47/aef6c06649039accf914afef490268e1067ed82be62bcfa5b7e886ad15e8/safetensors-0.7.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c82f4d474cf725255d9e6acf17252991c3c8aac038d6ef363a4bf8be2f6db517", size = 467781, upload-time = "2025-11-19T15:18:35.84Z" }, + { url = "https://files.pythonhosted.org/packages/e8/00/374c0c068e30cd31f1e1b46b4b5738168ec79e7689ca82ee93ddfea05109/safetensors-0.7.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:94fd4858284736bb67a897a41608b5b0c2496c9bdb3bf2af1fa3409127f20d57", size = 447058, upload-time = "2025-11-19T15:18:34.416Z" }, + { url = "https://files.pythonhosted.org/packages/f1/06/578ffed52c2296f93d7fd2d844cabfa92be51a587c38c8afbb8ae449ca89/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542", size = 491748, upload-time = "2025-11-19T15:18:09.79Z" }, + { url = "https://files.pythonhosted.org/packages/ae/33/1debbbb70e4791dde185edb9413d1fe01619255abb64b300157d7f15dddd/safetensors-0.7.0-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8469155f4cb518bafb4acf4865e8bb9d6804110d2d9bdcaa78564b9fd841e104", size = 503881, upload-time = "2025-11-19T15:18:16.145Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1c/40c2ca924d60792c3be509833df711b553c60effbd91da6f5284a83f7122/safetensors-0.7.0-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:54bef08bf00a2bff599982f6b08e8770e09cc012d7bba00783fc7ea38f1fb37d", size = 623463, upload-time = "2025-11-19T15:18:21.11Z" }, + { url = "https://files.pythonhosted.org/packages/9b/3a/13784a9364bd43b0d61eef4bea2845039bc2030458b16594a1bd787ae26e/safetensors-0.7.0-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42cb091236206bb2016d245c377ed383aa7f78691748f3bb6ee1bfa51ae2ce6a", size = 532855, upload-time = "2025-11-19T15:18:25.719Z" }, + { url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48", size = 507152, upload-time = "2025-11-19T15:18:33.023Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a8/4b45e4e059270d17af60359713ffd83f97900d45a6afa73aaa0d737d48b6/safetensors-0.7.0-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1d060c70284127fa805085d8f10fbd0962792aed71879d00864acda69dbab981", size = 541856, upload-time = "2025-11-19T15:18:31.075Z" }, + { url = "https://files.pythonhosted.org/packages/06/87/d26d8407c44175d8ae164a95b5a62707fcc445f3c0c56108e37d98070a3d/safetensors-0.7.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:cdab83a366799fa730f90a4ebb563e494f28e9e92c4819e556152ad55e43591b", size = 674060, upload-time = "2025-11-19T15:18:37.211Z" }, + { url = "https://files.pythonhosted.org/packages/11/f5/57644a2ff08dc6325816ba7217e5095f17269dada2554b658442c66aed51/safetensors-0.7.0-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:672132907fcad9f2aedcb705b2d7b3b93354a2aec1b2f706c4db852abe338f85", size = 771715, upload-time = "2025-11-19T15:18:38.689Z" }, + { url = "https://files.pythonhosted.org/packages/86/31/17883e13a814bd278ae6e266b13282a01049b0c81341da7fd0e3e71a80a3/safetensors-0.7.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:5d72abdb8a4d56d4020713724ba81dac065fedb7f3667151c4a637f1d3fb26c0", size = 714377, upload-time = "2025-11-19T15:18:40.162Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d8/0c8a7dc9b41dcac53c4cbf9df2b9c83e0e0097203de8b37a712b345c0be5/safetensors-0.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4", size = 677368, upload-time = "2025-11-19T15:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/05/e5/cb4b713c8a93469e3c5be7c3f8d77d307e65fe89673e731f5c2bfd0a9237/safetensors-0.7.0-cp38-abi3-win32.whl", hash = "sha256:c74af94bf3ac15ac4d0f2a7c7b4663a15f8c2ab15ed0fc7531ca61d0835eccba", size = 326423, upload-time = "2025-11-19T15:18:45.74Z" }, + { url = "https://files.pythonhosted.org/packages/5d/e6/ec8471c8072382cb91233ba7267fd931219753bb43814cbc71757bfd4dab/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755", size = 341380, upload-time = "2025-11-19T15:18:44.427Z" }, +] + +[[package]] +name = "scikit-image" +version = "0.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "imageio" }, + { name = "lazy-loader" }, + { name = "networkx" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "scipy" }, + { name = "tifffile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/b4/2528bb43c67d48053a7a649a9666432dc307d66ba02e3a6d5c40f46655df/scikit_image-0.26.0.tar.gz", hash = "sha256:f5f970ab04efad85c24714321fcc91613fcb64ef2a892a13167df2f3e59199fa", size = 22729739, upload-time = "2025-12-20T17:12:21.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/48/02357ffb2cca35640f33f2cfe054a4d6d5d7a229b88880a64f1e45c11f4e/scikit_image-0.26.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a2e852eccf41d2d322b8e60144e124802873a92b8d43a6f96331aa42888491c7", size = 12346329, upload-time = "2025-12-20T17:11:11.599Z" }, + { url = "https://files.pythonhosted.org/packages/67/b9/b792c577cea2c1e94cda83b135a656924fc57c428e8a6d302cd69aac1b60/scikit_image-0.26.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:98329aab3bc87db352b9887f64ce8cdb8e75f7c2daa19927f2e121b797b678d5", size = 12031726, upload-time = "2025-12-20T17:11:13.871Z" }, + { url = "https://files.pythonhosted.org/packages/07/a9/9564250dfd65cb20404a611016db52afc6268b2b371cd19c7538ea47580f/scikit_image-0.26.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:915bb3ba66455cf8adac00dc8fdf18a4cd29656aec7ddd38cb4dda90289a6f21", size = 13094910, upload-time = "2025-12-20T17:11:16.2Z" }, + { url = "https://files.pythonhosted.org/packages/a3/b8/0d8eeb5a9fd7d34ba84f8a55753a0a3e2b5b51b2a5a0ade648a8db4a62f7/scikit_image-0.26.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b36ab5e778bf50af5ff386c3ac508027dc3aaeccf2161bdf96bde6848f44d21b", size = 13660939, upload-time = "2025-12-20T17:11:18.464Z" }, + { url = "https://files.pythonhosted.org/packages/2f/d6/91d8973584d4793d4c1a847d388e34ef1218d835eeddecfc9108d735b467/scikit_image-0.26.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:09bad6a5d5949c7896c8347424c4cca899f1d11668030e5548813ab9c2865dcb", size = 14138938, upload-time = "2025-12-20T17:11:20.919Z" }, + { url = "https://files.pythonhosted.org/packages/39/9a/7e15d8dc10d6bbf212195fb39bdeb7f226c46dd53f9c63c312e111e2e175/scikit_image-0.26.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:aeb14db1ed09ad4bee4ceb9e635547a8d5f3549be67fc6c768c7f923e027e6cd", size = 14752243, upload-time = "2025-12-20T17:11:23.347Z" }, + { url = "https://files.pythonhosted.org/packages/8f/58/2b11b933097bc427e42b4a8b15f7de8f24f2bac1fd2779d2aea1431b2c31/scikit_image-0.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:ac529eb9dbd5954f9aaa2e3fe9a3fd9661bfe24e134c688587d811a0233127f1", size = 11906770, upload-time = "2025-12-20T17:11:25.297Z" }, + { url = "https://files.pythonhosted.org/packages/ad/ec/96941474a18a04b69b6f6562a5bd79bd68049fa3728d3b350976eccb8b93/scikit_image-0.26.0-cp313-cp313-win_arm64.whl", hash = "sha256:a2d211bc355f59725efdcae699b93b30348a19416cc9e017f7b2fb599faf7219", size = 11342506, upload-time = "2025-12-20T17:11:27.399Z" }, + { url = "https://files.pythonhosted.org/packages/03/e5/c1a9962b0cf1952f42d32b4a2e48eed520320dbc4d2ff0b981c6fa508b6b/scikit_image-0.26.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9eefb4adad066da408a7601c4c24b07af3b472d90e08c3e7483d4e9e829d8c49", size = 12663278, upload-time = "2025-12-20T17:11:29.358Z" }, + { url = "https://files.pythonhosted.org/packages/ae/97/c1a276a59ce8e4e24482d65c1a3940d69c6b3873279193b7ebd04e5ee56b/scikit_image-0.26.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6caec76e16c970c528d15d1c757363334d5cb3069f9cea93d2bead31820511f3", size = 12405142, upload-time = "2025-12-20T17:11:31.282Z" }, + { url = "https://files.pythonhosted.org/packages/d4/4a/f1cbd1357caef6c7993f7efd514d6e53d8fd6f7fe01c4714d51614c53289/scikit_image-0.26.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a07200fe09b9d99fcdab959859fe0f7db8df6333d6204344425d476850ce3604", size = 12942086, upload-time = "2025-12-20T17:11:33.683Z" }, + { url = "https://files.pythonhosted.org/packages/5b/6f/74d9fb87c5655bd64cf00b0c44dc3d6206d9002e5f6ba1c9aeb13236f6bf/scikit_image-0.26.0-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92242351bccf391fc5df2d1529d15470019496d2498d615beb68da85fe7fdf37", size = 13265667, upload-time = "2025-12-20T17:11:36.11Z" }, + { url = "https://files.pythonhosted.org/packages/a7/73/faddc2413ae98d863f6fa2e3e14da4467dd38e788e1c23346cf1a2b06b97/scikit_image-0.26.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:52c496f75a7e45844d951557f13c08c81487c6a1da2e3c9c8a39fcde958e02cc", size = 14001966, upload-time = "2025-12-20T17:11:38.55Z" }, + { url = "https://files.pythonhosted.org/packages/02/94/9f46966fa042b5d57c8cd641045372b4e0df0047dd400e77ea9952674110/scikit_image-0.26.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:20ef4a155e2e78b8ab973998e04d8a361d49d719e65412405f4dadd9155a61d9", size = 14359526, upload-time = "2025-12-20T17:11:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b4/2840fe38f10057f40b1c9f8fb98a187a370936bf144a4ac23452c5ef1baf/scikit_image-0.26.0-cp313-cp313t-win_amd64.whl", hash = "sha256:c9087cf7d0e7f33ab5c46d2068d86d785e70b05400a891f73a13400f1e1faf6a", size = 12287629, upload-time = "2025-12-20T17:11:43.11Z" }, + { url = "https://files.pythonhosted.org/packages/22/ba/73b6ca70796e71f83ab222690e35a79612f0117e5aaf167151b7d46f5f2c/scikit_image-0.26.0-cp313-cp313t-win_arm64.whl", hash = "sha256:27d58bc8b2acd351f972c6508c1b557cfed80299826080a4d803dd29c51b707e", size = 11647755, upload-time = "2025-12-20T17:11:45.279Z" }, + { url = "https://files.pythonhosted.org/packages/51/44/6b744f92b37ae2833fd423cce8f806d2368859ec325a699dc30389e090b9/scikit_image-0.26.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:63af3d3a26125f796f01052052f86806da5b5e54c6abef152edb752683075a9c", size = 12365810, upload-time = "2025-12-20T17:11:47.357Z" }, + { url = "https://files.pythonhosted.org/packages/40/f5/83590d9355191f86ac663420fec741b82cc547a4afe7c4c1d986bf46e4db/scikit_image-0.26.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ce00600cd70d4562ed59f80523e18cdcc1fae0e10676498a01f73c255774aefd", size = 12075717, upload-time = "2025-12-20T17:11:49.483Z" }, + { url = "https://files.pythonhosted.org/packages/72/48/253e7cf5aee6190459fe136c614e2cbccc562deceb4af96e0863f1b8ee29/scikit_image-0.26.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6381edf972b32e4f54085449afde64365a57316637496c1325a736987083e2ab", size = 13161520, upload-time = "2025-12-20T17:11:51.58Z" }, + { url = "https://files.pythonhosted.org/packages/73/c3/cec6a3cbaadfdcc02bd6ff02f3abfe09eaa7f4d4e0a525a1e3a3f4bce49c/scikit_image-0.26.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6624a76c6085218248154cc7e1500e6b488edcd9499004dd0d35040607d7505", size = 13684340, upload-time = "2025-12-20T17:11:53.708Z" }, + { url = "https://files.pythonhosted.org/packages/d4/0d/39a776f675d24164b3a267aa0db9f677a4cb20127660d8bf4fd7fef66817/scikit_image-0.26.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f775f0e420faac9c2aa6757135f4eb468fb7b70e0b67fa77a5e79be3c30ee331", size = 14203839, upload-time = "2025-12-20T17:11:55.89Z" }, + { url = "https://files.pythonhosted.org/packages/ee/25/2514df226bbcedfe9b2caafa1ba7bc87231a0c339066981b182b08340e06/scikit_image-0.26.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede4d6d255cc5da9faeb2f9ba7fedbc990abbc652db429f40a16b22e770bb578", size = 14770021, upload-time = "2025-12-20T17:11:58.014Z" }, + { url = "https://files.pythonhosted.org/packages/8d/5b/0671dc91c0c79340c3fe202f0549c7d3681eb7640fe34ab68a5f090a7c7f/scikit_image-0.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:0660b83968c15293fd9135e8d860053ee19500d52bf55ca4fb09de595a1af650", size = 12023490, upload-time = "2025-12-20T17:12:00.013Z" }, + { url = "https://files.pythonhosted.org/packages/65/08/7c4cb59f91721f3de07719085212a0b3962e3e3f2d1818cbac4eeb1ea53e/scikit_image-0.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:b8d14d3181c21c11170477a42542c1addc7072a90b986675a71266ad17abc37f", size = 11473782, upload-time = "2025-12-20T17:12:01.983Z" }, + { url = "https://files.pythonhosted.org/packages/49/41/65c4258137acef3d73cb561ac55512eacd7b30bb4f4a11474cad526bc5db/scikit_image-0.26.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cde0bbd57e6795eba83cb10f71a677f7239271121dc950bc060482834a668ad1", size = 12686060, upload-time = "2025-12-20T17:12:03.886Z" }, + { url = "https://files.pythonhosted.org/packages/e7/32/76971f8727b87f1420a962406388a50e26667c31756126444baf6668f559/scikit_image-0.26.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:163e9afb5b879562b9aeda0dd45208a35316f26cc7a3aed54fd601604e5cf46f", size = 12422628, upload-time = "2025-12-20T17:12:05.921Z" }, + { url = "https://files.pythonhosted.org/packages/37/0d/996febd39f757c40ee7b01cdb861867327e5c8e5f595a634e8201462d958/scikit_image-0.26.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:724f79fd9b6cb6f4a37864fe09f81f9f5d5b9646b6868109e1b100d1a7019e59", size = 12962369, upload-time = "2025-12-20T17:12:07.912Z" }, + { url = "https://files.pythonhosted.org/packages/48/b4/612d354f946c9600e7dea012723c11d47e8d455384e530f6daaaeb9bf62c/scikit_image-0.26.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3268f13310e6857508bd87202620df996199a016a1d281b309441d227c822394", size = 13272431, upload-time = "2025-12-20T17:12:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/0a/6e/26c00b466e06055a086de2c6e2145fe189ccdc9a1d11ccc7de020f2591ad/scikit_image-0.26.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fac96a1f9b06cd771cbbb3cd96c5332f36d4efd839b1d8b053f79e5887acde62", size = 14016362, upload-time = "2025-12-20T17:12:12.793Z" }, + { url = "https://files.pythonhosted.org/packages/47/88/00a90402e1775634043c2a0af8a3c76ad450866d9fa444efcc43b553ba2d/scikit_image-0.26.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c1e7bd342f43e7a97e571b3f03ba4c1293ea1a35c3f13f41efdc8a81c1dc8f2", size = 14364151, upload-time = "2025-12-20T17:12:14.909Z" }, + { url = "https://files.pythonhosted.org/packages/da/ca/918d8d306bd43beacff3b835c6d96fac0ae64c0857092f068b88db531a7c/scikit_image-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b702c3bb115e1dcf4abf5297429b5c90f2189655888cbed14921f3d26f81d3a4", size = 12413484, upload-time = "2025-12-20T17:12:17.046Z" }, + { url = "https://files.pythonhosted.org/packages/dc/cd/4da01329b5a8d47ff7ec3c99a2b02465a8017b186027590dc7425cee0b56/scikit_image-0.26.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0608aa4a9ec39e0843de10d60edb2785a30c1c47819b67866dd223ebd149acaf", size = 11769501, upload-time = "2025-12-20T17:12:19.339Z" }, +] + +[[package]] +name = "scipy" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" }, + { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" }, + { url = "https://files.pythonhosted.org/packages/b2/83/15087d945e0e4d48ce2377498abf5ad171ae013232ae31d06f336e64c999/scipy-1.17.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b", size = 22683595, upload-time = "2026-02-23T00:19:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e0/e58fbde4a1a594c8be8114eb4aac1a55bcd6587047efc18a61eb1f5c0d30/scipy-1.17.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6", size = 32896429, upload-time = "2026-02-23T00:19:35.536Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5f/f17563f28ff03c7b6799c50d01d5d856a1d55f2676f537ca8d28c7f627cd/scipy-1.17.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464", size = 35203952, upload-time = "2026-02-23T00:19:42.259Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a5/9afd17de24f657fdfe4df9a3f1ea049b39aef7c06000c13db1530d81ccca/scipy-1.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950", size = 34979063, upload-time = "2026-02-23T00:19:47.547Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/88b1d2384b424bf7c924f2038c1c409f8d88bb2a8d49d097861dd64a57b2/scipy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369", size = 37598449, upload-time = "2026-02-23T00:19:53.238Z" }, + { url = "https://files.pythonhosted.org/packages/35/e5/d6d0e51fc888f692a35134336866341c08655d92614f492c6860dc45bb2c/scipy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448", size = 36510943, upload-time = "2026-02-23T00:20:50.89Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fd/3be73c564e2a01e690e19cc618811540ba5354c67c8680dce3281123fb79/scipy-1.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87", size = 24545621, upload-time = "2026-02-23T00:20:55.871Z" }, + { url = "https://files.pythonhosted.org/packages/6f/6b/17787db8b8114933a66f9dcc479a8272e4b4da75fe03b0c282f7b0ade8cd/scipy-1.17.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a", size = 31936708, upload-time = "2026-02-23T00:19:58.694Z" }, + { url = "https://files.pythonhosted.org/packages/38/2e/524405c2b6392765ab1e2b722a41d5da33dc5c7b7278184a8ad29b6cb206/scipy-1.17.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0", size = 28570135, upload-time = "2026-02-23T00:20:03.934Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c3/5bd7199f4ea8556c0c8e39f04ccb014ac37d1468e6cfa6a95c6b3562b76e/scipy-1.17.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce", size = 20741977, upload-time = "2026-02-23T00:20:07.935Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b8/8ccd9b766ad14c78386599708eb745f6b44f08400a5fd0ade7cf89b6fc93/scipy-1.17.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6", size = 23029601, upload-time = "2026-02-23T00:20:12.161Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a0/3cb6f4d2fb3e17428ad2880333cac878909ad1a89f678527b5328b93c1d4/scipy-1.17.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e", size = 33019667, upload-time = "2026-02-23T00:20:17.208Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c3/2d834a5ac7bf3a0c806ad1508efc02dda3c8c61472a56132d7894c312dea/scipy-1.17.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475", size = 35264159, upload-time = "2026-02-23T00:20:23.087Z" }, + { url = "https://files.pythonhosted.org/packages/4d/77/d3ed4becfdbd217c52062fafe35a72388d1bd82c2d0ba5ca19d6fcc93e11/scipy-1.17.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50", size = 35102771, upload-time = "2026-02-23T00:20:28.636Z" }, + { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" }, + { url = "https://files.pythonhosted.org/packages/06/1c/1172a88d507a4baaf72c5a09bb6c018fe2ae0ab622e5830b703a46cc9e44/scipy-1.17.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c", size = 36562980, upload-time = "2026-02-23T00:20:40.575Z" }, + { url = "https://files.pythonhosted.org/packages/70/b0/eb757336e5a76dfa7911f63252e3b7d1de00935d7705cf772db5b45ec238/scipy-1.17.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49", size = 24856543, upload-time = "2026-02-23T00:20:45.313Z" }, + { url = "https://files.pythonhosted.org/packages/cf/83/333afb452af6f0fd70414dc04f898647ee1423979ce02efa75c3b0f2c28e/scipy-1.17.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717", size = 31584510, upload-time = "2026-02-23T00:21:01.015Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a6/d05a85fd51daeb2e4ea71d102f15b34fedca8e931af02594193ae4fd25f7/scipy-1.17.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9", size = 28170131, upload-time = "2026-02-23T00:21:05.888Z" }, + { url = "https://files.pythonhosted.org/packages/db/7b/8624a203326675d7746a254083a187398090a179335b2e4a20e2ddc46e83/scipy-1.17.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b", size = 20342032, upload-time = "2026-02-23T00:21:09.904Z" }, + { url = "https://files.pythonhosted.org/packages/c9/35/2c342897c00775d688d8ff3987aced3426858fd89d5a0e26e020b660b301/scipy-1.17.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866", size = 22678766, upload-time = "2026-02-23T00:21:14.313Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f2/7cdb8eb308a1a6ae1e19f945913c82c23c0c442a462a46480ce487fdc0ac/scipy-1.17.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350", size = 32957007, upload-time = "2026-02-23T00:21:19.663Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2e/7eea398450457ecb54e18e9d10110993fa65561c4f3add5e8eccd2b9cd41/scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118", size = 35221333, upload-time = "2026-02-23T00:21:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/d9/77/5b8509d03b77f093a0d52e606d3c4f79e8b06d1d38c441dacb1e26cacf46/scipy-1.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068", size = 35042066, upload-time = "2026-02-23T00:21:31.358Z" }, + { url = "https://files.pythonhosted.org/packages/f9/df/18f80fb99df40b4070328d5ae5c596f2f00fffb50167e31439e932f29e7d/scipy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118", size = 37612763, upload-time = "2026-02-23T00:21:37.247Z" }, + { url = "https://files.pythonhosted.org/packages/4b/39/f0e8ea762a764a9dc52aa7dabcfad51a354819de1f0d4652b6a1122424d6/scipy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:3877ac408e14da24a6196de0ddcace62092bfc12a83823e92e49e40747e52c19", size = 37290984, upload-time = "2026-02-23T00:22:35.023Z" }, + { url = "https://files.pythonhosted.org/packages/7c/56/fe201e3b0f93d1a8bcf75d3379affd228a63d7e2d80ab45467a74b494947/scipy-1.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:f8885db0bc2bffa59d5c1b72fad7a6a92d3e80e7257f967dd81abb553a90d293", size = 25192877, upload-time = "2026-02-23T00:22:39.798Z" }, + { url = "https://files.pythonhosted.org/packages/96/ad/f8c414e121f82e02d76f310f16db9899c4fcde36710329502a6b2a3c0392/scipy-1.17.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6", size = 31949750, upload-time = "2026-02-23T00:21:42.289Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b0/c741e8865d61b67c81e255f4f0a832846c064e426636cd7de84e74d209be/scipy-1.17.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1", size = 28585858, upload-time = "2026-02-23T00:21:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1b/3985219c6177866628fa7c2595bfd23f193ceebbe472c98a08824b9466ff/scipy-1.17.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39", size = 20757723, upload-time = "2026-02-23T00:21:52.039Z" }, + { url = "https://files.pythonhosted.org/packages/c0/19/2a04aa25050d656d6f7b9e7b685cc83d6957fb101665bfd9369ca6534563/scipy-1.17.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca", size = 23043098, upload-time = "2026-02-23T00:21:56.185Z" }, + { url = "https://files.pythonhosted.org/packages/86/f1/3383beb9b5d0dbddd030335bf8a8b32d4317185efe495374f134d8be6cce/scipy-1.17.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad", size = 33030397, upload-time = "2026-02-23T00:22:01.404Z" }, + { url = "https://files.pythonhosted.org/packages/41/68/8f21e8a65a5a03f25a79165ec9d2b28c00e66dc80546cf5eb803aeeff35b/scipy-1.17.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a", size = 35281163, upload-time = "2026-02-23T00:22:07.024Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/c8a5e19479554007a5632ed7529e665c315ae7492b4f946b0deb39870e39/scipy-1.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4", size = 35116291, upload-time = "2026-02-23T00:22:12.585Z" }, + { url = "https://files.pythonhosted.org/packages/52/52/e57eceff0e342a1f50e274264ed47497b59e6a4e3118808ee58ddda7b74a/scipy-1.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2", size = 37682317, upload-time = "2026-02-23T00:22:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/11/2f/b29eafe4a3fbc3d6de9662b36e028d5f039e72d345e05c250e121a230dd4/scipy-1.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:eb092099205ef62cd1782b006658db09e2fed75bffcae7cc0d44052d8aa0f484", size = 37345327, upload-time = "2026-02-23T00:22:24.442Z" }, + { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" }, +] + +[[package]] +name = "send2trash" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, +] + +[[package]] +name = "setuptools" +version = "81.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/1c/73e719955c59b8e424d015ab450f51c0af856ae46ea2da83eba51cc88de1/setuptools-81.0.0.tar.gz", hash = "sha256:487b53915f52501f0a79ccfd0c02c165ffe06631443a886740b91af4b7a5845a", size = 1198299, upload-time = "2026-02-06T21:10:39.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/e3/c164c88b2e5ce7b24d667b9bd83589cf4f3520d97cad01534cd3c4f55fdb/setuptools-81.0.0-py3-none-any.whl", hash = "sha256:fdd925d5c5d9f62e4b74b30d6dd7828ce236fd6ed998a08d81de62ce5a6310d6", size = 1062021, upload-time = "2026-02-06T21:10:37.175Z" }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, +] + +[[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, 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, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/2c/0a5f6f8ee0d5589e48c7640213ed5175d52cf540a06725b628cc1a45d6ce/soupsieve-2.8.4.tar.gz", hash = "sha256:e121fd02e975c695e4e9e8774a5ee35d74714b59307868dcc5319ad2d9e3328e", size = 121110, upload-time = "2026-05-24T13:55:57.154Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" }, +] + +[[package]] +name = "spike-image-to-3d" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "accelerate" }, + { name = "diffusers" }, + { name = "einops" }, + { name = "huggingface-hub" }, + { name = "jupyter" }, + { name = "jupyter-collaboration" }, + { name = "jupyter-mcp-server" }, + { name = "jupyterlab" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "omegaconf" }, + { name = "pandas" }, + { name = "pillow" }, + { name = "rembg", extra = ["cpu"] }, + { name = "safetensors" }, + { name = "torch" }, + { name = "torchvision" }, + { name = "transformers" }, + { name = "trimesh" }, + { name = "xatlas" }, +] + +[package.metadata] +requires-dist = [ + { name = "accelerate", specifier = ">=1.13.0" }, + { name = "diffusers", specifier = ">=0.37.1" }, + { name = "einops", specifier = ">=0.8.2" }, + { name = "huggingface-hub", specifier = "<1" }, + { name = "jupyter", specifier = ">=1.1.1" }, + { name = "jupyter-collaboration", specifier = ">=4.4.0" }, + { name = "jupyter-mcp-server", specifier = ">=1.0.2" }, + { name = "jupyterlab", specifier = ">=4.5.7" }, + { name = "matplotlib", specifier = ">=3.10.9" }, + { name = "numpy", specifier = ">=2.4.6" }, + { name = "omegaconf", specifier = ">=2.3.0" }, + { name = "pandas", specifier = ">=3.0.3" }, + { name = "pillow", specifier = ">=12.2.0" }, + { name = "rembg", extras = ["cpu"], specifier = ">=2.0.75" }, + { name = "safetensors", specifier = ">=0.7.0" }, + { name = "torch", specifier = ">=2.12.0" }, + { name = "torchvision", specifier = ">=0.27.0" }, + { name = "transformers", specifier = "==4.46.3" }, + { name = "trimesh", specifier = ">=4.12.2" }, + { name = "xatlas", specifier = ">=0.0.11" }, +] + +[[package]] +name = "sqlite-anyio" +version = "0.2.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/20/a3/7830c95b37f1268dbb47e559d1f1ae027f3a4c36b1f7fc1b2dc5de1c5073/sqlite_anyio-0.2.8.tar.gz", hash = "sha256:d68b51a18c01a7dfa9cedbc319871ce77ab3ed0822518fb32810bb465b52d761", size = 3271, upload-time = "2026-03-02T10:37:43.466Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/aa/182981b92659df83c3eb7d6f8fb0874984d72ad688fa4054cb96bc044bb0/sqlite_anyio-0.2.8-py3-none-any.whl", hash = "sha256:bbdfefb144aed2633d2618ee1508edd3abe67a00389379360949da4671640d86", size = 4041, upload-time = "2026-03-02T10:37:42.246Z" }, +] + +[[package]] +name = "sse-starlette" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "starlette" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f7/2b/58abc2d1fd397e7dde08e947e05c884d8ef2f78d5e2588c17a12d42d6994/sse_starlette-3.4.4.tar.gz", hash = "sha256:07e0fa0460138baf25cdd5fb28683472c3995dc1642225191b3832d62526bcb0", size = 31819, upload-time = "2026-05-12T17:37:17.019Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/67/805710444ea8cc75fbf70b920ed431a560c4bf9c57f7d5a3117213189399/sse_starlette-3.4.4-py3-none-any.whl", hash = "sha256:3f4dd50d8aed2771a091f3a83000323fc3844541c16b4fe585ae2420cc6df973", size = 16514, upload-time = "2026-05-12T17:37:15.601Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "starlette" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/95/66/4d20cdf39a8d6a51e663b7038e3b828ff211d3891a43a713fe7e4643f3a8/starlette-1.1.0.tar.gz", hash = "sha256:e83c7fe0ddecd8719c5b840080325aec0260acec86e9832899e377b91d65e90f", size = 2660060, upload-time = "2026-05-23T16:55:41.376Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/79/920b8e0a8b20f793e8d64855095cb8febabf6175b8550b6f7a547d813891/starlette-1.1.0-py3-none-any.whl", hash = "sha256:7f0dfd38e428aad5cb6f9f667f0ca1d2d8ca3f3385dccac8305f79ec98458382", size = 72899, upload-time = "2026-05-23T16:55:39.201Z" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, +] + +[[package]] +name = "tifffile" +version = "2026.5.15" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/66/0aef917d525767a40edebe088f8ed6a4417e6eb489c58f6805bfa872636b/tifffile-2026.5.15.tar.gz", hash = "sha256:ee4f3e07ee0d8ff4745a8c735ac2b72caa3173c7d6059b00fdc3ff492a0b635b", size = 429998, upload-time = "2026-05-15T20:04:55.896Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/6e/7d8850ff112f8f80d394ca45e89b975a3a43559d47af3137b767669b3294/tifffile-2026.5.15-py3-none-any.whl", hash = "sha256:6715515a53cabc0cefc5c9f13a0ae2c250e63e2ca784ce02d0b6c333810c2a17", size = 266665, upload-time = "2026-05-15T20:04:54.227Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.20.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/25/b1681c1c30ea3ea6e584ae3fffd552430b12faa599b558c4c4783f56d7ff/tokenizers-0.20.3.tar.gz", hash = "sha256:2278b34c5d0dd78e087e1ca7f9b1dcbf129d80211afa645f214bd6e051037539", size = 340513, upload-time = "2024-11-05T17:34:10.403Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/19/36e9eaafb229616cb8502b42030fa7fe347550e76cb618de71b498fc3222/tokenizers-0.20.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e0b630e0b536ef0e3c8b42c685c1bc93bd19e98c0f1543db52911f8ede42cf84", size = 2666813, upload-time = "2024-11-05T17:31:32.783Z" }, + { url = "https://files.pythonhosted.org/packages/b9/c7/e2ce1d4f756c8a62ef93fdb4df877c2185339b6d63667b015bf70ea9d34b/tokenizers-0.20.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a02d160d2b19bcbfdf28bd9a4bf11be4cb97d0499c000d95d4c4b1a4312740b6", size = 2555354, upload-time = "2024-11-05T17:31:34.208Z" }, + { url = "https://files.pythonhosted.org/packages/7c/cf/5309c2d173a6a67f9ec8697d8e710ea32418de6fd8541778032c202a1c3e/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e3d80d89b068bc30034034b5319218c7c0a91b00af19679833f55f3becb6945", size = 2897745, upload-time = "2024-11-05T17:31:35.733Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e5/af3078e32f225e680e69d61f78855880edb8d53f5850a1834d519b2b103f/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:174a54910bed1b089226512b4458ea60d6d6fd93060254734d3bc3540953c51c", size = 2794385, upload-time = "2024-11-05T17:31:37.497Z" }, + { url = "https://files.pythonhosted.org/packages/0b/a7/bc421fe46650cc4eb4a913a236b88c243204f32c7480684d2f138925899e/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:098b8a632b8656aa5802c46689462c5c48f02510f24029d71c208ec2c822e771", size = 3084580, upload-time = "2024-11-05T17:31:39.456Z" }, + { url = "https://files.pythonhosted.org/packages/c6/22/97e1e95ee81f75922c9f569c23cb2b1fdc7f5a7a29c4c9fae17e63f751a6/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:78c8c143e3ae41e718588281eb3e212c2b31623c9d6d40410ec464d7d6221fb5", size = 3093581, upload-time = "2024-11-05T17:31:41.224Z" }, + { url = "https://files.pythonhosted.org/packages/d5/14/f0df0ee3b9e516121e23c0099bccd7b9f086ba9150021a750e99b16ce56f/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b26b0aadb18cd8701077362ba359a06683662d5cafe3e8e8aba10eb05c037f1", size = 3385934, upload-time = "2024-11-05T17:31:43.811Z" }, + { url = "https://files.pythonhosted.org/packages/66/52/7a171bd4929e3ffe61a29b4340fe5b73484709f92a8162a18946e124c34c/tokenizers-0.20.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07d7851a72717321022f3774e84aa9d595a041d643fafa2e87fbc9b18711dac0", size = 2997311, upload-time = "2024-11-05T17:31:46.224Z" }, + { url = "https://files.pythonhosted.org/packages/7c/64/f1993bb8ebf775d56875ca0d50a50f2648bfbbb143da92fe2e6ceeb4abd5/tokenizers-0.20.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:bd44e48a430ada902c6266a8245f5036c4fe744fcb51f699999fbe82aa438797", size = 8988601, upload-time = "2024-11-05T17:31:47.907Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3f/49fa63422159bbc2f2a4ac5bfc597d04d4ec0ad3d2ef46649b5e9a340e37/tokenizers-0.20.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a4c186bb006ccbe1f5cc4e0380d1ce7806f5955c244074fd96abc55e27b77f01", size = 9303950, upload-time = "2024-11-05T17:31:50.674Z" }, + { url = "https://files.pythonhosted.org/packages/66/11/79d91aeb2817ad1993ef61c690afe73e6dbedbfb21918b302ef5a2ba9bfb/tokenizers-0.20.3-cp313-none-win32.whl", hash = "sha256:6e19e0f1d854d6ab7ea0c743d06e764d1d9a546932be0a67f33087645f00fe13", size = 2188941, upload-time = "2024-11-05T17:31:53.334Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ff/ac8410f868fb8b14b5e619efa304aa119cb8a40bd7df29fc81a898e64f99/tokenizers-0.20.3-cp313-none-win_amd64.whl", hash = "sha256:d50ede425c7e60966a9680d41b58b3a0950afa1bb570488e2972fa61662c4273", size = 2380269, upload-time = "2024-11-05T17:31:54.796Z" }, +] + +[[package]] +name = "torch" +version = "2.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cuda-bindings", marker = "sys_platform == 'linux'" }, + { name = "cuda-toolkit", extra = ["cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "nvidia-cublas", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" }, + { name = "setuptools" }, + { name = "sympy" }, + { name = "triton", marker = "sys_platform == 'linux'" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/ca/01896c80ba921676aa45886b2c5b8d774912de2a1f719de48169c6f755cd/torch-2.12.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:90dd587a5f61bfe1307148b581e2084fc5bc4a06e2b90a20e9a36b81087ff16b", size = 88009511, upload-time = "2026-05-13T14:54:47.411Z" }, + { url = "https://files.pythonhosted.org/packages/a5/04/52bdaf4787eab6ac7d7f5851dff934e4def0bc8ead9c8fd2b69b3e529699/torch-2.12.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:864392c73b7654f4d2b3ae712f607937d0dbb1101c4555fbb41848106b297f39", size = 426383231, upload-time = "2026-05-13T14:53:32.129Z" }, + { url = "https://files.pythonhosted.org/packages/49/8a/94bdecd13f5aaa90d45920b89789d9fe7c6f4af8c3cdd7ce01fcb59908fc/torch-2.12.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5d6b560dfa7d56291c07d615c3bb73e8d9943d9b6d87f76cd0d9d570c4797fa6", size = 532269288, upload-time = "2026-05-13T14:53:49.423Z" }, + { url = "https://files.pythonhosted.org/packages/3e/2f/bdbaaa267de519ef1b73054bf590d8c93c37a266c9a4e24a01bd38b6918f/torch-2.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:3fee918902090ade827643e758e98363278815de583c75d111fdd665ebffde9f", size = 122987706, upload-time = "2026-05-13T14:54:00.335Z" }, + { url = "https://files.pythonhosted.org/packages/9b/ad/e95e822f3538171e22640a7fbe839a1fdb666600bf6487025de2ff03b11a/torch-2.12.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:10ee1448a9f304d3b987eb4656f664ba6e4d7b410ca7a5a7c642199777a2cf88", size = 88319556, upload-time = "2026-05-13T14:54:05.574Z" }, + { url = "https://files.pythonhosted.org/packages/b7/07/055d06d985b445d67422d25b033c11cf55bbb81785d4c4e68e28bca5820e/torch-2.12.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:af68dbf403439cae9ceaeaaf92f8352b460787dcd27b92aa05c40dd4a19c0f1e", size = 426397656, upload-time = "2026-05-13T14:52:38.84Z" }, + { url = "https://files.pythonhosted.org/packages/43/94/b0b4fdc3014122e0a7302fb90086d352aa48f2576f0b252561ebb38c01a8/torch-2.12.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:a6a2eebb237d3b1d9ad3b378e86d9b9e0782afdea8b1e0eba6a13646b9b49c07", size = 532183124, upload-time = "2026-05-13T14:53:16.178Z" }, + { url = "https://files.pythonhosted.org/packages/d8/c8/052405e6ad05d3237bfe5a4df78f917773956f8e17813a2d44c059068b74/torch-2.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2140e373e9a51a3e22ef62e8d14366d0b470d18f0adf19fdc757368077133a34", size = 123232462, upload-time = "2026-05-13T14:52:27.26Z" }, + { url = "https://files.pythonhosted.org/packages/67/dc/ac069f8d6e8be701535921141055293b0d4819d3d7f224a4612cf157c7f9/torch-2.12.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f7dfae4a519197dfa050e98d8e36378a0fb5899625a875c2b54445005a2e404e", size = 88027282, upload-time = "2026-05-13T14:53:05.258Z" }, + { url = "https://files.pythonhosted.org/packages/33/c3/1c1eb00e34555b536dddf792676026a988d710ed36981aa00499b36b0620/torch-2.12.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:891c769072637c74e9a5a77a3bc782894696d8ffec83b938df8536dee7f0ba78", size = 426386961, upload-time = "2026-05-13T14:51:28.406Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d4/7e730dba0c7032a4154dc9056b76cf9625515e030e269cfbf8098fcfee7d/torch-2.12.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:e2ad3eb85d39c3cab62dfa93ed5a73516e6a53c6713cb97d004004fe089f0f1f", size = 532272265, upload-time = "2026-05-13T14:51:59.308Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b4/92c80d1bbfee1c0036c06d1d2155a3065bd2423134c83bf8a47e65cd6b9b/torch-2.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:c66696857e987efb8bc1777a37357ec4f60ab5e8af6250b83d6034437fa2d8f3", size = 122987138, upload-time = "2026-05-13T14:51:45.942Z" }, + { url = "https://files.pythonhosted.org/packages/7b/78/2e12b37ce50a19a037d7bc62d652a5a8f27385a7b05859d6bc9204f20cfe/torch-2.12.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:b4556715c8572758625d62b6e0ae3b1f76c440221913a6fb5e100f321fb4fb02", size = 88320100, upload-time = "2026-05-13T14:51:39.955Z" }, + { url = "https://files.pythonhosted.org/packages/56/5e/83c450ec7b0bb40a7b74611c1b5440f9260e33c54c90d556fd4a1f0fd955/torch-2.12.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a43ac605a5e13116c72b64c359644cce0229f213dde48d2ae0ae5eb5becf7feb", size = 426391871, upload-time = "2026-05-13T14:52:14.989Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e9/1a0b575d98d0afedd8f157d23fa3d2759421483660448e60d0a4b10b6daa/torch-2.12.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6a7512adfdd7f6732e40de1c620831e3c75b39b98cef60b11d0c5f0a76473ec5", size = 532192241, upload-time = "2026-05-13T14:51:07.795Z" }, + { url = "https://files.pythonhosted.org/packages/88/21/afadd25ecd81b3cea1e11c73cf1ab41a983a50271548c3ec7ec3b9efc3e9/torch-2.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5f96b63f8287f66a005dd1b5a6abba2920f11156c5e5c4d815f3e2050fd1aa16", size = 123231092, upload-time = "2026-05-13T14:51:18.854Z" }, +] + +[[package]] +name = "torchvision" +version = "0.27.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pillow" }, + { name = "torch" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/ae/36547812e6e047c1d80bcacd1b17a340612b08a6e876e0aabf3d0b9228b0/torchvision-0.27.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:41d6dae73e1af09fa82ded597ae57f2a2314285acde54b25890a8f8e51b999d7", size = 1758826, upload-time = "2026-05-13T14:57:05.262Z" }, + { url = "https://files.pythonhosted.org/packages/ae/30/32c4ea842738728a14e3df8c576c62dedcf5ae5cb6a5c984c6429ebe7524/torchvision-0.27.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:70f071c6f74b60d5fe8851636d8d4cd5f4fa29d57fd9348a87a6f17b990b95ba", size = 7789501, upload-time = "2026-05-13T14:56:57.786Z" }, + { url = "https://files.pythonhosted.org/packages/f6/24/4d0d48684251bd0673f87d633d5d88ab00227983b00591156eed2f86c8d5/torchvision-0.27.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:aaafa6962c9d91f42503de1957d6fa349907d028c06f335bd95da7a5bc57147d", size = 7579868, upload-time = "2026-05-13T14:56:41.618Z" }, + { url = "https://files.pythonhosted.org/packages/ba/da/e6edd051d2ba25adf23b120fa97f458dff888d098c51e84724f17d2d1470/torchvision-0.27.0-cp313-cp313-win_amd64.whl", hash = "sha256:aee384a2782c89517c4ab9061d2720ba59fd2ffe5ef89d0a149cc2d43abdf521", size = 4092700, upload-time = "2026-05-13T14:57:09.729Z" }, + { url = "https://files.pythonhosted.org/packages/fa/23/95dfa40431360f42ca949bf861434bed51164adfa8fb9801e05bf3194f50/torchvision-0.27.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:c5121f1b9ab09a7f73e837871deb8321551f7eaeb19d87aa00de9191968eae44", size = 1845008, upload-time = "2026-05-13T14:57:03.768Z" }, + { url = "https://files.pythonhosted.org/packages/23/b9/9dbdf76b2b49a75ba8088df6f7c755bdb520afb6c6dbac0102b46cde5e99/torchvision-0.27.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:1c01f0d1091ae22b9dfc082b0a0fe5faaf053686a29b4fb082ba7691375c73cf", size = 7791430, upload-time = "2026-05-13T14:56:56.206Z" }, + { url = "https://files.pythonhosted.org/packages/5c/6a/e4a16cf2f3310c2ea7760dc5d9054496844391e0f4c1fae87fefac2f3d9e/torchvision-0.27.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:dadea3c5ecfd05bbb2a3312ab0374f213c58bf6459cb059122e2f4dfe13d10ed", size = 7668441, upload-time = "2026-05-13T14:57:02.127Z" }, + { url = "https://files.pythonhosted.org/packages/00/70/01b6461117a6a94b5af3f8ee166bb0f045056f3cf187750c110dabfdfffa/torchvision-0.27.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a49e55055a39a8506fe7e59850522cab004efb2c3839f6057658889c1d69c815", size = 4141602, upload-time = "2026-05-13T14:56:53.449Z" }, + { url = "https://files.pythonhosted.org/packages/92/22/c0633677b3b3f3e69554a21ac087bf705f829c40cd5e3783507b8c006681/torchvision-0.27.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:c1fac0fc2a7adf29481fc1938a0e7845c57ba1147a986784109c4d98f434ea8c", size = 1758818, upload-time = "2026-05-13T14:56:54.988Z" }, + { url = "https://files.pythonhosted.org/packages/48/e8/55f9d9667b56dae470e69e31beac9b00d458ea393feec1aae95cc4f3f1c9/torchvision-0.27.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:cbf89764fc76f3f17fbf80c12d5a89c691e91cb9d82c38412aaf0568655ffb19", size = 7789667, upload-time = "2026-05-13T14:56:48.858Z" }, + { url = "https://files.pythonhosted.org/packages/00/bc/6f8681daf3bbc4c315bb0005110f99d28e3ecd675bf9c8f2c0d393fbac7a/torchvision-0.27.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:91f61b9865423037c327eb56afa207cc72de874e458c361840db9dcf5ce0c0eb", size = 7579848, upload-time = "2026-05-13T14:56:38.209Z" }, + { url = "https://files.pythonhosted.org/packages/19/6c/8d8020e6bd1e46c53e487c9c4e9457a07f2ee28931028fb5d71e2da40adc/torchvision-0.27.0-cp314-cp314-win_amd64.whl", hash = "sha256:5bb82fc3c55daf1788621e504310b0a286f1069627a8742f692aebb075ef25a7", size = 4119284, upload-time = "2026-05-13T14:56:46.625Z" }, + { url = "https://files.pythonhosted.org/packages/8d/7e/e78c48662a8d551606efdbe11c6b9c1d6d2391b92cd0e4591b9e6a2412b8/torchvision-0.27.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:2c4099a15150143b9b034730b404a56d572efe0b79489b4c765d929cb4eac7f3", size = 1758828, upload-time = "2026-05-13T14:56:52.293Z" }, + { url = "https://files.pythonhosted.org/packages/21/dd/d03ee9f9ee7bf11a8c7c776fb8e7fd6102f59c013791a2a4e5175bd6cba7/torchvision-0.27.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:b4c6bb0a670dcba017b3643e21902c9b8a1cc1c127d602f1488fa29ec3c6e865", size = 7790618, upload-time = "2026-05-13T14:56:44.721Z" }, + { url = "https://files.pythonhosted.org/packages/39/08/4002336a74742be70728603ec1769feb2b55e0d19c532c9ec9f92008de76/torchvision-0.27.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1c2db4bde82bc48ebff73436a6adf34d4f809448268a70d9a1285f5c8f92313d", size = 7580217, upload-time = "2026-05-13T14:56:43.274Z" }, + { url = "https://files.pythonhosted.org/packages/ed/cb/4dd4783eb3565f526ba6e64b6f6ca26c00eacc924cdfe60455db9d91b84b/torchvision-0.27.0-cp314-cp314t-win_amd64.whl", hash = "sha256:72bf547e58ddb948689734eed6f4b6a2031f979dba4fb08e3690688b392e929f", size = 4226392, upload-time = "2026-05-13T14:56:40.235Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/50/57/6d7303a77ae439d9189108f76c0c4fd89ee5e2cc8387bffb55232565c4ed/tornado-6.5.6.tar.gz", hash = "sha256:9a365179fe8ff6b8766f602c0f67c185d778193e9bdd828b19f0b6ed7764177d", size = 518139, upload-time = "2026-05-27T15:35:54.646Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/0d/b4f481e18c5a51864e6d12b9a05ecf72919696680b747c958c3fc1f4fbae/tornado-6.5.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:65fcfaafb079435c2c19dc9e07c0f1cf0fa9051759ed0a7d0a3ba7ea7f64919c", size = 447737, upload-time = "2026-05-27T15:35:38.122Z" }, + { url = "https://files.pythonhosted.org/packages/9e/9c/5430c39fcab1144d35860f457b15e9c08b4bc7ac86764354204e983d6183/tornado-6.5.6-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:38bc01b4acacded2de63ae78023548e41ebe6fbed3ec05a796d7ae3ad893887e", size = 445899, upload-time = "2026-05-27T15:35:40.519Z" }, + { url = "https://files.pythonhosted.org/packages/8b/79/fa7e14a2f939c807a8d30619b4eb604eab219601b78792516ebe22d40cf9/tornado-6.5.6-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b942e6a137fda31ff54bf8e6e2c8d1c37f1f50583f3ed53fb840b53b9601d104", size = 448964, upload-time = "2026-05-27T15:35:42.106Z" }, + { url = "https://files.pythonhosted.org/packages/a7/71/bd67d5f5199f937dafe03a49a37989f60f600ff6fef34c79412a829d97bd/tornado-6.5.6-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8666946e70171b8c3f1fc9b7876fac492e84822c4c7f3746f4e8f8bc9ac92a79", size = 449935, upload-time = "2026-05-27T15:35:43.906Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/c24388c9cf5b3c3a513b56a158af9f23092c9a2810d789e294310797df21/tornado-6.5.6-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1c34cfab7ad6d104f052f55de06d39bbafc5885cfeb4da688803308dbcfa90b7", size = 449767, upload-time = "2026-05-27T15:35:45.793Z" }, + { url = "https://files.pythonhosted.org/packages/a5/eb/6a07ad550c3f7b37244bd0becdf293ec3d3e961783d8b720a97df50de1b2/tornado-6.5.6-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:385f35e4e22fb52551dfcda4cdc8c30c61c2c001aef5ddad99cdfe116952efd3", size = 449174, upload-time = "2026-05-27T15:35:47.485Z" }, + { url = "https://files.pythonhosted.org/packages/bb/84/3469e098dccdb6763130e06aacd786bb4363fca7b590a55c101ddf34ed30/tornado-6.5.6-cp39-abi3-win32.whl", hash = "sha256:db475f1b67b2809b10bb16264829087724ca8d24fe4ed47f7b8675cae453ef86", size = 450230, upload-time = "2026-05-27T15:35:49.322Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3c/273a04e0b9dd9016f1685cca0c1c8795a71ac88a34a8c889a0b443483226/tornado-6.5.6-cp39-abi3-win_amd64.whl", hash = "sha256:6739bf1e8eb09230f1280ddbd3236f0309db70f2c551a8dbc40f62babdf82f79", size = 450667, upload-time = "2026-05-27T15:35:51.194Z" }, + { url = "https://files.pythonhosted.org/packages/02/98/0cffe22a224f60c5fb1e3aa0b76f9da2e1ca78b0e9545e3d077c68ce60a7/tornado-6.5.6-cp39-abi3-win_arm64.whl", hash = "sha256:2543597b24a695d72338a9a77818362d72387c03ae173f1f169eadc5c91466ac", size = 449690, upload-time = "2026-05-27T15:35:52.902Z" }, +] + +[[package]] +name = "tqdm" +version = "4.67.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" }, +] + +[[package]] +name = "traitlets" +version = "5.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/22/40f55b26baeab80c2d7b3f1db0682f8954e4617fee7d90ce634022ef05c6/traitlets-5.15.0.tar.gz", hash = "sha256:4fead733f81cf1c4c938e06f8ca4633896833c9d89eff878159457f4d4392971", size = 163197, upload-time = "2026-05-06T08:05:58.016Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/98/a9937a969d018a23badfea0b381f66783649d48e0ea6c41923265c3cbeb3/traitlets-5.15.0-py3-none-any.whl", hash = "sha256:fb36a18867a6803deab09f3c5e0fa81bb7b26a5c9e82501c9933f759166eff40", size = 85877, upload-time = "2026-05-06T08:05:55.853Z" }, +] + +[[package]] +name = "transformers" +version = "4.46.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/37/5a/58f96c83e566f907ae39f16d4401bbefd8bb85c60bd1e6a95c419752ab90/transformers-4.46.3.tar.gz", hash = "sha256:8ee4b3ae943fe33e82afff8e837f4b052058b07ca9be3cb5b729ed31295f72cc", size = 8627944, upload-time = "2024-11-18T22:13:01.012Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/51/b87caa939fedf307496e4dbf412f4b909af3d9ca8b189fc3b65c1faa456f/transformers-4.46.3-py3-none-any.whl", hash = "sha256:a12ef6f52841fd190a3e5602145b542d03507222f2c64ebb7ee92e8788093aef", size = 10034536, upload-time = "2024-11-18T22:12:57.024Z" }, +] + +[[package]] +name = "trimesh" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/37/5cb90f04990260d2caceb6093560c6cefafca1ec522c1e43be01ca658244/trimesh-4.12.2.tar.gz", hash = "sha256:c8ca31571ac00b112e4e160e66a2d4c3491df321f056bd33806be0485d1af9d9", size = 842220, upload-time = "2026-05-01T00:57:43.333Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/98/716a473cfb24750858ddd5d14e6527539dd206583a46408d08eeb2844a75/trimesh-4.12.2-py3-none-any.whl", hash = "sha256:b5b5afa63c5272345f2858f7676bc8c217dc8a89f4fadf6193fe10a81b5ff2aa", size = 741043, upload-time = "2026-05-01T00:57:40.763Z" }, +] + +[[package]] +name = "triton" +version = "3.7.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/e1/a59a583de59b8f62c495d67c80ee3ea97d09e91ac80c4c6e76456ed8d8ac/triton-3.7.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:abdf6beaa89b1bcfb9a43cd990536ce66091a997841a4814b260b7bee4c88c3c", size = 188503209, upload-time = "2026-05-07T19:05:17.935Z" }, + { url = "https://files.pythonhosted.org/packages/30/b1/b7507bb9815d403927c8dd51d4158ed2e11751a92dbc118a044f247b6848/triton-3.7.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a35d7afe3f3f058e7ec49fcce09794049e0ffc5c59019ac25ec3413741b8c4e7", size = 201453566, upload-time = "2026-05-07T18:46:20.427Z" }, + { url = "https://files.pythonhosted.org/packages/a6/8f/0bea7a6a0c989315c9135a1d7fb37e41905cfb3a17cbc1f10044ebd4cc3a/triton-3.7.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc1d61c172d257db80ddf42595131fb196ad2e9bdd751e90fe2ef13531734e8b", size = 188612899, upload-time = "2026-05-07T19:05:24.955Z" }, + { url = "https://files.pythonhosted.org/packages/e1/02/d96f57828d0912aec733b9bc7e0e7dbfd2c6f079a8fa433ac25cb93d1a30/triton-3.7.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70fb9bbdc9f400afc54bbf6eb2670af28829a6ae3996863317964783141daf56", size = 201553816, upload-time = "2026-05-07T18:46:27.49Z" }, + { url = "https://files.pythonhosted.org/packages/40/fb/82a802dac4689f2a2fb2e69302e6a138eecc3e175bbe976ba3cfc717683a/triton-3.7.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a44a8476d0d3571eac4e4d1048e1ff75aad81a09ff4602ccfc56c6dea1672e", size = 188507879, upload-time = "2026-05-07T19:05:32.209Z" }, + { url = "https://files.pythonhosted.org/packages/8f/af/9904ec6d3c93d9b24e5ec360445bbdf758b7f00bfbeedb89cb0eb64eb8bb/triton-3.7.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9b85e72968a9d8bba5ddb24e9b64aaabaf48affb042f2755cb7cfa92b7531ce", size = 201460637, upload-time = "2026-05-07T18:46:34.749Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f9/4835a8ea746b88727d8899f4e3ccce4f9cacb38abfc3bb0a638266c53111/triton-3.7.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18a160de426fd99f92b0baf509045360afbd3bfaa0b4a5171dde800ec9f09684", size = 188608706, upload-time = "2026-05-07T19:05:39.218Z" }, + { url = "https://files.pythonhosted.org/packages/c1/68/fa86e5a39608000f645535b2c124920126327ab731f8c4fafd5b07ff8d4b/triton-3.7.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce061073102714b725f3660ec6939d94a1da7984b3aa99c921417cae273672f5", size = 201546766, upload-time = "2026-05-07T18:46:42.088Z" }, +] + +[[package]] +name = "typer" +version = "0.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/51/9aed62104cea109b820bbd6c14245af756112017d309da813ef107d42e7e/typer-0.25.1.tar.gz", hash = "sha256:9616eb8853a09ffeabab1698952f33c6f29ffdbceb4eaeecf571880e8d7664cc", size = 122276, upload-time = "2026-04-30T19:32:16.964Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/f9/2b3ff4e56e5fa7debfaf9eb135d0da96f3e9a1d5b27222223c7296336e5f/typer-0.25.1-py3-none-any.whl", hash = "sha256:75caa44ed46a03fb2dab8808753ffacdbfea88495e74c85a28c5eefcf5f39c89", size = 58409, upload-time = "2026-04-30T19:32:18.271Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "tzdata" +version = "2026.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.48.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e6/bf/f6544ba992ddb9a6077343a576f9844f7f8f06ab819aefd00206e9255f18/uvicorn-0.48.0.tar.gz", hash = "sha256:a5504207195d08c2511bf9125ede5ac4a4b71725d519e758d01dcf0bc2d31c37", size = 91074, upload-time = "2026-05-24T12:08:41.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/be/72532be3da7acc5fdfbccdb95215cd04f995a0886532a5b423f929cda4cc/uvicorn-0.48.0-py3-none-any.whl", hash = "sha256:48097851328b87ec36117d3d575234519eb58c2b22d79666e9bbc6c49a761dad", size = 71410, upload-time = "2026-05-24T12:08:40.258Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/ee/afaf0f85a9a18fe47a67f1e4422ed6cf1fe642f0ae0a2f81166231303c52/wcwidth-0.7.0.tar.gz", hash = "sha256:90e3a7ea092341c44b99562e75d09e4d5160fe7a3974c6fb842a101a95e7eed0", size = 182132, upload-time = "2026-05-02T16:04:12.653Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/52/e465037f5375f43533d1a80b6923955201596a99142ed524d77b571a1418/wcwidth-0.7.0-py3-none-any.whl", hash = "sha256:5d69154c429a82910e241c738cd0e2976fac8a2dd47a1a805f4afed1c0f136f2", size = 110825, upload-time = "2026-05-02T16:04:11.033Z" }, +] + +[[package]] +name = "webcolors" +version = "25.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, +] + +[[package]] +name = "websocket-client" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" }, +] + +[[package]] +name = "websockets" +version = "16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" }, + { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" }, + { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" }, + { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" }, + { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" }, + { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" }, + { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" }, + { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" }, + { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" }, + { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" }, + { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" }, + { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" }, + { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" }, + { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" }, + { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" }, + { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" }, + { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" }, + { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/f4/c67440c7fb409a71b7404b7aefcd7569a9c0d6bd071299bf4198ae7a5d95/widgetsnbextension-4.0.15.tar.gz", hash = "sha256:de8610639996f1567952d763a5a41af8af37f2575a41f9852a38f947eb82a3b9", size = 1097402, upload-time = "2025-11-01T21:15:55.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" }, +] + +[[package]] +name = "xatlas" +version = "0.0.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/fe/32adb4dbdf5485c185de9b62b83d434f12ca5be8a000d9882c871808987b/xatlas-0.0.11.tar.gz", hash = "sha256:72f0bc6c42c19252be87e947d9dfe251c8d6c6943fd43e3d173ddc6b1afad693", size = 7718208, upload-time = "2025-07-04T16:46:43.315Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/e7/1dd383c0d28e396f16eee548e2b3f9f4cec8d3ab3db004c8bbcf57a44939/xatlas-0.0.11-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:7d41023193a433ea783df563ccde2bb8bb039dca0896469a3cb32e58db9763da", size = 223491, upload-time = "2025-07-04T16:45:50.239Z" }, + { url = "https://files.pythonhosted.org/packages/4e/64/ccc8ec8aa31eaa09b8b2b8922c50d97af8d41a24254499f5eaf926352c26/xatlas-0.0.11-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:70a459492c0ffcf7e37a77ac37f8a4483acd87aee07de9600e4f056e56c326dd", size = 201092, upload-time = "2025-07-04T16:45:51.224Z" }, + { url = "https://files.pythonhosted.org/packages/f7/9f/2bd9b63d24751db2ba6c85944e09be2bc897aaace224d22dbc764a19487f/xatlas-0.0.11-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7739f75c588808a0ad0b3a730661143dddddceec84401451989b829d9986df94", size = 268197, upload-time = "2025-07-04T16:45:52.673Z" }, + { url = "https://files.pythonhosted.org/packages/85/84/df846c46097331af6a10d3675edefc2ab893cb784c02fc7ab1e8cc580457/xatlas-0.0.11-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c2ba5ca5e26dba5e9a04aab98ee5de0e5a0e8c87a1feae83da11052b83d86dd", size = 260836, upload-time = "2025-07-04T16:45:53.718Z" }, + { url = "https://files.pythonhosted.org/packages/ec/9a/962bc0ddcce7c81e9f08b020132d8b0143f18d8ee49744aca669a2fe1a1b/xatlas-0.0.11-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:494206aa15a28f44691acd1575344181717b300e5602187e7db04fa72e0d1e9b", size = 1414366, upload-time = "2025-07-04T16:45:54.942Z" }, + { url = "https://files.pythonhosted.org/packages/11/15/fe587b62db22b9d5220576995de67d7d00f0d3b8a6d461cc670831820676/xatlas-0.0.11-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ff4c084c1f2cccbc781302484613c4d87fcbab1fa4972a4e84194acb18bbf9d9", size = 1291580, upload-time = "2025-07-04T16:45:56.18Z" }, + { url = "https://files.pythonhosted.org/packages/73/c6/8eba622eead5571c73fb997095ab156ba40f8e99471b9b37053d32a338d4/xatlas-0.0.11-cp313-cp313-win32.whl", hash = "sha256:12d5f37f60bc6a82e538dc553eb3ebe85fd622ecb9b6d32505db4c3ea1202706", size = 185822, upload-time = "2025-07-04T16:45:57.222Z" }, + { url = "https://files.pythonhosted.org/packages/8c/91/116e12b0b7bce720eea981b06b39150ceaef49b044bd3b535316443cfd05/xatlas-0.0.11-cp313-cp313-win_amd64.whl", hash = "sha256:81431d19c3a11dc3fbae95460cd6b16239636b21fa7c30bd5796976a03844ede", size = 207911, upload-time = "2025-07-04T16:45:58.526Z" }, +] + +[[package]] +name = "yarl" +version = "1.24.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/12/1e8f37460ea0f7eb59c221fdaf0ed75e7ac43e97f8093b9c6f411df50a78/yarl-1.24.2.tar.gz", hash = "sha256:9ac374123c6fd7abf64d1fec93962b0bd4ee2c19751755a762a72dd96c0378f8", size = 210798, upload-time = "2026-05-19T21:31:05.599Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/62/fcf0ce677f17e5c471c06311dd25964be38a4c586993632910d2e75278bc/yarl-1.24.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:491ac9141decf49ee8030199e1ee251cdff0e131f25678817ff6aa5f837a3536", size = 128978, upload-time = "2026-05-19T21:29:23.83Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/8e63299bb71ed61a834121d9d3fe6c9fcf2a6a5d09754ff4f20f2d20baf5/yarl-1.24.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e89418f65eda18f99030386305bd44d7d504e328a7945db1ead514fbe03a0607", size = 91733, upload-time = "2026-05-19T21:29:25.375Z" }, + { url = "https://files.pythonhosted.org/packages/c1/24/16748d5dab6daec8b0ed81ccec639a1cded0f18dcc62a4f696b4fe366c37/yarl-1.24.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cdfcce633b4a4bb8281913c57fcafd4b5933fbc19111a5e3930bbd299d6102f1", size = 91113, upload-time = "2026-05-19T21:29:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/1b/66/b63fff7b71211e866624b21432d5943cbb633eb0c2872d9ee3070648f22c/yarl-1.24.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:863297ddede92ee49024e9a9b11ecb59f310ca85b60d8537f56bed9bbb5b1986", size = 103899, upload-time = "2026-05-19T21:29:28.842Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/ba1974b8533909636f7733fe86cf677e3619527c3c2fa913e0ea89c48757/yarl-1.24.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:374423f70754a2c96942ede36a29d37dc6b0cb8f92f8d009ddf3ed78d3da5488", size = 97862, upload-time = "2026-05-19T21:29:31.086Z" }, + { url = "https://files.pythonhosted.org/packages/1b/a5/123ac993b5c2ba6f554a140305620cb8f150fa543711bbc49be3ec0a65a4/yarl-1.24.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:33a29b5d00ccbf3219bb3e351d7875739c19481e030779f48cc46a7a71681a9b", size = 111060, upload-time = "2026-05-19T21:29:32.657Z" }, + { url = "https://files.pythonhosted.org/packages/23/37/c472d3af3509688392134a88a825276770a187f1daa4de3f6dc0a327a751/yarl-1.24.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a9532c57211730c515341af11fef6e9b61d157487272a096d0c04da445642592", size = 110613, upload-time = "2026-05-19T21:29:34.379Z" }, + { url = "https://files.pythonhosted.org/packages/df/88/09c28dad91e662ccfaa1b78f1c57badde74fc9d0b23e74aef644750ecd73/yarl-1.24.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:91e72cf093fd833483a97ee648e0c053c7c629f51ff4a0e7edd84f806b0c5617", size = 107012, upload-time = "2026-05-19T21:29:36.216Z" }, + { url = "https://files.pythonhosted.org/packages/07/ab/9d4f69d571a94f4d112fa7e2e007200f5a54d319f58c82ac7b7baa61f5c6/yarl-1.24.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b3177bc0a768ef3bacceb4f272632990b7bea352f1b2f1eee9d6d6ff16516f92", size = 105887, upload-time = "2026-05-19T21:29:38.746Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9a/000b2b66c0d772a499fc531d21dab92dfeb73b640a12eed6ba89f49bb2d0/yarl-1.24.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e196952aacaf3b232e265ff02980b64d483dc0972bd49bcb061171ff22ac203a", size = 103620, upload-time = "2026-05-19T21:29:40.368Z" }, + { url = "https://files.pythonhosted.org/packages/41/7c/7c1050f73450fbdaa3f0c72017059f00ce5e13366692f3dba25275a1083d/yarl-1.24.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:204e7a61ce99919c0de1bf904ab5d7aa188a129ea8f690a8f76cfb6e2844dc44", size = 100599, upload-time = "2026-05-19T21:29:42.66Z" }, + { url = "https://files.pythonhosted.org/packages/ec/b1/29e5756b3926705f5f6089bd5b9f50a56eaac550da6e260bf713ead44d04/yarl-1.24.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b156914620f0b9d78dc1adb3751141daee561cfec796088abb89ed49d220f1a", size = 110604, upload-time = "2026-05-19T21:29:44.632Z" }, + { url = "https://files.pythonhosted.org/packages/a3/4b/8415bc96e9b150cde942fbac9a8182985e58f40ce5c54c34ed015407d3ee/yarl-1.24.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8372a2b976cf70654b2be6619ab6068acabb35f724c0fda7b277fbf53d66a5cf", size = 105161, upload-time = "2026-05-19T21:29:46.755Z" }, + { url = "https://files.pythonhosted.org/packages/8b/d4/cde059abfa229553b7298a2eadde2752e723d50aeedaef86ce59da2718ee/yarl-1.24.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:f9a1e9b622ca284143aab5d885848686dcd85453bb1ca9abcdb7503e64dc0056", size = 110619, upload-time = "2026-05-19T21:29:48.972Z" }, + { url = "https://files.pythonhosted.org/packages/e7/2c/d6a6c9a61549f7b6c7e6dc6937d195bcf069582b47b7200dcd0e7b256acf/yarl-1.24.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:810e19b685c8c3c5862f6a38160a1f4e4c0916c9390024ec347b6157a45a0992", size = 107362, upload-time = "2026-05-19T21:29:51Z" }, + { url = "https://files.pythonhosted.org/packages/92/dd/3ae5fe417e9d1c353a548553326eb9935e76b6b727161563b424cc296df3/yarl-1.24.2-cp313-cp313-win_amd64.whl", hash = "sha256:7d37fb7c38f2b6edab0f845c4f85148d4c44204f52bc127021bd2bc9fdbf1656", size = 92667, upload-time = "2026-05-19T21:29:52.743Z" }, + { url = "https://files.pythonhosted.org/packages/10/cc/a7beb239f78f27fca1b053c8e8595e4179c02e62249b4687ec218c370c50/yarl-1.24.2-cp313-cp313-win_arm64.whl", hash = "sha256:1e831894be7c2954240e49791fa4b50c05a0dc881de2552cfe3ffd8631c7f461", size = 87069, upload-time = "2026-05-19T21:29:54.442Z" }, + { url = "https://files.pythonhosted.org/packages/40/0e/e08087695fc12789263821c5dc0f8dc52b5b17efd0887cacf419f8a43ba3/yarl-1.24.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:f9312b3c02d9b3d23840f67952913c9c8721d7f1b7db305289faefa878f364c2", size = 129670, upload-time = "2026-05-19T21:29:56.631Z" }, + { url = "https://files.pythonhosted.org/packages/3a/98/ab4b5ed1b1b5cd973c8a3eb994c3a6aefb6ce6d399e21bb5f0316c33815c/yarl-1.24.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a4f4d6cd615823bfc7fb7e9b5987c3f41666371d870d51058f77e2680fbe9630", size = 91916, upload-time = "2026-05-19T21:29:58.645Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b1/5297bb6a7df4782f7605bffc43b31f5044070935fbbcaa6c705a07e6ac65/yarl-1.24.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0c3063e5c0a8e8e62fae6c2596fa01da1561e4cd1da6fec5789f5cf99a8aefd8", size = 91625, upload-time = "2026-05-19T21:30:00.412Z" }, + { url = "https://files.pythonhosted.org/packages/02/a7/45baabfff76829264e623b185cff0c340d7e11bf3e1cd9ea37e7d17934bd/yarl-1.24.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fecd17873a096036c1c87ab3486f1aef7f269ada7f23f7f856f93b1cc7744f14", size = 104574, upload-time = "2026-05-19T21:30:02.544Z" }, + { url = "https://files.pythonhosted.org/packages/f3/40/3a5ab144d3d650ca37d4f4b57e56169be8af3ca34c448793e064b30baaed/yarl-1.24.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a46d1ab4ba4d32e6dc80daf8a28ce0bd83d08df52fbc32f3e288663427734535", size = 97534, upload-time = "2026-05-19T21:30:04.319Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b5/5658fef3681fb5776b4513b052bec750009f47b3a592251c705d75375798/yarl-1.24.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:73e68edf6dfd5f73f9ca127d84e2a6f9213c65bdffb736bda19524c0564fcd14", size = 111481, upload-time = "2026-05-19T21:30:05.988Z" }, + { url = "https://files.pythonhosted.org/packages/4c/06/fdcd7dde037f00866dce123ed4ba23dba94beb56fc4cf561668d27be37f2/yarl-1.24.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a296ca617f2d25fbceafb962b88750d627e5984e75732c712154d058ae8d79a3", size = 111529, upload-time = "2026-05-19T21:30:07.738Z" }, + { url = "https://files.pythonhosted.org/packages/c2/53/d81269aaafccea0d33396c03035de997b743f11e648e6e27a0df99c72980/yarl-1.24.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51b2cf5ec89a8b8470177641ed62a3ba22d74e1e898e06ad53aa77972487208", size = 107338, upload-time = "2026-05-19T21:30:09.713Z" }, + { url = "https://files.pythonhosted.org/packages/ae/04/23049463f729bd899df203a7960505a75333edd499cda8aa1d5a82b64df5/yarl-1.24.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:310fc687f7b2044ec54e372c8cbe923bb88f5c37bded0d3079e5791c2fc3cf50", size = 106147, upload-time = "2026-05-19T21:30:11.365Z" }, + { url = "https://files.pythonhosted.org/packages/14/18/04a4b5830b43ed5e4c5015b40e9f6241ad91487d71611061b4e111d6ac80/yarl-1.24.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:297a2fe352ecf858b30a98f87948746ec16f001d279f84aebdbd3bd965e2f1bd", size = 104272, upload-time = "2026-05-19T21:30:12.978Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f7/8cffdf319aee7a7c1dbd07b61d91c3e3fda460c7a93b5f93e445f3806c4c/yarl-1.24.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2a263e76b97bc42bdcd7c5f4953dec1f7cd62a1112fa7f869e57255229390d67", size = 99962, upload-time = "2026-05-19T21:30:15.001Z" }, + { url = "https://files.pythonhosted.org/packages/d7/39/b3cce3b7dbef64ac700ad4cea156a207d01bede0f507587616c364b5468e/yarl-1.24.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:822519b64cf0b474f1a0aaef1dc621438ea46bb77c94df97a5b4d213a7d8a8b1", size = 111063, upload-time = "2026-05-19T21:30:16.683Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ea/100818505e7ebf165c7242ff17fdf7d9fee79e27234aeca871c1082920d7/yarl-1.24.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b6067060d9dc594899ba83e6db6c48c68d1e494a6dab158156ed86977ca7bcb1", size = 105438, upload-time = "2026-05-19T21:30:18.769Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d2/e075a0b32aa6625087de9e653087df0759fed5de4a435fef594181102a77/yarl-1.24.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0063adad533e57171b79db3943b229d40dfafeeee579767f96541f106bac5f1b", size = 111458, upload-time = "2026-05-19T21:30:21.024Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5c/ceea7ba98b65c8eb8d947fdc52f9bedfcd43c6a57c9e3c90c17be8f324a3/yarl-1.24.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ee8e3fb34513e8dc082b586ef4910c98335d43a6fab688cd44d4851bacfce3e8", size = 107589, upload-time = "2026-05-19T21:30:23.412Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d9/5582d57e2b2db9b85eb6663a22efdd78e08805f3f5389566e9fcad254d1b/yarl-1.24.2-cp314-cp314-win_amd64.whl", hash = "sha256:afb00d7fd8e0f285ca29a44cc50df2d622ff2f7a6d933fa641577b5f9d5f3db0", size = 94424, upload-time = "2026-05-19T21:30:25.425Z" }, + { url = "https://files.pythonhosted.org/packages/92/10/7dc07a0e22806a9280f42a57361395506e800c64e22737cd7b0886feab42/yarl-1.24.2-cp314-cp314-win_arm64.whl", hash = "sha256:68cf6eacd6028ef1142bc4b48376b81566385ca6f9e7dde3b0fa91be08ffcb57", size = 88690, upload-time = "2026-05-19T21:30:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/9e/13/d5b8e2c8667db955bcb3de233f18798fefe7edf1d7429c2c9d4f9c401114/yarl-1.24.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:221ce1dd921ac4f603957f17d7c18c5cc0797fbb52f156941f92e04605d1d67b", size = 136248, upload-time = "2026-05-19T21:30:29.297Z" }, + { url = "https://files.pythonhosted.org/packages/de/46/a4a97c05c9c9b8fd266bb2a0df12992c7fbd02391eb9640583411b6dab32/yarl-1.24.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5f3224db28173a00d7afacdee07045cc4673dfab2b15492c7ae10deddbece761", size = 95084, upload-time = "2026-05-19T21:30:31.031Z" }, + { url = "https://files.pythonhosted.org/packages/95/b2/845cf2074a015e6fe0d0808cf1a2d9e868386c4220d657ebd8302b199043/yarl-1.24.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c557165320d6244ebe3a02431b2a201a20080e02f41f0cfa0ccc47a183765da8", size = 95272, upload-time = "2026-05-19T21:30:33.062Z" }, + { url = "https://files.pythonhosted.org/packages/fe/16/e69d4aa244aef45235ddfebc0e04036a6829842bc5a6a795aedc6c998d23/yarl-1.24.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:904065e6e85b1fa54d0d87438bd58c14c0bad97aad654ad1077fd9d87e8478ed", size = 101497, upload-time = "2026-05-19T21:30:34.842Z" }, + { url = "https://files.pythonhosted.org/packages/15/94/c07107715d621076863ee88b3ddf183fa5e9d4aba5769623c9979828410a/yarl-1.24.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8cec2a38d70edc10e0e856ceda886af5327a017ccbde8e1de1bd44d300357543", size = 94002, upload-time = "2026-05-19T21:30:37.724Z" }, + { url = "https://files.pythonhosted.org/packages/a9/35/fc1bbdd895b5e4010b8fdd037f7ed3aa289d3863e08231b30231ca9a0815/yarl-1.24.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e7484b9361ed222ee1ca5b4337aa4cbdcc4618ce5aff57d9ef1582fd95893fc0", size = 106524, upload-time = "2026-05-19T21:30:40.196Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/32b66d0a4ba47c296cf86d03e2c67bff58399fe6d6d84d5205c04c66cc6d/yarl-1.24.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:84f9670b89f34db07f81e53aee83e0b938a3412329d51c8f922488be7fcc4024", size = 106165, upload-time = "2026-05-19T21:30:41.888Z" }, + { url = "https://files.pythonhosted.org/packages/95/47/37cb5ff50c5e825d4d38e81bb04d1b7e96bf960f7ab89f9850b162f3f114/yarl-1.24.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:abb2759733d63a28b4956500a5dd57140f26486c92b2caedfb964ab7d9b79dbf", size = 103010, upload-time = "2026-05-19T21:30:43.985Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d2/4597912315096f7bb359e46e13bf8b60994fcbb2db29b804c0902ef4eff5/yarl-1.24.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:081c2bf54efe03774d0311172bc04fedf9ca01e644d4cd8c805688e527209bdc", size = 101128, upload-time = "2026-05-19T21:30:46.291Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d5/c8e86e120521e646013d02a8e3b8884392e28494be8f392366e50d208efc/yarl-1.24.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:86746bef442aa479107fe28132e1277237f9c24c2f00b0b0cf22b3ee0904f2bb", size = 101382, upload-time = "2026-05-19T21:30:48.085Z" }, + { url = "https://files.pythonhosted.org/packages/fa/98/70b229236118f89dbeb739b76f10225bbf53b5497725502594c9a01d699a/yarl-1.24.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:2d07d21d0bc4b17558e8de0b02fbfdf1e347d3bb3699edd00bb92e7c57925420", size = 95964, upload-time = "2026-05-19T21:30:49.785Z" }, + { url = "https://files.pythonhosted.org/packages/87/f8/56c386981e3c8648d279fdef2397ffec577e8320fd5649745e34d54faeb7/yarl-1.24.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:4fb1ac3fc5fecd8ae7453ea237e4d22b49befa70266dfe1629924245c21a0c7f", size = 106204, upload-time = "2026-05-19T21:30:51.862Z" }, + { url = "https://files.pythonhosted.org/packages/1a/1e/765afe97811ca35933e2a7de70ac57b1997ea2e4ee895719ee7a231fb7e5/yarl-1.24.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4da31a5512ed1729ca8d8aacde3f7faeb8843cde3165d6bcf7f88f74f17bb8aa", size = 101510, upload-time = "2026-05-19T21:30:53.62Z" }, + { url = "https://files.pythonhosted.org/packages/ee/78/393913f4b9039e1edd09ae8a9bbb9d539be909a8abf6d8a2084585bed4b7/yarl-1.24.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:533ded4dceb5f1f3da7906244f4e82cf46cfd40d84c69a1faf5ac506aa65ecbe", size = 105584, upload-time = "2026-05-19T21:30:55.962Z" }, + { url = "https://files.pythonhosted.org/packages/78/87/deb17b7049bbe74ea11a713b86f8f27800cc1c8648b0b797243ebb4830ba/yarl-1.24.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7b3a85525f6e7eeabcfdd372862b21ee1915db1b498a04e8bf0e389b607ff0bd", size = 103410, upload-time = "2026-05-19T21:30:57.962Z" }, + { url = "https://files.pythonhosted.org/packages/8f/be/f9f7594e23b5b93affff0318e4593c1920331bcaefda326cabcad94296a1/yarl-1.24.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a7624b1ca46ca5d7b864ef0d2f8efe3091454085ee1855b4e992314529972215", size = 102980, upload-time = "2026-05-19T21:30:59.735Z" }, + { url = "https://files.pythonhosted.org/packages/65/a4/ba80dccd3593ff1f01051a818694d07b58cb8232677ee9a22a5a1f93a9fc/yarl-1.24.2-cp314-cp314t-win_arm64.whl", hash = "sha256:e434a45ce2e7a947f951fc5a8944c8cc080b7e59f9c50ae80fd39107cf88126d", size = 91219, upload-time = "2026-05-19T21:31:01.934Z" }, + { url = "https://files.pythonhosted.org/packages/fd/4d/4b880086bd0d3e034d25647be1d830afc3e3f610e98c4ab3490af6b1b6d5/yarl-1.24.2-py3-none-any.whl", hash = "sha256:2783d9226db8797636cd6896e4de81feed252d1db72265686c9558d97a4d94b9", size = 53576, upload-time = "2026-05-19T21:31:03.909Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" }, +]