diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..58323d6 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,14 @@ +.git +.venv +*.sif +*.ipynb +__pycache__ +*.pyc +*.pyo +.pytest_cache +build +*.egg-info +.claude +config.yaml +docs/ +CLAUDE.md diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml new file mode 100644 index 0000000..e0617aa --- /dev/null +++ b/.gitea/workflows/ci.yml @@ -0,0 +1,80 @@ +name: CI + +on: + push: + pull_request: + +jobs: + lint: + name: lint:ruff + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v9.0.0 + with: + python-version: "3.11" + enable-cache: true + - run: uv sync --all-packages + - name: ruff check gallery + run: uv run ruff check gallery + - name: ruff check plotstyle + run: uv run ruff check plotstyle + - name: ruff check tests + run: uv run ruff check tests + + format: + name: format:ruff + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v9.0.0 + with: + python-version: "3.11" + enable-cache: true + - run: uv sync --all-packages + - name: ruff format check gallery + run: uv run ruff format --check gallery + - name: ruff format check plotstyle + run: uv run ruff format --check plotstyle + - name: ruff format check tests + run: uv run ruff format --check tests + + typecheck: + name: typecheck:ty + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v9.0.0 + with: + python-version: "3.11" + enable-cache: true + - run: uv sync --all-packages + - name: ty check gallery + run: uv run ty check gallery + - name: ty check plotstyle + run: uv run ty check plotstyle + + vulnerabilities: + name: vulnerabilities:pip-audit + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v9.0.0 + with: + python-version: "3.11" + enable-cache: true + - run: uv sync --all-packages + - run: uv run pip-audit --skip-editable + + test: + name: test:pytest + runs-on: ubuntu-latest + needs: [lint, format, typecheck, vulnerabilities] + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v9.0.0 + with: + python-version: "3.11" + enable-cache: true + - run: uv sync --all-packages + - run: uv run pytest tests/ -v diff --git a/.gitea/workflows/publish-plotstyle.yml b/.gitea/workflows/publish-plotstyle.yml new file mode 100644 index 0000000..5ec65c1 --- /dev/null +++ b/.gitea/workflows/publish-plotstyle.yml @@ -0,0 +1,39 @@ +name: Publish plotstyle + +on: + push: + tags: + - "plotstyle-v*" + +permissions: + contents: read + packages: write + +jobs: + publish: + name: build-and-publish + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: astral-sh/setup-uv@v9.0.0 + with: + python-version: "3.11" + + - name: Verify tag matches package version + run: | + tag_version="${GITHUB_REF_NAME#plotstyle-v}" + pkg_version="$(uv version --short --package plotstyle)" + if [ "$tag_version" != "$pkg_version" ]; then + echo "Tag plotstyle-v$tag_version does not match pyproject.toml version $pkg_version" >&2 + exit 1 + fi + + - name: Build wheel and sdist + run: uv build --package plotstyle -o dist + + - name: Publish to Gitea package registry + env: + UV_PUBLISH_USERNAME: ${{ github.actor }} + UV_PUBLISH_PASSWORD: ${{ secrets.GITHUB_TOKEN }} + run: uv publish --publish-url "${{ github.server_url }}/api/packages/${{ github.repository_owner }}/pypi" dist/* diff --git a/.gitignore b/.gitignore index f97a30b..dd01b73 100644 --- a/.gitignore +++ b/.gitignore @@ -2,9 +2,10 @@ .vscode *.sif *.ipynb +!examples/*.ipynb backups .pytest_cache .venv build *egg-info -.claude \ No newline at end of file +.claude diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml deleted file mode 100644 index 226c84c..0000000 --- a/.gitlab-ci.yml +++ /dev/null @@ -1,65 +0,0 @@ -# GitLab CI/CD Pipeline for Gallery Generator -# Builds Apptainer container and runs tests inside it - -stages: - - build - - test - -variables: - CONTAINER_IMAGE: "gallery-generator.sif" - APPTAINER_CACHE_DIR: "$CI_PROJECT_DIR/.apptainer-cache" - -# Cache to speed up builds -cache: - key: "$CI_COMMIT_REF_SLUG" - paths: - - .apptainer-cache/ - -# Build the Apptainer container -build:container: - stage: build - tags: - - apptainer - script: - - echo "Building Apptainer container..." - - apptainer --version - - apptainer build --fakeroot $CONTAINER_IMAGE Singularity.def - - ls -lh $CONTAINER_IMAGE - artifacts: - paths: - - $CONTAINER_IMAGE - expire_in: 1 hour - -# Run tests inside the container -test:pytest: - stage: test - tags: - - apptainer - dependencies: - - build:container - script: - - echo "Running pytest inside container..." - - apptainer exec $CONTAINER_IMAGE pytest /src/tests/ -v - artifacts: - when: always - -# Run tests with coverage -test:coverage: - stage: test - tags: - - apptainer - dependencies: - - build:container - script: - - echo "Running coverage analysis inside container..." - - apptainer exec $CONTAINER_IMAGE pytest /src/tests/ --cov=/src --cov-report=xml --cov-report=term - - apptainer exec $CONTAINER_IMAGE cat /src/coverage.xml > coverage.xml || echo "No coverage.xml found" - coverage: '/TOTAL.*\s+(\d+%)$/' - artifacts: - reports: - coverage_report: - coverage_format: cobertura - path: coverage.xml - paths: - - coverage.xml - expire_in: 30 days diff --git a/CLAUDE.md b/CLAUDE.md index 98db509..621ecc3 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -6,41 +6,55 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co A Python package that generates responsive static HTML galleries from scientific plot collections (PDFs and HTMLs). It converts PDFs to PNGs via ImageMagick, organizes plots hierarchically, propagates YAML/JSON metadata through directory trees, and renders everything via a Jinja2 template into a static website served from a web directory. +The repo also ships `plotstyle`, a standalone matplotlib styling toolkit (KIT corporate-design theme + building-block functions) for producing the PDF figures that feed into a `gallery` source directory. `gallery` never imports it — the only connection is the PDF files and `metadata.yaml` on disk. **See `plotstyle/CLAUDE.md` for full agent-facing usage docs, the API reference, and the metadata.yaml workflow.** + +This repo is a **uv workspace** (root `pyproject.toml` has `[tool.uv.workspace] members = ["plotstyle"]`) and both projects build with uv's own `uv_build` backend — there is no setuptools anywhere in this repo. Use `uv`/`uv run` for everything; don't reach for `pip install` here. + ## Commands ```bash -# Install the package (editable) -pip install -e ".[dev]" +# Install everything (gallery + plotstyle + dev tools) into the shared workspace venv +uv sync --all-packages # Run all tests -pytest tests/ +uv run pytest tests/ # Run a single test file -pytest tests/test_generate_gallery.py -v +uv run pytest tests/test_generate_gallery.py -v +uv run pytest tests/test_plotstyle.py -v # Run a single test by name -pytest tests/test_generate_gallery.py::test_needs_update_missing_target -v +uv run pytest tests/test_generate_gallery.py::test_needs_update_missing_target -v # Generate gallery -gallery generate --verbose +uv run gallery generate --verbose # Generate with a non-default config -gallery --config config.yaml generate --verbose +uv run gallery --config config.yaml generate --verbose # Incremental update for one source only -gallery generate --source /path/to/plots --verbose +uv run gallery generate --source /path/to/plots --verbose # Clean regeneration -gallery generate --clean --verbose +uv run gallery generate --clean --verbose # Launch TUI -gallery tui +uv run gallery tui # Serve output locally python -m http.server 8000 -d /web/kschmidt/public_html/ ``` -Code style: black with `line-length = 120`. +Code style: ruff (lint + format), `line-length = 120`. Type-checked with `ty`. + +```bash +uv run ruff check gallery plotstyle tests +uv run ruff format gallery plotstyle tests +uv run ty check gallery plotstyle +uv run pip-audit --skip-editable +``` + +**Before committing**, run the same checks CI (`.gitea/workflows/ci.yml`) runs and make sure they pass — `ruff check`, `ruff format --check`, `ty check`, `pip-audit`, and `pytest tests/`. Catching a failure locally is faster than waiting on the pipeline. ## Architecture @@ -75,6 +89,9 @@ generate() [api.py] | `gallery/assets/js/` | Vanilla JS modules loaded as ES modules; `GalleryApp` in `gallery-app.js` orchestrates all managers | | `gallery/assets/css/` | Modular CSS; `main.css` imports all others via `@import` | | `config.yaml` | Local deployment config (paths are machine-specific) | +| `plotstyle/` | Standalone matplotlib styling toolkit for producing plots (see `plotstyle/CLAUDE.md`) — not imported by `gallery/`; a separate uv workspace member with its own `pyproject.toml`, code under `plotstyle/src/plotstyle/` (src layout) | +| `.gitea/workflows/publish-plotstyle.yml` | Builds and publishes `plotstyle` to the Gitea package registry on `plotstyle-v*` tags | +| `examples/plotstyle_showcase.ipynb` | Rendered, runnable tour of every `plotstyle` function | ### Config File Format @@ -104,10 +121,20 @@ When `source_to_update` is passed to `generate()`, only that source's subdirecto `metadata.yaml` (or `.yml`/`.json`) in any source directory is loaded and **merged with parent metadata** (`inherit_from_parent=True` by default). Child directories override parent keys. Per-plot overrides can live in `.yaml` files alongside the plot. +Fields are freeform YAML (no fixed schema); `title`, `description`, `plot_type`, `experiment` get prominent placement in the per-plot metadata popup, everything else still displays under "Additional Information". Text values support inline LaTeX rendered via MathJax client-side. + +### Plot-Producing Companion (`plotstyle`) + +`plotstyle` (a separate uv workspace member, see below) is how plots destined for a `gallery` source directory should be produced — a KIT corporate-design matplotlib theme plus building blocks (`new_figure`, `colorbar`, `style_legend`, `panel_label`, `savefig`). It has no code dependency on `gallery`; the two only meet on disk, via the PDFs and `metadata.yaml` files a `plotstyle` script writes into a `gallery` source directory. **Full usage docs, API reference, best practices, and the metadata.yaml workflow live in `plotstyle/CLAUDE.md`** — read that file before writing or reviewing any script that `import plotstyle`. `examples/plotstyle_showcase.ipynb` is a rendered, runnable tour of every function. + +`plotstyle` has its own `plotstyle/pyproject.toml` (own `uv_build` project, code lives in `plotstyle/src/plotstyle/`) and is a member of this repo's uv workspace (`[tool.uv.workspace] members = ["plotstyle"]` in the root `pyproject.toml`) — `uv sync --all-packages` installs both `gallery` and `plotstyle` (and matplotlib) into one shared venv, which is why `import plotstyle` works from `tests/` and the example notebook without `gallery` ever depending on it. It's also independently publishable: pushing a tag matching `plotstyle-v*` (e.g. `plotstyle-v0.1.0`) runs `.gitea/workflows/publish-plotstyle.yml`, which runs `uv build --package plotstyle` and `uv publish` to this repo's Gitea package registry (`{server}/api/packages/{owner}/pypi`) using the workflow's auto-generated token. The tag's version suffix must match `plotstyle/pyproject.toml`'s `version` field or the workflow fails fast — bump that version before tagging a new release. + ### Frontend (Static JS/CSS) The frontend is vanilla ES modules — no build step. `assets/js/main.js` imports `GalleryApp` from `gallery-app.js`, which instantiates all manager classes (`ThemeManager`, `SearchManager`, `NavigationManager`, etc.). Each manager is self-contained. The template embeds gallery data as JSON in the page; JS reads it at runtime. ### Deployment -The project ships a `Singularity.def` / `web.sif` Apptainer container for HPC environments. CI (`.gitlab-ci.yml`) builds the container and runs pytest inside it. For local development the `.venv` is sufficient. +The project ships a `Dockerfile` plus `docker-compose.yml` (a `generator` service that runs `gallery generate` on an interval, and an `nginx`-based `web` service serving the output — see `deploy/entrypoint.sh` and `deploy/nginx.conf`). This suits a dedicated VM/server you fully control. The `Dockerfile` is a two-stage build: a builder stage copies in the official `ghcr.io/astral-sh/uv` binary and runs `uv build --package gallery` to produce a wheel, then the final stage `pip install`s just that wheel (no dev deps, no workspace/lockfile needed at runtime). CI (`.gitea/workflows/ci.yml`, run via Gitea Actions) uses `astral-sh/setup-uv` + `uv sync --all-packages` and runs every check (`ruff check`, `ruff format --check`, `ty check`, `pip-audit`, `pytest`) via `uv run` — no plain `pip`/`actions/setup-python` anywhere in CI. For local development, `uv sync --all-packages` is all you need. + +On shared HPC login nodes without a Docker daemon (e.g. KIT ETP, where `public_html` is already auto-served) use a plain venv install plus a `systemd --user` timer instead — see `deploy/systemd/README.md`. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..3cca6ef --- /dev/null +++ b/Dockerfile @@ -0,0 +1,30 @@ +FROM python:3.11-slim AS builder + +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /usr/local/bin/ + +WORKDIR /app + +COPY pyproject.toml uv.lock README.md ./ +COPY plotstyle/pyproject.toml plotstyle/README.md plotstyle/ +COPY gallery/ gallery/ + +RUN uv build --package gallery -o dist + +FROM python:3.11-slim + +RUN apt-get update \ + && apt-get install -y --no-install-recommends imagemagick \ + && rm -rf /var/lib/apt/lists/* + +WORKDIR /app + +COPY --from=builder /app/dist/*.whl /tmp/ +COPY deploy/entrypoint.sh deploy/entrypoint.sh + +RUN pip install --no-cache-dir /tmp/*.whl && rm /tmp/*.whl + +RUN useradd -r -s /bin/false gallery +USER gallery + +ENTRYPOINT ["gallery"] +CMD ["generate"] diff --git a/README.md b/README.md index de6198e..7b6952e 100644 --- a/README.md +++ b/README.md @@ -31,15 +31,19 @@ - TUI: `gallery tui` - Config file stored under user `$HOME/.config/gallery` +### Producing Plots (`plotstyle`) + +- Companion matplotlib styling toolkit (optional `plotting` extra) for producing figures that look consistent across a thesis and slide deck, ready to drop straight into a gallery source directory — see [Producing Plots with `plotstyle`](#producing-plots-with-plotstyle) + ## Installation -### From GitLab +### From Gitea Pip install: ```bash -pip install git+https://gitlab.etp.kit.edu/kschmidt/web +pip install git+https://git.larsbogner.de/lars/ETPlot ``` Or git clone and `pip install .`. After installation the `gallery` command is available in your shell. Verify with: @@ -54,6 +58,20 @@ gallery --help - Python packages are installed automatically by pip (Jinja2, PyYAML, PyMuPDF, Textual, argcomplete, platformdirs) - [ImageMagick](https://imagemagick.org/) is **optional** — used as a fallback if `PyMuPDF` is not available +### Optional: `plotstyle` (for producing plots) + +`plotstyle` is a separate package (its own `plotstyle/pyproject.toml`, a member of this repo's uv workspace) — installing `gallery` alone never pulls in `matplotlib`. + +```bash +# Working in this repo (installs gallery + plotstyle + matplotlib together): +uv sync --all-packages + +# Just the plotstyle library, standalone: +pip install "plotstyle @ git+https://git.larsbogner.de/lars/ETPlot#subdirectory=plotstyle" +``` + +`plotstyle` also requires a local LaTeX toolchain (`latex` + `dvipng`) to be installed separately; see [Producing Plots with `plotstyle`](#producing-plots-with-plotstyle). + ### Shell Completion (optional) Install tab-completion for bash/zsh/fish: @@ -170,7 +188,6 @@ paths: gallery: plot_root: "gallery" # subdirectory inside web_folder png_dpi: 400 # thumbnail resolution - backup_folder: "" # optional backup path sources: - name: "analysis_results" @@ -215,6 +232,37 @@ LaTeX formulas are supported in metadata values and rendered with MathJax: formula: "$$E = mc^2$$" ``` +## Producing Plots with `plotstyle` + +`plotstyle` is a companion matplotlib styling toolkit shipped in this repo (the `plotstyle/` package) for producing the plots you'll point a gallery source at — a KIT (Karlsruhe Institute of Technology) corporate-design color palette, consistent spines/ticks/gridlines, LaTeX text in a modern sans font, and a few building-block functions (figure titles with a parameters subtitle, a same-size colorbar helper, an outside-axes legend, panel labels). It has no code dependency on `gallery` — the two only meet on disk, through the PDF files (and optional `metadata.yaml`) a `plotstyle` script writes into a directory that `gallery` then scans. + +Install it with the `plotting` extra (see [Installation](#installation)) and make sure a LaTeX toolchain (`latex` + `dvipng`) is available locally — `plotstyle` always renders text through real LaTeX, there's no fallback. + +```python +import numpy as np +import plotstyle as ps + +ps.use() # once, before creating any figure + +fig, ax = ps.new_figure( + "thesis-single", + title="Measured signal", + params={"N": 512, "seed": 42}, +) +x = np.linspace(0, 10, 200) +ax.plot(x, np.sin(x), label="signal") +ax.set_xlabel("Time (s)") +ax.set_ylabel(r"Amplitude $A(t)$") +ps.style_legend(ax, title="Series") + +# Save straight into a gallery source directory: +ps.savefig(fig, "/path/to/plots/measured_signal", formats=("pdf",)) +``` + +That PDF (plus an optional `metadata.yaml` next to it, as described above) is exactly what `gallery generate --source /path/to/plots` picks up — `gallery` converts the PDF to a thumbnail PNG itself, so `plotstyle` scripts should stick to `formats=("pdf",)` rather than also producing a PNG. + +See `examples/plotstyle_showcase.ipynb` for a fully rendered tour of every function, and `plotstyle/CLAUDE.md` for the full API reference and best practices (aimed at coding agents, but equally useful for humans). + ## Shortcuts | Icon | Button | Function | Shortcut | diff --git a/Singularity.def b/Singularity.def deleted file mode 100644 index b914821..0000000 --- a/Singularity.def +++ /dev/null @@ -1,20 +0,0 @@ -Bootstrap: docker -From: python:3.11-slim - -%post - apt-get update - apt-get install -y --no-install-recommends imagemagick - rm -rf /var/lib/apt/lists/* - - pip install --no-cache-dir jinja2 pyyaml coverage pytest pytest-cov - mkdir -p /src - -%files - . /src - -%environment - export PYTHONPATH=/src - -%runscript - cd /src - exec python3 generate_gallery.py "$@" diff --git a/config.lbogner.yaml b/config.lbogner.yaml new file mode 100644 index 0000000..52243b3 --- /dev/null +++ b/config.lbogner.yaml @@ -0,0 +1,36 @@ +# Gallery Configuration for lbogner (KIT ETP HPC login nodes) +# ============================================================== +# Deployed via plain venv + systemd --user timer (see deploy/systemd/README.md), +# not Docker/Compose — this path has no Docker daemon, and /web/lbogner/public_html +# is already served by KIT's own web infrastructure. + +paths: + # Working directory where the script runs from + work_dir: "/work/lbogner/web" + + # Web hosting directory where gallery files are served (auto-served by KIT) + web_folder: "/web/lbogner/public_html/" + +gallery: + plot_root: "gallery" + png_dpi: 400 + +ui: + max_recent_plots: 20 + search_debounce_ms: 300 + +metadata: + cache_enabled: true + inherit_from_parent: true + +# Data Sources +# TODO: fill in your actual plot-producing repo output directories under +# /work/lbogner/... and/or plot data under /ceph/... (adjust names/paths to match +# where each cloned repo's plotstyle scripts actually write their PDFs). +sources: + - name: "ttbar_analysis" + path: "/work/lbogner/PLACEHOLDER/ttbar_analysis/plots" + - name: "needle_benchmarks" + path: "/work/lbogner/PLACEHOLDER/needle/benchmarks/plots" + - name: "aido_convergence_study" + path: "/work/lbogner/PLACEHOLDER/aido/results_convergence/plots" diff --git a/config.yaml b/config.yaml index 451d8c6..cd990fd 100644 --- a/config.yaml +++ b/config.yaml @@ -5,7 +5,7 @@ paths: # Working directory where the script runs from work_dir: "/work/kschmidt/web" - + # Web hosting directory where gallery files are served web_folder: "/web/kschmidt/public_html/" @@ -13,18 +13,15 @@ paths: gallery: # Root folder name for plots in web directory plot_root: "gallery" - + # PNG conversion quality png_dpi: 400 - - # Backup folder (leave empty to disable) - backup_folder: "" # UI Settings ui: # Maximum number of recent plots to track max_recent_plots: 20 - + # Search settings search_debounce_ms: 300 @@ -32,13 +29,13 @@ ui: metadata: # Enable metadata caching cache_enabled: true - + # Inherit metadata from parent folders inherit_from_parent: true # Data Sources # Each source represents a collection of plots to include in the gallery -sources: +sources: - name: "ttbar_analysis" path: "/work/kschmidt/NEEDLE/test_analysis/data/cf_store/test_analysis/cf.PlotVariables1D/run2_2016_nano_v9/" - name: "needle_benchmarks" diff --git a/deploy/entrypoint.sh b/deploy/entrypoint.sh new file mode 100755 index 0000000..0fdc5a7 --- /dev/null +++ b/deploy/entrypoint.sh @@ -0,0 +1,26 @@ +#!/bin/sh +set -e + +CONFIG_FILE="${CONFIG_FILE:-/config/config.yaml}" +GENERATE_INTERVAL="${GENERATE_INTERVAL:-300}" # seconds between regenerations; 0 = run once and exit + +if [ ! -f "$CONFIG_FILE" ]; then + echo "ERROR: config file not found at $CONFIG_FILE" >&2 + exit 1 +fi + +run_generate() { + echo "[$(date -u +%FT%TZ)] Running gallery generate..." + gallery --config "$CONFIG_FILE" generate --verbose +} + +run_generate + +if [ "$GENERATE_INTERVAL" -eq 0 ]; then + exit 0 +fi + +while true; do + sleep "$GENERATE_INTERVAL" + run_generate +done diff --git a/deploy/nginx.conf b/deploy/nginx.conf new file mode 100644 index 0000000..4548a33 --- /dev/null +++ b/deploy/nginx.conf @@ -0,0 +1,40 @@ +server { + listen 80; + server_name _; + + root /var/www/gallery; + index index.html; + + # Security headers + add_header X-Content-Type-Options "nosniff" always; + add_header X-Frame-Options "SAMEORIGIN" always; + add_header X-XSS-Protection "1; mode=block" always; + add_header Referrer-Policy "strict-origin-when-cross-origin" always; + + # Gzip + gzip on; + gzip_vary on; + gzip_types text/plain text/css application/javascript application/json image/svg+xml; + gzip_min_length 1024; + + # Static assets: cache aggressively + location ~* \.(css|js|png|jpg|jpeg|gif|ico|svg|woff2?)$ { + expires 7d; + add_header Cache-Control "public, immutable"; + } + + # HTML: no cache so regenerated galleries are picked up immediately + location ~* \.html$ { + expires -1; + add_header Cache-Control "no-store"; + } + + location / { + try_files $uri $uri/ $uri/index.html =404; + } + + # Deny access to hidden files + location ~ /\. { + deny all; + } +} diff --git a/deploy/systemd/README.md b/deploy/systemd/README.md new file mode 100644 index 0000000..24029e8 --- /dev/null +++ b/deploy/systemd/README.md @@ -0,0 +1,62 @@ +# Deploying on a KIT HPC login node (no Docker daemon) + +This path is for machines like the ETP login nodes: `/ceph`, `/work`, `/web` are +mounted directly, but there's no Docker daemon available, and your `public_html` +is already served by KIT's own web infrastructure — so no web server needs to +run here at all, only the generator on a schedule. + +## 1. Install into a venv + +```bash +python3 -m venv ~/.venvs/gallery +~/.venvs/gallery/bin/pip install -e /work/lbogner/ETPlot # path to your clone +``` + +PyMuPDF (a base dependency) handles PDF→PNG conversion; ImageMagick is not required. + +## 2. Point a config at your paths + +Copy/edit `config.lbogner.yaml` from the repo root (already has `web_folder: +/web/lbogner/public_html/` and placeholder `sources:` — fill in the real +plot-output directories under `/work/lbogner/...` or `/ceph/...`). Put it +wherever you like, e.g. `~/gallery/config.lbogner.yaml`, and adjust the path in +`gallery-generate.service` if you move it. + +## 3. Install the systemd --user timer + +```bash +mkdir -p ~/.config/systemd/user +cp deploy/systemd/gallery-generate.{service,timer} ~/.config/systemd/user/ +systemctl --user daemon-reload +systemctl --user enable --now gallery-generate.timer +``` + +Check status/logs: + +```bash +systemctl --user list-timers gallery-generate.timer +journalctl --user -u gallery-generate.service -f +``` + +By default a user's systemd instance (and its timers) stops when you log out. +Enable lingering so it keeps running: + +```bash +loginctl enable-linger $USER +``` + +If lingering isn't permitted on your login node, or `systemctl --user` isn't +usable there at all, fall back to a crontab entry instead: + +``` +*/5 * * * * ~/.venvs/gallery/bin/gallery --config ~/gallery/config.lbogner.yaml generate >> ~/gallery-generate.log 2>&1 +``` + +## Why not the Docker Compose stack? + +`docker-compose.yml` at the repo root (generator + nginx) is for a scenario +where you control a dedicated VM/server and need to serve the output yourself. +On the ETP login nodes there's no Docker daemon (Apptainer/Singularity only), +and `public_html` is already auto-served — running your own nginx there would +be redundant. It remains a fine option for anyone deploying this on their own +server. diff --git a/deploy/systemd/gallery-generate.service b/deploy/systemd/gallery-generate.service new file mode 100644 index 0000000..c0cf6df --- /dev/null +++ b/deploy/systemd/gallery-generate.service @@ -0,0 +1,7 @@ +[Unit] +Description=Generate ETPlot gallery +Wants=network-online.target + +[Service] +Type=oneshot +ExecStart=%h/.venvs/gallery/bin/gallery --config %h/gallery/config.lbogner.yaml generate --verbose diff --git a/deploy/systemd/gallery-generate.timer b/deploy/systemd/gallery-generate.timer new file mode 100644 index 0000000..3165e4a --- /dev/null +++ b/deploy/systemd/gallery-generate.timer @@ -0,0 +1,10 @@ +[Unit] +Description=Periodically regenerate the ETPlot gallery + +[Timer] +OnBootSec=2min +OnUnitActiveSec=5min +Persistent=true + +[Install] +WantedBy=timers.target diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..2b40e7f --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,42 @@ +services: + generator: + build: . + image: etplot-gallery:latest + entrypoint: ["/app/deploy/entrypoint.sh"] + environment: + CONFIG_FILE: /config/config.yaml + # How often to regenerate the gallery (seconds). Set to 0 to run once and exit. + GENERATE_INTERVAL: "300" + volumes: + - ./config.yaml:/config/config.yaml:ro + # Mount your plot source directories here, matching the paths in config.yaml. + # Example: + # - /path/to/plots:/plots:ro + - gallery_output:/var/www/gallery + restart: unless-stopped + healthcheck: + test: ["CMD", "gallery", "--help"] + interval: 60s + timeout: 10s + retries: 3 + start_period: 30s + + web: + image: nginx:1.27-alpine + ports: + - "${HTTP_PORT:-8080}:80" + volumes: + - ./deploy/nginx.conf:/etc/nginx/conf.d/default.conf:ro + - gallery_output:/var/www/gallery:ro + depends_on: + - generator + restart: unless-stopped + healthcheck: + test: ["CMD", "wget", "-qO-", "http://localhost/"] + interval: 30s + timeout: 5s + retries: 3 + start_period: 10s + +volumes: + gallery_output: diff --git a/docs/COVERAGE_TESTING.md b/docs/COVERAGE_TESTING.md deleted file mode 100644 index e834301..0000000 --- a/docs/COVERAGE_TESTING.md +++ /dev/null @@ -1,275 +0,0 @@ -# Automated Coverage Testing Documentation - -## Overview - -This repository now includes automated code coverage testing using the `coverage.py` package. Coverage testing helps ensure that your tests adequately exercise your codebase and identifies untested code paths. - -## 🚀 Quick Start - -### Container-based Coverage (Recommended) -```bash -# Build and test with coverage in container -./tests/test_container.sh - -# Or run coverage directly in container -apptainer exec gallery-generator.sif python3 /src/tests/run_coverage.py -``` - -### Local Coverage Testing -```bash -# Run coverage tests locally -./tests/run_coverage_local.sh - -# Or manually -pip install coverage -coverage run -m unittest tests.test_container -coverage report -coverage html -``` - -## 📁 Coverage Files - -### Core Coverage Files -- **`.coveragerc`** - Coverage configuration file -- **`tests/run_coverage.py`** - Automated coverage script for containers -- **`tests/run_coverage_local.sh`** - Local coverage testing script - -### Generated Reports -- **`coverage.xml`** - XML format for CI/CD integration -- **`coverage_html_report/`** - Interactive HTML reports -- **`.coverage`** - Coverage data file - -## 🔧 Configuration - -### Coverage Settings (`.coveragerc`) -```ini -[run] -source = . -omit = - tests/* # Exclude test files - __pycache__/* # Exclude cache - assets/* # Exclude static assets - docs/* # Exclude documentation - templates/* # Exclude templates - -[report] -precision = 2 # 2 decimal places -show_missing = True # Show missing line numbers -skip_covered = False # Show all files - -[html] -directory = coverage_html_report -title = Gallery Generator Coverage Report -``` - -### Singularity Container Integration -The coverage package is automatically installed in the container: -```bash -pip install --no-cache-dir jinja2 pyyaml coverage -``` - -## 📊 Coverage Reports - -### Console Report -Shows coverage percentage and missing lines: -``` -Name Stmts Miss Cover Missing ------------------------------------------------------ -generate_gallery.py 190 45 76.32% 156-167, 234-245 -orchestration/config.py 45 8 82.22% 78-82 -orchestration/logger.py 67 12 82.09% 45-48, 89-94 ------------------------------------------------------ -TOTAL 302 65 78.48% -``` - -### HTML Report -Interactive report with: -- Line-by-line coverage highlighting -- Branch coverage details -- Sortable file listings -- Coverage trends - -### XML Report -Machine-readable format for CI/CD: -- GitLab CI coverage visualization -- External tool integration -- Coverage badges - -## 🎯 Coverage Targets - -### Current Thresholds -- **Minimum Target**: 80% overall coverage -- **Warning Level**: Below 70% coverage -- **Exclusions**: Test files, static assets, documentation - -### Best Practices -- **Focus on Core Logic**: Prioritize business logic coverage -- **Test Edge Cases**: Include error handling and boundary conditions -- **Regular Monitoring**: Run coverage with every commit -- **Incremental Improvement**: Gradually increase coverage over time - -## 🔄 CI/CD Integration - -### GitLab CI Pipeline -The coverage testing is integrated into the GitLab CI pipeline: - -```yaml -test:coverage: - stage: test - script: - - apptainer exec $CONTAINER_IMAGE python3 /src/tests/run_coverage.py - coverage: '/TOTAL.+?(\d+\.\d+)%/' - artifacts: - reports: - coverage_report: - coverage_format: cobertura - path: coverage.xml -``` - -### Features -- **Automatic Reports**: Coverage reports in merge requests -- **Badge Integration**: Coverage badges in README -- **Trend Tracking**: Historical coverage data -- **Failure Thresholds**: Fail builds below minimum coverage - -## 🛠️ Advanced Usage - -### Custom Coverage Runs -```bash -# Test specific modules -coverage run --source=orchestration -m unittest tests.test_metadata - -# Include/exclude patterns -coverage run --omit="*/tests/*" -m unittest discover - -# Branch coverage (more detailed) -coverage run --branch -m unittest tests.test_container -``` - -### Coverage Analysis -```bash -# Show missing lines -coverage report --show-missing - -# Generate detailed HTML -coverage html --show-contexts - -# Export data -coverage json -coverage xml -``` - -### Integration with IDEs -- **VS Code**: Coverage Gutters extension -- **PyCharm**: Built-in coverage runner -- **Vim**: Coverage highlighting plugins - -## 📈 Coverage Metrics - -### What Coverage Measures -- **Statement Coverage**: Lines of code executed -- **Branch Coverage**: Decision paths taken -- **Function Coverage**: Functions called -- **Class Coverage**: Classes instantiated - -### What Coverage Doesn't Measure -- **Code Quality**: Coverage ≠ good tests -- **Logic Correctness**: 100% coverage ≠ bug-free -- **Performance**: Execution speed not measured -- **Security**: Vulnerabilities not detected - -## 🧪 Testing Strategy - -### Container Test Suite Coverage -Current test files and their focus: - -#### `tests/test_container.py` -- **Environment validation** - Container setup -- **Utility functions** - Helper functions -- **Metadata system** - YAML processing -- **PDF processing** - ImageMagick integration -- **Gallery generation** - End-to-end workflow - -#### `tests/test_build_container.py` -- **Container building** - Singularity build process -- **Dependency validation** - Package installation -- **Application functionality** - Script execution - -### Coverage Gaps Analysis -Use `tests/test_coverage.py` to analyze: -- Missing function coverage -- Untested code paths -- Critical functionality gaps -- Integration test needs - -## 🚨 Troubleshooting - -### Common Issues - -#### No Coverage Data -```bash -# Ensure coverage is running tests -coverage run --debug=trace -m unittest tests.test_container -``` - -#### Import Errors -```bash -# Check PYTHONPATH -export PYTHONPATH=/src:$PYTHONPATH -``` - -#### Permission Issues -```bash -# Container write permissions -apptainer exec --writable-tmpfs container.sif python3 tests/run_coverage.py -``` - -### Debug Commands -```bash -# Check coverage configuration -coverage debug config - -# Verify data collection -coverage debug data - -# Test discovery -coverage debug sys -``` - -## 📚 References - -- **Coverage.py Documentation**: https://coverage.readthedocs.io/ -- **GitLab CI Coverage**: https://docs.gitlab.com/ee/ci/testing/code_coverage.html -- **Testing Best Practices**: Python Testing 101 -- **Container Testing**: Singularity/Apptainer Documentation - -## 🔄 Maintenance - -### Regular Tasks -- **Weekly**: Review coverage reports -- **Monthly**: Update coverage targets -- **Release**: Ensure minimum coverage met -- **Quarterly**: Review exclusion patterns - -### Cleanup -```bash -# Remove coverage files -./tests/cleanup.sh - -# Manual cleanup -rm -f .coverage coverage.xml -rm -rf coverage_html_report/ -``` - -### Updates -```bash -# Update coverage package -pip install --upgrade coverage - -# Update container -apptainer build --force container.sif Singularity.def -``` - ---- - -*This automated coverage system provides comprehensive testing insights while maintaining the containerized, dependency-free approach of the gallery generator project.* diff --git a/docs/SORT_IMPLEMENTATION.md b/docs/SORT_IMPLEMENTATION.md deleted file mode 100644 index b0dae4a..0000000 --- a/docs/SORT_IMPLEMENTATION.md +++ /dev/null @@ -1,136 +0,0 @@ -# Gallery Sort Functionality Implementation Guide - -## Overview -This guide explains how to integrate the new sorting functionality that allows users to sort plots by name and creation time. - -## Frontend Implementation (Complete ✅) - -The frontend implementation is complete and includes: - -### 1. Sort Controls UI -- **Name/Time buttons**: Toggle between sorting by filename and creation time -- **Order button**: Toggle between ascending (↑) and descending (↓) order -- **Positioned**: Left side of the controls container, next to view toggle buttons -- **Responsive**: Adapts to mobile layouts - -### 2. Keyboard Shortcuts -- `Ctrl+N`: Sort by name -- `Ctrl+M`: Sort by time (modification/creation time) -- `Ctrl+O`: Toggle sort order (ascending/descending) - -### 3. Persistence -- Sort preferences are saved to localStorage -- Settings persist across page reloads and navigation - -### 4. Tile Sizing -- Grid view now shows ~6 plots per row on desktop (240px minimum width) -- Responsive design maintains usability on mobile devices - -## Backend Integration (Required) - -To enable time-based sorting, you need to modify your Python gallery generation code: - -### 1. Add Creation Time to Plot Items - -```python -from pathlib import Path - -def add_creation_time_to_items(items, base_path): - """Add creation time to plot items for sorting functionality.""" - for item in items: - try: - # Get creation time from PNG or PDF file - png_path = None - pdf_path = None - - if 'png_href' in item: - png_rel_path = item['png_href'].replace('../', '').replace('./', '') - png_path = Path(base_path) / png_rel_path - - if 'pdf_href' in item: - pdf_rel_path = item['pdf_href'].replace('../', '').replace('./', '') - pdf_path = Path(base_path) / pdf_rel_path - - # Use PNG creation time if available, otherwise PDF - creation_time = 0 - if png_path and png_path.exists(): - creation_time = int(png_path.stat().st_ctime) - elif pdf_path and pdf_path.exists(): - creation_time = int(pdf_path.stat().st_ctime) - - item['creation_time'] = creation_time - - except Exception as e: - print(f"Warning: Could not get creation time for {item.get('name', 'unknown')}: {e}") - item['creation_time'] = 0 - - return items -``` - -### 2. Integrate into Your Gallery Generation - -In your existing gallery generation code, call this function before rendering the template: - -```python -# Your existing code that creates the items list -items = generate_plot_items() # Your existing function - -# Add creation times -items = add_creation_time_to_items(items, gallery_base_path) - -# Pass to template -template.render(items=items, ...) -``` - -### 3. Template Data Structure - -The template now expects each item to have a `creation_time` field: - -```python -item = { - 'name': 'plot_name.png', - 'png_href': './plot_name.png', - 'pdf_href': './plot_name.pdf', - 'creation_time': 1642723200 # Unix timestamp -} -``` - -## File Locations - -### Frontend Files (Ready to use) -- `templates/gallery.html` - Updated with sort controls and data attributes -- `assets/css/view-controls.css` - Styling for sort and view controls -- `assets/css/view-override.css` - Grid layout with larger tiles -- `assets/js/sort-manager.js` - Sort functionality implementation -- `assets/js/gallery-app.js` - Integration of SortManager -- `assets/js/keyboard-manager.js` - Keyboard shortcuts for sorting - -### Backend Integration -- `python/add_creation_time.py` - Example implementation for adding creation times - -## Features Summary - -### ✅ Completed Features -1. **Larger Grid Tiles**: ~6 plots per row instead of 8 -2. **Sort Controls**: Name and time sorting with visual feedback -3. **Sort Order Toggle**: Ascending/descending with visual indicator -4. **Keyboard Shortcuts**: Quick access to all sort functions -5. **Persistence**: Settings saved across sessions -6. **Responsive Design**: Works on all screen sizes -7. **Template Integration**: Data attributes ready for backend - -### 🔄 Next Steps (Backend Integration) -1. Modify your Python gallery generation code to include `creation_time` -2. Use the provided `add_creation_time_to_items()` function -3. Test with real plot files to ensure timestamps are correct - -## Testing - -After backend integration: -1. Navigate to a gallery with multiple plots -2. Click the sort buttons to verify functionality -3. Use keyboard shortcuts to test responsiveness -4. Check that sort order toggles correctly -5. Verify settings persist after page reload - -The frontend is fully functional and will work immediately once the backend provides the `creation_time` data. diff --git a/examples/plotstyle_showcase.ipynb b/examples/plotstyle_showcase.ipynb new file mode 100644 index 0000000..ddab55c --- /dev/null +++ b/examples/plotstyle_showcase.ipynb @@ -0,0 +1,658 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4e9fb3ed", + "metadata": {}, + "source": [ + "# `plotstyle` showcase\n", + "\n", + "A tour of the reusable matplotlib building blocks in `plotstyle` — a KIT\n", + "(Karlsruhe Institute of Technology) corporate-design color palette plus a\n", + "handful of small helpers (`new_figure`, `colorbar`, `savefig`,\n", + "`style_legend`, `panel_label`) so every figure produced for a thesis chapter\n", + "or a talk slide looks consistent.\n", + "\n", + "Install the extra once: `pip install -e \".[plotting]\"` (or `uv sync --extra plotting`).\n", + "This notebook requires a working local LaTeX (`latex` + `dvipng`) install —\n", + "`plotstyle` always renders text through real TeX, no mathtext fallback.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9c81491e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:29.369269Z", + "iopub.status.busy": "2026-07-22T12:40:29.369083Z", + "iopub.status.idle": "2026-07-22T12:40:29.757832Z", + "shell.execute_reply": "2026-07-22T12:40:29.757066Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LaTeX text rendering enabled: True\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import plotstyle as ps\n", + "\n", + "ps.use()\n", + "print(\"LaTeX text rendering enabled:\", plt.rcParams[\"text.usetex\"])\n" + ] + }, + { + "cell_type": "markdown", + "id": "9f004413", + "metadata": {}, + "source": [ + "`use()` also sets up the plot chrome applied by every figure below: only the\n", + "bottom spine is kept (left/top/right removed), tick marks stay on the left\n", + "and bottom axes, the x-axis gets shorter minor ticks between the major ones\n", + "(the y-axis doesn't — its major gridlines already mark position), gridlines\n", + "are light-grey and horizontal only, major tick labels are darker than minor\n", + "ones, and titles (figure and axes alike) are left-aligned rather than\n", + "centered — all visible in the line plot in section 2. All text, including\n", + "tick numerals, renders through real LaTeX in Latin Modern Sans (via the\n", + "`sfmath` package and `fontenc`'s T1 encoding, so math-mode numbers stay sans\n", + "instead of falling back to a serif math font, and plain characters like \"|\"\n", + "render correctly).\n", + "\n", + "**Titling convention used throughout this notebook:** prefer\n", + "`new_figure(title=..., params=...)` (section 3) for a single axes; reserve\n", + "plain `ax.set_title()` for per-panel titles in multi-axes figures (section 8)\n", + "where there's no single title that could cover every panel.\n" + ] + }, + { + "cell_type": "markdown", + "id": "b20c3f51", + "metadata": {}, + "source": [ + "## 1. The categorical palette\n", + "\n", + "Nine fixed-order, colorblind-safe-where-possible hues via\n", + "`plotstyle.colors.CATEGORICAL` / `get_color(i)` — KIT green, orange, KIT\n", + "blue, brown, cyan, purple, pea green, red, and yellow (in that order, chosen\n", + "to keep adjacent hues distinguishable). The order never changes; a 10th\n", + "series should fold into \"Other\" or move to a facet rather than cycling back\n", + "to slot 0. KIT yellow reads poorly on a white surface — pair it with a\n", + "direct label rather than relying on the fill alone.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5146dcca", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:29.759851Z", + "iopub.status.busy": "2026-07-22T12:40:29.759611Z", + "iopub.status.idle": "2026-07-22T12:40:30.131619Z", + "shell.execute_reply": "2026-07-22T12:40:30.130873Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['#009682', '#DF9B1B', '#4664AA', '#A78230', '#23A1E0', '#A3107C', '#8CB63C', '#A22223', '#FCE500']\n" + ] + } + ], + "source": [ + "fig, ax = ps.new_figure(\"thesis-wide\", title=\"Categorical palette (fixed order)\")\n", + "ax.grid(False)\n", + "for i, hex_color in enumerate(ps.colors.CATEGORICAL):\n", + " ax.bar(i, 1, color=hex_color, width=0.8)\n", + "ax.set_xticks(range(len(ps.colors.CATEGORICAL)))\n", + "ax.set_xticklabels([f\"slot {i}\" for i in range(len(ps.colors.CATEGORICAL))])\n", + "ax.set_yticks([])\n", + "ax.set_ylim(0, 1.1)\n", + "ax.spines[\"left\"].set_visible(False)\n", + "plt.show()\n", + "\n", + "print(list(ps.colors.CATEGORICAL))\n" + ] + }, + { + "cell_type": "markdown", + "id": "f524b9a2", + "metadata": {}, + "source": [ + "## 2. Line plots: color, and optionally linestyle\n", + "\n", + "By default `axes.prop_cycle` only varies color — every line solid — so the\n", + "brand colors read cleanly without extra visual noise.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a4edc295", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:30.134787Z", + "iopub.status.busy": "2026-07-22T12:40:30.134429Z", + "iopub.status.idle": "2026-07-22T12:40:30.316449Z", + "shell.execute_reply": "2026-07-22T12:40:30.315034Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = ps.new_figure(\n", + " \"thesis-single\",\n", + " title=\"Default: no linestyle cycling\",\n", + " params={\"cycle_linestyles\": False},\n", + ")\n", + "x = np.linspace(0, 10, 200)\n", + "for i in range(5):\n", + " ax.plot(x, np.sin(x - i * 0.4) * (i + 1), label=f\"series {i}\")\n", + "ax.set_xlabel(\"Time (s)\")\n", + "ax.set_ylabel(r\"Amplitude $A(t)$\")\n", + "ps.style_legend(ax, title=\"Series\")\n", + "ps.panel_label(ax, \"a\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "c8f33d18", + "metadata": {}, + "source": [ + "Pass `cycle_linestyles=True` to `use()` to also vary linestyle — useful when\n", + "a figure might be printed or projected in grayscale, or viewed by someone\n", + "with color-vision deficiency, so series stay distinguishable without color.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "59d68b50", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:30.318967Z", + "iopub.status.busy": "2026-07-22T12:40:30.318798Z", + "iopub.status.idle": "2026-07-22T12:40:30.511821Z", + "shell.execute_reply": "2026-07-22T12:40:30.510506Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ps.use(cycle_linestyles=True)\n", + "\n", + "fig, ax = ps.new_figure(\n", + " \"thesis-single\",\n", + " title=\"Opt-in: linestyle cycling\",\n", + " params={\"cycle_linestyles\": True},\n", + ")\n", + "for i in range(5):\n", + " ax.plot(x, np.sin(x - i * 0.4) * (i + 1), label=f\"series {i}\")\n", + "ax.set_xlabel(\"Time (s)\")\n", + "ax.set_ylabel(r\"Amplitude $A(t)$\")\n", + "ps.style_legend(ax, title=\"Series\")\n", + "ps.panel_label(ax, \"a\")\n", + "plt.show()\n", + "\n", + "ps.use() # back to the no-cycle default for the rest of this notebook\n" + ] + }, + { + "cell_type": "markdown", + "id": "22ecdcf9", + "metadata": {}, + "source": [ + "## 3. Figure titles and parameter subtitles\n", + "\n", + "`new_figure(title=..., params=...)` sets a left-aligned, bold figure-level\n", + "title — preferred over an axes title even for a single axes, so single- and\n", + "multi-panel figures stay consistent. `params` is a dict rendered as a\n", + "smaller subtitle line: `key1: value1 | key2: value2 | ...` — handy for\n", + "recording the run parameters that produced a plot, as seen in the two line\n", + "plots above.\n", + "\n", + "This is the recommended way to title a single-axes figure — every example in\n", + "this notebook uses it instead of `ax.set_title()`. The exception is\n", + "multi-axes figures, where each panel needs its own title; section 8 uses\n", + "plain `ax.set_title()` per subplot for exactly that reason.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dc8f77ea", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:30.514127Z", + "iopub.status.busy": "2026-07-22T12:40:30.513894Z", + "iopub.status.idle": "2026-07-22T12:40:30.657177Z", + "shell.execute_reply": "2026-07-22T12:40:30.656188Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = ps.new_figure(\n", + " \"thesis-single\",\n", + " title=\"Measured signal\",\n", + " params={\"N\": 512, \"sigma\": 1.2, \"seed\": 42},\n", + ")\n", + "ax.plot(x, np.sin(x))\n", + "ax.set_xlabel(\"Time (s)\")\n", + "ax.set_ylabel(r\"Amplitude $A(t)$\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "a8e9bbe1", + "metadata": {}, + "source": [ + "## 4. Figure size presets\n", + "\n", + "`new_figure(preset=...)` ships named sizes (inches) tuned for thesis print and\n", + "slide decks. Pass an explicit `(w, h)` tuple to bypass the presets entirely.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2edb0c4c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:30.658897Z", + "iopub.status.busy": "2026-07-22T12:40:30.658728Z", + "iopub.status.idle": "2026-07-22T12:40:30.711393Z", + "shell.execute_reply": "2026-07-22T12:40:30.710597Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = ps.new_figure((6, 4), title=\"plotstyle.FIGSIZES presets (drawn to scale)\")\n", + "colors_iter = iter(ps.colors.CATEGORICAL)\n", + "y = 0.0\n", + "for name, (w, h) in ps.FIGSIZES.items():\n", + " color = next(colors_iter)\n", + " ax.add_patch(plt.Rectangle((0, y), w, h, fill=False, edgecolor=color, linewidth=2))\n", + " ax.text(w + 0.15, y + h / 2, f\"{name} {w}\\u00d7{h} in\", va=\"center\", fontsize=10, color=color)\n", + " y += h + 0.5\n", + "ax.set_xlim(0, 14)\n", + "ax.set_ylim(0, y)\n", + "ax.set_aspect(\"equal\")\n", + "ax.axis(\"off\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "1d390e31", + "metadata": {}, + "source": [ + "## 5. Sequential colormap — magnitude\n", + "\n", + "One hue, light → dark: `colors.sequential_cmap()` is a KIT-blue ramp\n", + "(brand blue at full value, tinting lighter toward zero) for continuous\n", + "magnitude data (heatmaps, density fields).\n", + "\n", + "`ps.colorbar(im, ax)` is used here instead of `fig.colorbar(im, ax=ax)` —\n", + "with `ax.set_aspect(\"equal\")` on a non-square array, the default colorbar\n", + "sizes itself to the axes' nominal box and ends up taller than what's\n", + "actually drawn; `ps.colorbar` appends a same-size axes via\n", + "`make_axes_locatable` so it always matches.\n", + "\n", + "`ps.no_spines(ax)` turns off all four spines — the themed bottom spine\n", + "(see `use()`) implies an x baseline that doesn't mean anything for\n", + "pixel/bin-indexed data like this.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "74a67468", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:30.713724Z", + "iopub.status.busy": "2026-07-22T12:40:30.713553Z", + "iopub.status.idle": "2026-07-22T12:40:30.869396Z", + "shell.execute_reply": "2026-07-22T12:40:30.868495Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = ps.new_figure(\"square\", title=\"Sequential colormap (KIT blue)\")\n", + "X, Y = np.meshgrid(np.linspace(-3, 3, 60), np.linspace(-3, 3, 90))\n", + "Z = np.exp(-(X**2 + Y**2))\n", + "im = ax.pcolormesh(X, Y, Z, cmap=ps.colors.sequential_cmap(), shading=\"auto\")\n", + "ps.no_spines(ax)\n", + "ps.colorbar(im, ax, label=\"Density\")\n", + "ax.set_aspect(\"equal\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "13388fdd", + "metadata": {}, + "source": [ + "## 6. Diverging colormap — polarity\n", + "\n", + "KIT blue ↔ KIT red with a neutral gray midpoint: `colors.diverging_cmap()`\n", + "for signed data such as a correlation matrix, always centered on the data's\n", + "true zero (`vmin`/`vmax` symmetric around it). Another `ps.no_spines(ax)`\n", + "call here for the same reason as section 5 — a correlation matrix has no\n", + "meaningful axis baseline either.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bcd8ec15", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:30.871197Z", + "iopub.status.busy": "2026-07-22T12:40:30.871032Z", + "iopub.status.idle": "2026-07-22T12:40:31.057109Z", + "shell.execute_reply": "2026-07-22T12:40:31.056321Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rng = np.random.default_rng(0)\n", + "data = rng.normal(size=(6, 200))\n", + "corr = np.corrcoef(data)\n", + "\n", + "fig, ax = ps.new_figure(\"square\", title=\"Diverging colormap (KIT blue / KIT red)\")\n", + "im = ax.imshow(corr, cmap=ps.colors.diverging_cmap(), vmin=-1, vmax=1)\n", + "ps.no_spines(ax)\n", + "ps.colorbar(im, ax, label=\"Correlation\")\n", + "ax.set_xticks(range(6))\n", + "ax.set_yticks(range(6))\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "d0fa0677", + "metadata": {}, + "source": [ + "## 7. Status colors\n", + "\n", + "A small, fixed, *reserved* scale (good / warning / serious / critical) —\n", + "never reused for \"series 4\", and always paired with a label rather than\n", + "color alone.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "37d1b539", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:31.058905Z", + "iopub.status.busy": "2026-07-22T12:40:31.058635Z", + "iopub.status.idle": "2026-07-22T12:40:31.180725Z", + "shell.execute_reply": "2026-07-22T12:40:31.179970Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = ps.new_figure(\"thesis-single\", title=\"Status colors (reserved, always labeled)\")\n", + "labels = list(ps.colors.STATUS.keys())\n", + "values = [92, 74, 45, 12]\n", + "bars = ax.barh(labels, values, color=[ps.colors.STATUS[k] for k in labels])\n", + "for bar, value in zip(bars, values):\n", + " ax.text(value + 1.5, bar.get_y() + bar.get_height() / 2, str(value), va=\"center\", fontsize=10)\n", + "ax.set_xlim(0, 108)\n", + "ax.set_xlabel(\"Checks passing (score out of 100)\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "8a96d616", + "metadata": {}, + "source": [ + "## 8. Multi-panel figures with panel labels\n", + "\n", + "`panel_label()` adds the `(a)`/`(b)`/… labels expected in multi-panel thesis\n", + "and paper figures, combining several of the building blocks above. By\n", + "default it sits in the bottom-right corner, colored to match the axes'\n", + "xlabel, on a light-grey semi-transparent rounded box with a slim solid\n", + "border — pass `box=False` for bare text instead. The figure-level\n", + "`title`/`params` from section 3 still set the figure's overall title — but\n", + "now each panel also gets its own plain `ax.set_title()`, since no single\n", + "title could describe all four at once. This is the one place in this\n", + "notebook where `ax.set_title()` is the right call.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "55084ae6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:31.182935Z", + "iopub.status.busy": "2026-07-22T12:40:31.182749Z", + "iopub.status.idle": "2026-07-22T12:40:31.651425Z", + "shell.execute_reply": "2026-07-22T12:40:31.650568Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = ps.new_figure(\n", + " \"thesis-wide\",\n", + " nrows=2,\n", + " ncols=2,\n", + " title=\"A multi-panel figure built from plotstyle building blocks\",\n", + " params={\"seed\": 0},\n", + ")\n", + "\n", + "axes[0, 0].plot(x, np.sin(x), label=\"sin\")\n", + "axes[0, 0].plot(x, np.cos(x), label=\"cos\")\n", + "axes[0, 0].set_title(\"Trigonometric\")\n", + "ps.style_legend(axes[0, 0], title=\"Function\")\n", + "ps.panel_label(axes[0, 0], \"a\")\n", + "\n", + "axes[0, 1].hist(rng.normal(size=1000), bins=30, color=ps.get_color(2))\n", + "axes[0, 1].set_title(\"Histogram\")\n", + "ps.panel_label(axes[0, 1], \"b\")\n", + "\n", + "axes[1, 0].pcolormesh(X, Y, Z, cmap=ps.colors.sequential_cmap(), shading=\"auto\")\n", + "axes[1, 0].set_title(\"Sequential\")\n", + "ps.no_spines(axes[1, 0])\n", + "ps.panel_label(axes[1, 0], \"c\")\n", + "\n", + "axes[1, 1].imshow(corr, cmap=ps.colors.diverging_cmap(), vmin=-1, vmax=1)\n", + "axes[1, 1].set_title(\"Diverging\")\n", + "ps.no_spines(axes[1, 1])\n", + "ps.panel_label(axes[1, 1], \"d\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "4dbdac0a", + "metadata": {}, + "source": [ + "## 9. Saving figures\n", + "\n", + "`savefig()` creates parent directories and writes one file per format — PDF\n", + "by default, which slots straight into ETPlot's own gallery pipeline\n", + "(PDF \\u2192 PNG) with no extra conversion step.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "52f994d6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-22T12:40:31.652959Z", + "iopub.status.busy": "2026-07-22T12:40:31.652808Z", + "iopub.status.idle": "2026-07-22T12:40:33.380105Z", + "shell.execute_reply": "2026-07-22T12:40:33.378530Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PosixPath('output/multi_panel_demo.pdf'), PosixPath('output/multi_panel_demo.png')]\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "written = ps.savefig(fig, Path(\"output\") / \"multi_panel_demo\", formats=(\"pdf\", \"png\"))\n", + "print(written)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5a51f67a", + "metadata": {}, + "source": [ + "## Recap\n", + "\n", + "That's the full building-block set: `use()`, `new_figure()` (with `title`,\n", + "`params`, and size presets), `colorbar()`, `colors` (categorical / sequential\n", + "/ diverging / status), `style_legend()`, `panel_label()`, and `savefig()`.\n", + "Call `ps.use()` once at the top of a plot-producing script and every figure\n", + "inherits the same validated, modern look — in a thesis chapter or on a\n", + "slide. For titles specifically: default to `new_figure(title=..., params=...)`;\n", + "only reach for `ax.set_title()` when a figure has multiple axes and each one\n", + "needs its own title.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.14.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/gallery/__init__.py b/gallery/__init__.py index 3db6a1e..16d45ad 100644 --- a/gallery/__init__.py +++ b/gallery/__init__.py @@ -21,17 +21,23 @@ Example usage: __version__ = "0.1.0" __author__ = "K. Schmidt" +from gallery.api import generate +from gallery.builder import build_gallery, get_template from gallery.config import ( GalleryConfig, - GallerySource, GalleryDefaults, + GallerySource, ) -from gallery.api import generate - -# Export utility functions for testing and advanced usage -from gallery.utils.stats import ( - calculate_directory_stats, - format_file_size, +from gallery.utils.datetime_utils import ( + datetime_from_timestamp, + strftime_filter, +) +from gallery.utils.metadata import ( + load_folder_metadata, + load_metadata_file, + merge_metadata, + resolve_metadata_for_plot, + save_metadata_cache, ) from gallery.utils.processing import ( convert_pdf_to_png, @@ -39,18 +45,12 @@ from gallery.utils.processing import ( process_plot_files, render_gallery_page, ) -from gallery.utils.metadata import ( - load_folder_metadata, - merge_metadata, - save_metadata_cache, - load_metadata_file, - resolve_metadata_for_plot, + +# Export utility functions for testing and advanced usage +from gallery.utils.stats import ( + calculate_directory_stats, + format_file_size, ) -from gallery.utils.datetime_utils import ( - datetime_from_timestamp, - strftime_filter, -) -from gallery.builder import build_gallery, get_template __all__ = [ "generate", @@ -74,4 +74,3 @@ __all__ = [ "datetime_from_timestamp", "strftime_filter", ] - diff --git a/gallery/api.py b/gallery/api.py index 33e9b9e..7d3199a 100644 --- a/gallery/api.py +++ b/gallery/api.py @@ -6,19 +6,19 @@ Provides the primary entry point for programmatic gallery generation. import shutil from pathlib import Path -from typing import Union, List, Dict, Any +from typing import Any, Dict, List, Optional, Union, cast +from gallery.builder import build_gallery, copy_assets, get_template from gallery.config import GalleryConfig, GallerySource -from gallery.builder import get_template, build_gallery, copy_assets def generate( - config: Union[GalleryConfig, str, Path] = None, - web_folder: Union[str, Path] = None, - sources: List[Union[GallerySource, Dict[str, Any]]] = None, + config: Optional[Union[GalleryConfig, str, Path]] = None, + web_folder: Optional[Union[str, Path]] = None, + sources: Optional[List[Union[GallerySource, Dict[str, Any]]]] = None, clean_first: bool = False, verbose: bool = False, - source_to_update: GallerySource = None, + source_to_update: Optional[GallerySource] = None, ) -> bool: """ Generate a scientific gallery from plot sources. @@ -79,20 +79,11 @@ def generate( if isinstance(config, (str, Path)): config = GalleryConfig.from_yaml(config) elif not isinstance(config, GalleryConfig): - raise TypeError( - f"config must be GalleryConfig, str, or Path, " - f"got {type(config)}" - ) + raise TypeError(f"config must be GalleryConfig, str, or Path, got {type(config)}") else: if web_folder is None or sources is None: - raise ValueError( - "Either config or both web_folder and sources " - "must be provided" - ) - config = GalleryConfig( - web_folder=web_folder, - sources=sources or [] - ) + raise ValueError("Either config or both web_folder and sources must be provided") + config = GalleryConfig(web_folder=web_folder, sources=sources or []) # Validate configuration if not config.sources: @@ -104,10 +95,7 @@ def generate( web_folder_path = Path(config.web_folder) if not _is_writable(web_folder_path): if verbose: - print( - f"Error: Cannot write to web_folder: " - f"{config.web_folder}" - ) + print(f"Error: Cannot write to web_folder: {config.web_folder}") return False # Create gallery root directory @@ -127,17 +115,12 @@ def generate( source_subdir = gallery_root / source_to_update.name if source_subdir.exists(): if verbose: - print( - f"Updating source directory {source_to_update.name}..." - ) + print(f"Updating source directory {source_to_update.name}...") try: shutil.rmtree(source_subdir) except Exception as e: if verbose: - print( - f"Warning: Could not clean source subdirectory " - f"{source_subdir}: {e}" - ) + print(f"Warning: Could not clean source subdirectory {source_subdir}: {e}") return False try: @@ -162,8 +145,10 @@ def generate( return False # Process sources + # config.sources is always List[GallerySource] after GalleryConfig.__post_init__ normalizes it. source_subdirs = [] for source in config.sources: + source = cast(GallerySource, source) # Skip sources not matching the update target (if specified) if source_to_update and source.name != source_to_update.name: # Still include them in the index if they exist @@ -178,10 +163,7 @@ def generate( # Validate source exists if not source_path.exists(): if verbose: - print( - f"Warning: Source {source.path} does not exist. " - f"Skipping." - ) + print(f"Warning: Source {source.path} does not exist. Skipping.") continue source_web_dir = gallery_root / source.name @@ -189,47 +171,37 @@ def generate( source_web_dir.mkdir(parents=True, exist_ok=True) except Exception as e: if verbose: - print( - f"Warning: Could not create directory " - f"{source_web_dir}: {e}" - ) + print(f"Warning: Could not create directory {source_web_dir}: {e}") continue source_subdirs.append(source.name) # Process source - if source_path.is_file() and source_path.suffix == '.pdf': + if source_path.is_file() and source_path.suffix == ".pdf": # Single PDF file from gallery.utils.processing import process_plot_files + item = process_plot_files( config=config, plot_file=source_path, web_dir=source_web_dir, ) from gallery.utils.processing import render_gallery_page + render_gallery_page( config=config, template=template, web_dir=source_web_dir, items=[item], subdirs=[], - relative_path=Path(source.name) + relative_path=Path(source.name), ) elif source_path.is_dir(): # Directory of plots - build_gallery( - config, - source_path, - source_web_dir, - template, - Path(source.name) - ) + build_gallery(config, source_path, source_web_dir, template, Path(source.name)) else: if verbose: - print( - f"Warning: Source {source.path} is neither a " - f"directory nor a PDF file. Skipping." - ) + print(f"Warning: Source {source.path} is neither a directory nor a PDF file. Skipping.") continue if verbose: @@ -237,15 +209,13 @@ def generate( except Exception as e: if verbose: - print( - f"Warning: Error processing source " - f"{source.name}: {e}" - ) + print(f"Warning: Error processing source {source.name}: {e}") continue # Render gallery root index try: from gallery.utils.processing import render_gallery_page + render_gallery_page( config=config, template=template, @@ -253,7 +223,7 @@ def generate( items=[], subdirs=source_subdirs, relative_path=Path("."), - title="Gallery Root" + title="Gallery Root", ) except Exception as e: if verbose: @@ -277,8 +247,8 @@ def generate( def _count_gallery_plots(gallery_root: Path) -> int: """Recursively count plot files (PDFs and HTMLs, excluding index.html) in the gallery output.""" count = 0 - for f in gallery_root.rglob('*'): - if f.is_file() and f.suffix.lower() in ('.pdf', '.html') and f.name != 'index.html': + for f in gallery_root.rglob("*"): + if f.is_file() and f.suffix.lower() in (".pdf", ".html") and f.name != "index.html": count += 1 return count diff --git a/gallery/assets/css/export.css b/gallery/assets/css/export.css deleted file mode 100644 index 84d7b5f..0000000 --- a/gallery/assets/css/export.css +++ /dev/null @@ -1,440 +0,0 @@ -/* ======================================== - EXPORT FUNCTIONALITY STYLES - ======================================== */ - -/* Selection mode styles */ -.selection-mode .grid-item { - cursor: pointer; - transition: all 0.2s ease; -} - -.selection-mode .grid-item:hover { - transform: scale(1.02); - box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); -} - -/* Selection overlay */ -.selection-overlay { - position: absolute; - top: 0; - left: 0; - right: 0; - bottom: 0; - background: rgba(0, 0, 0, 0.3); - display: none; - justify-content: center; - align-items: center; - border-radius: 8px; - z-index: 5; -} - -.selection-mode .selection-overlay { - display: flex; -} - -.selection-checkbox { - background: var(--card-background); - border: 2px solid var(--border-color); - border-radius: 50%; - width: 32px; - height: 32px; - display: flex; - align-items: center; - justify-content: center; - font-size: 18px; - transition: all 0.2s ease; -} - -.grid-item.selected .selection-checkbox { - background: var(--primary-color, #007bff); - border-color: var(--primary-color, #007bff); - color: white; -} - -.checkbox-icon { - line-height: 1; -} - -/* Selection counter */ -.selection-counter { - position: fixed; - bottom: 100px; - right: 20px; - background: var(--card-background); - border: 1px solid var(--border-color); - border-radius: 20px; - padding: 8px 16px; - font-size: 14px; - font-weight: 500; - color: var(--text-color); - box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); - z-index: 999; -} - -/* Export button styles */ -.export-btn { - background: #28a745 !important; -} - -.export-btn:hover { - background: #218838 !important; -} - -.export-btn:disabled { - background: #6c757d !important; - cursor: not-allowed; -} - -/* Export messages */ -.export-message { - position: fixed; - top: 20px; - right: 20px; - padding: 12px 24px; - border-radius: 6px; - font-weight: 500; - z-index: 1001; - box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); - animation: slideIn 0.3s ease; -} - -.export-message-info { - background: #d1ecf1; - color: #0c5460; - border: 1px solid #bee5eb; -} - -.export-message-success { - background: #d4edda; - color: #155724; - border: 1px solid #c3e6cb; -} - -.export-message-warning { - background: #fff3cd; - color: #856404; - border: 1px solid #ffeaa7; -} - -.export-message-error { - background: #f8d7da; - color: #721c24; - border: 1px solid #f5c6cb; -} - -@keyframes slideIn { - from { - transform: translateX(100%); - opacity: 0; - } - to { - transform: translateX(0); - opacity: 1; - } -} - -/* Selection mode indicator */ -.selection-mode::before { - content: "Selection Mode - Click plots to select them"; - position: fixed; - top: 0; - left: 0; - right: 0; - background: var(--primary-color, #007bff); - color: white; - text-align: center; - padding: 8px; - font-size: 14px; - font-weight: 500; - z-index: 1000; -} - -/* Adjust main content when in selection mode */ -.selection-mode { - padding-top: 40px; -} - -/* Export instructions overlay */ -.export-overlay { - position: fixed; - top: 0; - left: 0; - right: 0; - bottom: 0; - background: rgba(0, 0, 0, 0.5); - display: flex; - align-items: center; - justify-content: center; - z-index: 1002; -} - -.export-instructions { - background: var(--card-background); - border: 1px solid var(--border-color); - border-radius: 8px; - padding: 24px; - max-width: 600px; - max-height: 80vh; - overflow-y: auto; - box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3); -} - -.export-instructions h3 { - margin: 0 0 16px 0; - color: var(--text-color); -} - -.export-instructions p { - margin: 0 0 16px 0; - color: var(--text-color); -} - -.export-data { - margin: 16px 0; -} - -.export-data textarea { - width: 100%; - height: 200px; - font-family: 'Courier New', monospace; - font-size: 12px; - border: 1px solid var(--border-color); - border-radius: 4px; - padding: 8px; - background: var(--background-color); - color: var(--text-color); - resize: vertical; -} - -.export-commands { - margin: 16px 0; - padding: 12px; - background: var(--header-background); - border-radius: 4px; - border: 1px solid var(--border-color); -} - -.export-command-container { - margin: 20px 0; - border: 1px solid var(--border-color); - border-radius: 8px; - overflow: hidden; -} - -.export-command { - background: var(--header-background); - padding: 16px; - border-bottom: 1px solid var(--border-color); -} - -.export-command code { - font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; - font-size: 13px; - line-height: 1.4; - color: var(--text-color); - word-break: break-all; - display: block; - background: none; - border: none; - padding: 0; - margin: 0; -} - -.export-actions { - display: flex; - gap: 8px; - padding: 12px 16px; - background: var(--card-background); -} - -.export-actions button { - padding: 8px 16px; - border: 1px solid var(--border-color); - border-radius: 4px; - background: var(--card-background); - color: var(--text-color); - cursor: pointer; - transition: all 0.2s ease; -} - -.export-actions button:hover { - background: var(--header-background); -} - -.export-actions button:last-child { - background: var(--primary-color, #007bff); - color: white; - border-color: var(--primary-color, #007bff); -} - -.export-actions button:last-child:hover { - background: var(--primary-color-dark, #0056b3); -} - -.copy-btn, .close-btn { - padding: 8px 16px; - border: 1px solid var(--border-color); - border-radius: 6px; - background: var(--card-background); - color: var(--text-color); - cursor: pointer; - transition: all 0.2s ease; - font-size: 14px; - display: flex; - align-items: center; - gap: 4px; -} - -.copy-btn:hover { - background: var(--primary-color, #007bff); - color: white; - border-color: var(--primary-color, #007bff); -} - -.close-btn { - background: #dc3545; - color: white; - border-color: #dc3545; - margin-left: auto; -} - -.close-btn:hover { - background: #c82333; - border-color: #bd2130; -} - -.export-details, .export-tips { - margin: 20px 0; - padding: 16px; - border-radius: 6px; - border: 1px solid var(--border-color); -} - -.export-details { - background: var(--header-background); -} - -.export-tips { - background: var(--card-background); - border-color: var(--primary-color, #007bff); - border-left: 4px solid var(--primary-color, #007bff); -} - -.export-details h4, .export-tips h4 { - margin: 0 0 12px 0; - color: var(--text-color); - font-size: 16px; -} - -.export-details ul, .export-tips ul { - margin: 0; - padding-left: 20px; - color: var(--text-color); -} - -.export-details li, .export-tips li { - margin: 8px 0; - line-height: 1.5; -} - -.export-details code, .export-tips code { - background: var(--background-color); - padding: 2px 6px; - border-radius: 3px; - font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; - font-size: 12px; - border: 1px solid var(--border-color); -} - -.export-tips kbd { - background: var(--header-background); - border: 1px solid var(--border-color); - border-radius: 3px; - padding: 2px 6px; - font-family: inherit; - font-size: 12px; - box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1); -} - -.copy-feedback { - position: absolute; - top: 10px; - right: 10px; - padding: 8px 12px; - border-radius: 4px; - font-size: 12px; - font-weight: 500; - z-index: 1003; - animation: fadeInOut 2s ease-in-out; -} - -.copy-feedback-success { - background: #d4edda; - color: #155724; - border: 1px solid #c3e6cb; -} - -.copy-feedback-error { - background: #f8d7da; - color: #721c24; - border: 1px solid #f5c6cb; -} - -@keyframes fadeInOut { - 0% { opacity: 0; transform: translateY(-10px); } - 20% { opacity: 1; transform: translateY(0); } - 80% { opacity: 1; transform: translateY(0); } - 100% { opacity: 0; transform: translateY(-10px); } -} - -/* Dark theme adjustments */ -[data-theme="dark"] .selection-checkbox { - background: var(--card-background); - border-color: var(--border-color); -} - -[data-theme="dark"] .grid-item.selected .selection-checkbox { - background: var(--primary-color, #0d6efd); - border-color: var(--primary-color, #0d6efd); -} - -[data-theme="dark"] .export-message-info { - background: #0c5460; - color: #d1ecf1; - border-color: #086972; -} - -[data-theme="dark"] .export-message-success { - background: #155724; - color: #d4edda; - border-color: #1e7e34; -} - -[data-theme="dark"] .export-message-warning { - background: #856404; - color: #fff3cd; - border-color: #b58b14; -} - -[data-theme="dark"] .export-message-error { - background: #721c24; - color: #f8d7da; - border-color: #a94442; -} - -[data-theme="dark"] .copy-feedback-success { - background: #155724; - color: #d4edda; - border-color: #1e7e34; -} - -[data-theme="dark"] .copy-feedback-error { - background: #721c24; - color: #f8d7da; - border-color: #a94442; -} - -[data-theme="dark"] .export-tips kbd { - background: var(--background-color); - color: var(--text-color); -} diff --git a/gallery/assets/css/main.css b/gallery/assets/css/main.css index c6019d7..b9dfb44 100644 --- a/gallery/assets/css/main.css +++ b/gallery/assets/css/main.css @@ -18,7 +18,6 @@ @import url('./metadata.css'); @import url('./metadata-section.css'); @import url('./folder-metadata.css'); -@import url('./export.css'); /* View controls - must come after grid.css to override */ @import url('./view-controls.css'); diff --git a/gallery/assets/css/sort-debug.css b/gallery/assets/css/sort-debug.css deleted file mode 100644 index e69de29..0000000 diff --git a/gallery/assets/js/export-manager.js b/gallery/assets/js/export-manager.js deleted file mode 100644 index ab221c3..0000000 --- a/gallery/assets/js/export-manager.js +++ /dev/null @@ -1,444 +0,0 @@ -/** - * Export Manager for Gallery - * Handles exporting selected plots to merged PDF - */ - -export class ExportManager { - constructor() { - this.selectedPlots = new Set(); - this.maxPlots = 4; - this.init(); - } - - init() { - this.createExportButton(); - this.bindEvents(); - } - - /** - * Create the export button in the floating buttons section - */ - createExportButton() { - const floatingButtons = document.querySelector('.floating-buttons'); - if (!floatingButtons) return; - - const exportBtn = document.createElement('button'); - exportBtn.className = 'floating-btn export-btn'; - exportBtn.id = 'exportBtn'; - exportBtn.title = 'Export Selected Plots (Ctrl+E)'; - exportBtn.innerHTML = '📄'; - exportBtn.style.display = 'none'; // Hidden by default - exportBtn.onclick = () => this.exportSelectedPlots(); - - floatingButtons.appendChild(exportBtn); - - // Add selection counter - const selectionCounter = document.createElement('div'); - selectionCounter.className = 'selection-counter'; - selectionCounter.id = 'selectionCounter'; - selectionCounter.style.display = 'none'; - selectionCounter.innerHTML = '0/4 selected'; - floatingButtons.appendChild(selectionCounter); - } - - /** - * Bind events for plot selection - */ - bindEvents() { - // Add selection mode toggle - document.addEventListener('keydown', (e) => { - if (e.ctrlKey && e.key === 'e') { - e.preventDefault(); - this.toggleSelectionMode(); - } - if (e.key === 'Escape') { - this.exitSelectionMode(); - } - }); - - // Add selection handlers to existing plots - this.addSelectionHandlers(); - } - - /** - * Add selection handlers to all plot items - */ - addSelectionHandlers() { - const plotItems = document.querySelectorAll('.grid-item'); - plotItems.forEach(item => this.addSelectionHandler(item)); - } - - /** - * Add selection handler to a single plot item - */ - addSelectionHandler(item) { - // Create selection overlay - const overlay = document.createElement('div'); - overlay.className = 'selection-overlay'; - overlay.innerHTML = ` -
- ☐ -
- `; - item.appendChild(overlay); - - // Add click handler for selection - overlay.addEventListener('click', (e) => { - e.preventDefault(); - e.stopPropagation(); - this.togglePlotSelection(item); - }); - } - - /** - * Toggle selection mode - */ - toggleSelectionMode() { - const body = document.body; - const isSelectionMode = body.classList.contains('selection-mode'); - - if (isSelectionMode) { - this.exitSelectionMode(); - } else { - this.enterSelectionMode(); - } - } - - /** - * Enter selection mode - */ - enterSelectionMode() { - document.body.classList.add('selection-mode'); - document.getElementById('exportBtn').style.display = 'block'; - document.getElementById('selectionCounter').style.display = 'block'; - this.updateSelectionCounter(); - } - - /** - * Exit selection mode - */ - exitSelectionMode() { - const wasInSelectionMode = document.body.classList.contains('selection-mode'); - - document.body.classList.remove('selection-mode'); - document.getElementById('exportBtn').style.display = 'none'; - document.getElementById('selectionCounter').style.display = 'none'; - this.clearSelection(); - - // Show message if user was actually in selection mode - if (wasInSelectionMode) { - this.showMessage('Exited selection mode', 'info'); - } - } - - /** - * Toggle plot selection - */ - togglePlotSelection(item) { - const plotName = this.getPlotName(item); - const plotPath = this.getPlotPath(item); - - if (this.selectedPlots.has(plotName)) { - this.selectedPlots.delete(plotName); - item.classList.remove('selected'); - item.querySelector('.checkbox-icon').textContent = '☐'; - } else { - if (this.selectedPlots.size >= this.maxPlots) { - this.showMessage(`Maximum ${this.maxPlots} plots can be selected`, 'warning'); - return; - } - this.selectedPlots.add(plotName); - item.classList.add('selected'); - item.querySelector('.checkbox-icon').textContent = '☑'; - } - - this.updateSelectionCounter(); - } - - /** - * Get plot name from grid item - */ - getPlotName(item) { - const plotName = item.querySelector('.plot-name'); - return plotName ? plotName.textContent.trim() : ''; - } - - /** - * Get plot PDF path from grid item - */ - getPlotPath(item) { - const link = item.querySelector('a[href$=".pdf"]'); - return link ? link.href : ''; - } - - /** - * Update selection counter - */ - updateSelectionCounter() { - const counter = document.getElementById('selectionCounter'); - if (counter) { - counter.textContent = `${this.selectedPlots.size}/${this.maxPlots} selected`; - } - - const exportBtn = document.getElementById('exportBtn'); - if (exportBtn) { - exportBtn.disabled = this.selectedPlots.size === 0; - exportBtn.style.opacity = this.selectedPlots.size === 0 ? '0.5' : '1'; - } - } - - /** - * Clear all selections - */ - clearSelection() { - this.selectedPlots.clear(); - document.querySelectorAll('.grid-item.selected').forEach(item => { - item.classList.remove('selected'); - const checkbox = item.querySelector('.checkbox-icon'); - if (checkbox) checkbox.textContent = '☐'; - }); - this.updateSelectionCounter(); - } - - /** - * Export selected plots to merged PDF - */ - async exportSelectedPlots() { - if (this.selectedPlots.size === 0) { - this.showMessage('No plots selected', 'warning'); - return; - } - - const plotPaths = Array.from(this.selectedPlots).map(plotName => { - const item = Array.from(document.querySelectorAll('.grid-item')) - .find(item => this.getPlotName(item) === plotName); - return this.getPlotPath(item); - }); - - this.showMessage('Preparing export...', 'info'); - - try { - await this.createMergedPDF(plotPaths); - } catch (error) { - this.showMessage('Export failed: ' + error.message, 'error'); - } - } - - /** - * Create merged PDF using Python script - */ - async createMergedPDF(plotPaths) { - // Convert file:// URLs to actual paths - const actualPaths = plotPaths.map(url => { - if (url.startsWith('file://')) { - return url.substring(7); // Remove 'file://' prefix - } - return url; - }); - - const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0]; - const outputName = `merged_plots_${timestamp}.pdf`; - - const payload = { - plots: actualPaths, - layout: this.calculateLayout(actualPaths.length), - output_name: outputName - }; - - // Generate a unique temporary filename - const tempFileName = `export_request_${Date.now()}.json`; - - // Save the request to a JSON file that can be picked up by a Python script - const requestData = JSON.stringify(payload, null, 2); - - // Show improved export instructions with full command - this.showExportInstructions(requestData, tempFileName); - } - - /** - * Calculate optimal layout for given number of plots - */ - calculateLayout(numPlots) { - switch (numPlots) { - case 1: return { rows: 1, cols: 1 }; - case 2: return { rows: 1, cols: 2 }; - case 3: return { rows: 2, cols: 2 }; // 3 plots in 2x2 grid with one empty - case 4: return { rows: 2, cols: 2 }; - default: return { rows: 2, cols: 2 }; - } - } - - /** - * Show export instructions to user - */ - showExportInstructions(requestData, tempFileName) { - const tempFilePath = `/tmp/${tempFileName}`; - const fullCommand = `echo '${requestData.replace(/'/g, "'\\''")}' > ${tempFilePath} && python export_plots.py ${tempFilePath}`; - - const instructions = ` -
-

🚀 Export Selected Plots

-

Run the following command in your terminal to export the selected plots:

- -
-
- ${fullCommand} -
-
- - - -
-
- -
-

📋 Command Breakdown:

-
    -
  • Creates temporary file: ${tempFilePath}
    • -
  • Runs export script: python export_plots.py
    • -
  • Output file: Will be saved in the work directory
    • -
-
- -
-

💡 Tips:

-
    -
  • The temporary JSON file will be automatically cleaned up after successful export
    • -
  • Use Esc to exit selection mode
    • -
  • Press Ctrl+E to toggle selection mode
    • -
-
-
- `; - - const overlay = document.createElement('div'); - overlay.className = 'export-overlay'; - overlay.innerHTML = instructions; - - // Add methods to the overlay for button handlers - overlay.copyCommand = function() { - navigator.clipboard.writeText(fullCommand).then(() => { - this.showCopyFeedback('Command copied to clipboard!'); - }).catch(() => { - this.showCopyFeedback('Failed to copy. Please select and copy manually.', 'error'); - }); - }; - - overlay.copyJSON = function() { - navigator.clipboard.writeText(requestData).then(() => { - this.showCopyFeedback('JSON copied to clipboard!'); - }).catch(() => { - this.showCopyFeedback('Failed to copy. Please select and copy manually.', 'error'); - }); - }; - - overlay.close = function() { - this.remove(); - }; - - overlay.showCopyFeedback = function(message, type = 'success') { - const feedback = document.createElement('div'); - feedback.className = `copy-feedback copy-feedback-${type}`; - feedback.textContent = message; - this.appendChild(feedback); - - setTimeout(() => { - if (feedback.parentNode) { - feedback.parentNode.removeChild(feedback); - } - }, 2000); - }; - - document.body.appendChild(overlay); - - // Close on ESC key - const handleEscape = (e) => { - if (e.key === 'Escape') { - overlay.remove(); - document.removeEventListener('keydown', handleEscape); - } - }; - document.addEventListener('keydown', handleEscape); - - // Close on clicking outside - overlay.addEventListener('click', (e) => { - if (e.target === overlay) { - overlay.remove(); - document.removeEventListener('keydown', handleEscape); - } - }); - } - - /** - * Download the PDF blob - */ - downloadPDF(blob) { - const url = URL.createObjectURL(blob); - const a = document.createElement('a'); - a.href = url; - a.download = `merged_plots_${new Date().toISOString().split('T')[0]}.pdf`; - document.body.appendChild(a); - a.click(); - document.body.removeChild(a); - URL.revokeObjectURL(url); - } - - /** - * Show temporary message to user - */ - showMessage(text, type = 'info') { - // Remove existing message - const existing = document.querySelector('.export-message'); - if (existing) existing.remove(); - - const message = document.createElement('div'); - message.className = `export-message export-message-${type}`; - message.textContent = text; - - document.body.appendChild(message); - - setTimeout(() => { - if (message.parentNode) { - message.parentNode.removeChild(message); - } - }, 3000); - } -} - -// Add these methods to ExportManager if not present -ExportManager.prototype.isSelectionModeActive = function() { - return document.body.classList.contains('selection-mode'); -}; -ExportManager.prototype.exitSelectionMode = function() { - document.body.classList.remove('selection-mode'); - if (typeof this.clearSelection === 'function') { - this.clearSelection(); - } -}; - -// Ensure a single global instance -window.exportManager = window.exportManager || new ExportManager(); - -// Listen for ESC key globally to exit selection mode -// (This will work even if focus is not on a plot) -document.addEventListener('keydown', function(e) { - if (e.key === 'Escape' && window.exportManager && window.exportManager.isSelectionModeActive()) { - window.exportManager.exitSelectionMode(); - } -}); - -// Attach improved export logic to export button -document.addEventListener('DOMContentLoaded', function() { - const exportBtn = document.getElementById('exportBtn'); - if (exportBtn) { - exportBtn.addEventListener('click', function() { - window.exportManager.exportSelectedPlots(); - }); - } -}); diff --git a/gallery/builder.py b/gallery/builder.py index 73d2cfb..ec39d1b 100644 --- a/gallery/builder.py +++ b/gallery/builder.py @@ -2,7 +2,8 @@ import shutil from pathlib import Path -from typing import Dict, Any, Optional, Union +from typing import Any, Dict, Optional, Union + from jinja2 import Environment, FileSystemLoader, Template from gallery.config import GalleryConfig @@ -17,7 +18,6 @@ from gallery.utils.metadata import ( ) from gallery.utils.processing import ( process_plot_files, - needs_update, render_gallery_page, ) @@ -39,13 +39,14 @@ def get_template(template_dir: Optional[Union[Path, str]] = None): if template_dir is None: # Use package-included template import gallery + gallery_module_path = Path(gallery.__file__).parent template_dir = gallery_module_path / "templates" env = Environment(loader=FileSystemLoader(str(template_dir))) - env.filters['datetime_from_timestamp'] = datetime_from_timestamp - env.filters['strftime'] = strftime_filter + env.filters["datetime_from_timestamp"] = datetime_from_timestamp + env.filters["strftime"] = strftime_filter return env.get_template("gallery.html") @@ -54,8 +55,8 @@ def build_gallery( config: GalleryConfig, source_dir: Path, web_dir: Path, - template: Template = None, - relative_path: Path = None, + template: Optional[Template] = None, + relative_path: Optional[Path] = None, inherited_metadata: Optional[Dict[str, Any]] = None, ) -> None: """ @@ -119,7 +120,7 @@ def build_gallery( subdir_web, template, subdir_relative, - current_metadata if config.inherit_from_parent else {} + current_metadata if config.inherit_from_parent else {}, ) subdir_names.append(subdir.name) @@ -130,15 +131,11 @@ def build_gallery( items=items, subdirs=subdir_names, relative_path=relative_path, - metadata=current_metadata + metadata=current_metadata, ) -def copy_assets( - config: GalleryConfig, - assets_src: Optional[Path] = None, - verbose: bool = False -) -> bool: +def copy_assets(config: GalleryConfig, assets_src: Optional[Path] = None, verbose: bool = False) -> bool: """ Copy assets to the web directory. @@ -154,14 +151,13 @@ def copy_assets( if assets_src is None: # Use package-included assets import gallery + gallery_module_path = Path(gallery.__file__).parent assets_src = gallery_module_path / "assets" if not assets_src.exists(): if verbose: - print( - f"Warning: Assets directory {assets_src} not found" - ) + print(f"Warning: Assets directory {assets_src} not found") return False gallery_root = Path(config.web_folder) / config.plot_root @@ -171,7 +167,7 @@ def copy_assets( # so any change to any JS/CSS file triggers a redeploy. sentinel_dst = assets_dst / "css" / "main.css" newest_src_mtime = max( - (f.stat().st_mtime for f in assets_src.rglob('*') if f.is_file()), + (f.stat().st_mtime for f in assets_src.rglob("*") if f.is_file()), default=0, ) dst_mtime = sentinel_dst.stat().st_mtime if sentinel_dst.exists() else 0 diff --git a/gallery/cli.py b/gallery/cli.py index 6aa747d..2b89ed1 100644 --- a/gallery/cli.py +++ b/gallery/cli.py @@ -10,13 +10,17 @@ import argparse import os import sys from pathlib import Path +from typing import List, Optional, cast import argcomplete from gallery import generate from gallery.config import ( - ConfigManager, GalleryConfig, GallerySource, - default_config_path, get_active_config_path, ensure_user_config, + ConfigManager, + GalleryConfig, + GallerySource, + ensure_user_config, + get_active_config_path, ) _WELCOME = """\ @@ -58,6 +62,11 @@ Config file: {config_path} """ +def _set_completer(action: argparse.Action, completer) -> None: + """argcomplete reads `.completer` dynamically; argparse.Action has no such attribute.""" + setattr(action, "completer", completer) + + def _is_configured(config_path: Path) -> bool: """Return True if web_folder is set to a non-empty value.""" try: @@ -104,13 +113,16 @@ def build_parser() -> argparse.ArgumentParser: description="Scientific Plot Gallery Generator", formatter_class=argparse.RawDescriptionHelpFormatter, ) - parser.add_argument( - "--config", - type=str, - default=None, - metavar="FILE", - help="Path to config file (default: package bundled config)", - ).completer = argcomplete.completers.FilesCompleter(["yaml", "yml"]) + _set_completer( + parser.add_argument( + "--config", + type=str, + default=None, + metavar="FILE", + help="Path to config file (default: package bundled config)", + ), + argcomplete.completers.FilesCompleter(["yaml", "yml"]), + ) sub = parser.add_subparsers(dest="command", metavar="COMMAND") @@ -121,13 +133,16 @@ def build_parser() -> argparse.ArgumentParser: description="Generate scientific gallery from plot collections", ) gen.add_argument("--clean", action="store_true", help="Clean gallery directory before generation") - gen.add_argument( - "--source", - type=str, - default=None, - metavar="DIR", - help="Only recompute a specific source directory (name defaults to dir name)", - ).completer = argcomplete.completers.DirectoriesCompleter() + _set_completer( + gen.add_argument( + "--source", + type=str, + default=None, + metavar="DIR", + help="Only recompute a specific source directory (name defaults to dir name)", + ), + argcomplete.completers.DirectoriesCompleter(), + ) gen.add_argument("-v", "--verbose", action="store_true", help="Print verbose output") # --- config ------------------------------------------------------------- @@ -146,20 +161,21 @@ def build_parser() -> argparse.ArgumentParser: cfg_sub.add_parser("sources", help="List all configured sources") p_get = cfg_sub.add_parser("get", help="Get a config value") - p_get.add_argument("key", help="Dot-separated key, e.g. gallery.png_dpi").completer = _config_keys + _set_completer(p_get.add_argument("key", help="Dot-separated key, e.g. gallery.png_dpi"), _config_keys) p_set = cfg_sub.add_parser("set", help="Set a config value") - p_set.add_argument("key", help="Dot-separated key, e.g. gallery.png_dpi").completer = _config_keys + _set_completer(p_set.add_argument("key", help="Dot-separated key, e.g. gallery.png_dpi"), _config_keys) p_set.add_argument("value", help="New value (YAML-parsed: use true/false for bools)") p_add = cfg_sub.add_parser("add-source", help="Add a plot source") p_add.add_argument("--name", default=None, help="Source name (default: bottom-level directory name)") - p_add.add_argument("--path", required=True, metavar="DIR", help="Path to source directory").completer = ( - argcomplete.completers.DirectoriesCompleter() + _set_completer( + p_add.add_argument("--path", required=True, metavar="DIR", help="Path to source directory"), + argcomplete.completers.DirectoriesCompleter(), ) p_rm = cfg_sub.add_parser("remove-source", help="Remove a plot source by name") - p_rm.add_argument("name", help="Source name to remove").completer = _source_names + _set_completer(p_rm.add_argument("name", help="Source name to remove"), _source_names) return parser @@ -174,10 +190,12 @@ def _run_generate(args: argparse.Namespace) -> int: try: config = GalleryConfig.from_yaml(config_path) - source_to_update = None + source_to_update: Optional[GallerySource] = None if args.source: source_path = Path(args.source).resolve() - matching = next((s for s in config.sources if Path(s.path).resolve() == source_path), None) + # config.sources is always List[GallerySource] after GalleryConfig.__post_init__ normalizes it. + typed_sources = cast(List[GallerySource], config.sources) + matching = next((s for s in typed_sources if Path(s.path).resolve() == source_path), None) if matching is None: source_to_update = GallerySource(name=source_path.name, path=source_path) config.sources.append(source_to_update) @@ -312,6 +330,7 @@ def main(): sys.exit(_run_install_completion()) elif args.command == "tui": from gallery.tui import GalleryTUI + config_path = Path(args.config) if args.config else None GalleryTUI(config_path=config_path).run() sys.exit(0) diff --git a/gallery/config/__init__.py b/gallery/config/__init__.py index 03f3a64..54840b8 100644 --- a/gallery/config/__init__.py +++ b/gallery/config/__init__.py @@ -8,7 +8,8 @@ defaults for gallery generation settings. import shutil from dataclasses import dataclass, field from pathlib import Path -from typing import Any, Dict, List, Optional, Union +from typing import Any, Dict, List, Optional, Union, cast + import yaml from platformdirs import user_config_dir @@ -31,8 +32,8 @@ def user_config_path() -> Path: def get_active_config_path() -> Path: """Return the config path to use, with this precedence: - 1. User config (~/.config/gallery/config.yaml) — if it exists - 2. Package-bundled template — fallback + 1. User config (~/.config/gallery/config.yaml) — if it exists + 2. Package-bundled template — fallback """ ucp = user_config_path() return ucp if ucp.exists() else default_config_path() @@ -133,6 +134,7 @@ class ConfigManager: @dataclass class GalleryDefaults: """Default values for gallery generation.""" + png_dpi: int = 400 plot_root: str = "gallery" cache_enabled: bool = True @@ -142,6 +144,7 @@ class GalleryDefaults: @dataclass class GallerySource: """Represents a single data source for the gallery.""" + name: str path: Union[str, Path] @@ -157,22 +160,23 @@ class GalleryConfig: Can be created programmatically or loaded from YAML. """ + web_folder: Union[str, Path] sources: List[Union[GallerySource, Dict[str, Any]]] = field(default_factory=list) png_dpi: int = GalleryDefaults.png_dpi plot_root: str = GalleryDefaults.plot_root cache_enabled: bool = GalleryDefaults.cache_enabled inherit_from_parent: bool = GalleryDefaults.inherit_from_parent - backup_folder: str = "" def __post_init__(self): if isinstance(self.web_folder, str): self.web_folder = Path(self.web_folder) - normalized_sources = [] + normalized_sources: List[Union[GallerySource, Dict[str, Any]]] = [] for source in self.sources: if isinstance(source, dict): - source = GallerySource(**source) + source_dict = cast(Dict[str, Any], source) + source = GallerySource(name=source_dict["name"], path=source_dict["path"]) elif not isinstance(source, GallerySource): raise TypeError(f"Source must be dict or GallerySource, got {type(source)}") normalized_sources.append(source) @@ -197,16 +201,19 @@ class GalleryConfig: gallery_cfg = data.get("gallery", {}) sources_data = data.get("sources", []) - sources = [{"name": s["name"], "path": s["path"]} for s in sources_data] + sources: List[Union[GallerySource, Dict[str, Any]]] = [ + {"name": s["name"], "path": s["path"]} for s in sources_data + ] + + metadata_cfg = data.get("metadata", {}) return cls( web_folder=web_folder, sources=sources, png_dpi=gallery_cfg.get("png_dpi", GalleryDefaults.png_dpi), plot_root=gallery_cfg.get("plot_root", GalleryDefaults.plot_root), - cache_enabled=data.get("metadata", {}).get("cache_enabled", GalleryDefaults.cache_enabled), - inherit_from_parent=data.get("metadata", {}).get("inherit_from_parent", GalleryDefaults.inherit_from_parent), - backup_folder=gallery_cfg.get("backup_folder", ""), + cache_enabled=metadata_cfg.get("cache_enabled", GalleryDefaults.cache_enabled), + inherit_from_parent=metadata_cfg.get("inherit_from_parent", GalleryDefaults.inherit_from_parent), ) def to_yaml(self, yaml_file: Union[str, Path]) -> None: @@ -220,7 +227,6 @@ class GalleryConfig: "gallery": { "plot_root": self.plot_root, "png_dpi": self.png_dpi, - "backup_folder": self.backup_folder, }, "ui": { "max_recent_plots": 20, @@ -231,7 +237,8 @@ class GalleryConfig: "inherit_from_parent": self.inherit_from_parent, "supported_formats": [".yaml", ".yml", ".json"], }, - "sources": [{"name": s.name, "path": str(s.path)} for s in self.sources], + # self.sources is always List[GallerySource] after __post_init__ normalizes it. + "sources": [{"name": s.name, "path": str(s.path)} for s in cast(List[GallerySource], self.sources)], } with open(yaml_path, "w") as f: diff --git a/gallery/config/config.yaml b/gallery/config/config.yaml index 833c266..04f80a0 100644 --- a/gallery/config/config.yaml +++ b/gallery/config/config.yaml @@ -1,5 +1,4 @@ gallery: - backup_folder: '' plot_root: gallery png_dpi: 400 metadata: diff --git a/gallery/tui.py b/gallery/tui.py index 2d98555..7169208 100644 --- a/gallery/tui.py +++ b/gallery/tui.py @@ -27,6 +27,7 @@ from textual.app import App, ComposeResult from textual.binding import Binding from textual.containers import Horizontal, ScrollableContainer, Vertical from textual.reactive import reactive +from textual.widget import Widget from textual.widgets import Button, Collapsible, Footer, Header, Input, Label, RichLog, Static from gallery.config import ConfigManager, ensure_user_config, get_active_config_path @@ -37,12 +38,11 @@ from gallery.config import ConfigManager, ensure_user_config, get_active_config_ # widget_id is used as the HTML-style id (#web-folder) in CSS selectors # --------------------------------------------------------------------------- CONFIG_FIELDS = [ - ("web-folder", "paths.web_folder", True), - ("plot-root", "gallery.plot_root", False), - ("png-dpi", "gallery.png_dpi", False), - ("backup-folder", "gallery.backup_folder", False), - ("cache-enabled", "metadata.cache_enabled", False), - ("inherit-meta", "metadata.inherit_from_parent",False), + ("web-folder", "paths.web_folder", True), + ("plot-root", "gallery.plot_root", False), + ("png-dpi", "gallery.png_dpi", False), + ("cache-enabled", "metadata.cache_enabled", False), + ("inherit-meta", "metadata.inherit_from_parent", False), ] REQUIRED_IDS = {fid for fid, _, req in CONFIG_FIELDS if req} @@ -249,9 +249,6 @@ class GalleryTUI(App): with Horizontal(classes="field-row"): yield Label("PNG DPI") yield Input(id="png-dpi", placeholder="400") - with Horizontal(classes="field-row"): - yield Label("Backup folder") - yield Input(id="backup-folder", placeholder="leave empty to disable") with Horizontal(classes="field-row"): yield Label("Cache metadata") yield Input(id="cache-enabled", placeholder="true") @@ -269,9 +266,9 @@ class GalleryTUI(App): # Bottom bar — always visible outside the scroll area with Horizontal(id="footer-bar"): yield Static("", id="dirty-indicator") - yield Button("Save Config", id="save-btn", variant="success") - yield Button("Generate", id="generate-btn", variant="primary") - yield Button("Quit", id="quit-btn", variant="error") + yield Button("Save Config", id="save-btn", variant="success") + yield Button("Generate", id="generate-btn", variant="primary") + yield Button("Quit", id="quit-btn", variant="error") yield Footer() @@ -280,9 +277,7 @@ class GalleryTUI(App): # ------------------------------------------------------------------ def on_mount(self) -> None: self._load_config_into_fields() - self.query_one("#config-path-label", Static).update( - f"Config: {self.config_path}" - ) + self.query_one("#config-path-label", Static).update(f"Config: {self.config_path}") def _make_source_row(self, name: str = "", path: str = "") -> Horizontal: """Return a single editable source row widget.""" @@ -368,7 +363,7 @@ class GalleryTUI(App): self._save_config() @on(Button.Pressed, "#quit-btn") - def action_quit(self) -> None: + async def action_quit(self) -> None: self.exit() @on(Button.Pressed, "#save-btn") @@ -421,7 +416,9 @@ class GalleryTUI(App): @on(Button.Pressed, ".source-remove-btn") def _remove_source_row(self, event: Button.Pressed) -> None: """Remove the row whose − button was pressed.""" - event.button.parent.remove() + parent = event.button.parent + assert isinstance(parent, Widget), "source-remove button must be mounted inside a source row widget" + parent.remove() self.dirty = True # -- Generate -------------------------------------------------------- @@ -461,8 +458,7 @@ class GalleryTUI(App): status.label = label # --config is a top-level flag (before the subcommand) in the CLI parser - cmd = [sys.executable, "-m", "gallery.cli", - "--config", str(self.config_path), "generate", "--verbose"] + cmd = [sys.executable, "-m", "gallery.cli", "--config", str(self.config_path), "generate", "--verbose"] try: proc = subprocess.Popen( cmd, @@ -470,6 +466,7 @@ class GalleryTUI(App): stderr=subprocess.STDOUT, text=True, ) + assert proc.stdout is not None, "Popen was called with stdout=PIPE" for line in proc.stdout: line = line.rstrip() if line: diff --git a/gallery/utils/backup.py b/gallery/utils/backup.py deleted file mode 100644 index 6396f1d..0000000 --- a/gallery/utils/backup.py +++ /dev/null @@ -1,40 +0,0 @@ -"""Backup utilities for gallery.""" - -import zipfile -import datetime -from pathlib import Path - - -def create_backup( - web_folder: Path, - backup_folder: Path -) -> bool: - """ - Create a backup of the web folder. - - Args: - web_folder: Path to the web folder to backup - backup_folder: Path to the backup directory - - Returns: - True if backup was created successfully, False otherwise - """ - try: - today = datetime.date.today().strftime("%Y%m%d") - backup_name = f"backup-{today}.zip" - backup_path = backup_folder / backup_name - - backup_folder.mkdir(parents=True, exist_ok=True) - - if backup_path.exists(): - return True - - with zipfile.ZipFile(backup_path, "w", zipfile.ZIP_DEFLATED) as zipf: - for path in web_folder.rglob("*"): - if path.is_file(): - arcname = path.relative_to(web_folder.parent) - zipf.write(path, arcname) - return True - except Exception as e: - print(f"Warning: Could not create backup: {e}") - return False diff --git a/gallery/utils/metadata.py b/gallery/utils/metadata.py index 964a38b..f42bc6a 100644 --- a/gallery/utils/metadata.py +++ b/gallery/utils/metadata.py @@ -13,9 +13,10 @@ Features: """ import json -import yaml from pathlib import Path -from typing import Dict, Any +from typing import Any, Dict + +import yaml def load_metadata_file(metadata_path: Path) -> Dict[str, Any]: @@ -33,15 +34,14 @@ def load_metadata_file(metadata_path: Path) -> Dict[str, Any]: return {} try: - with metadata_path.open('r', encoding='utf-8') as f: + with metadata_path.open("r", encoding="utf-8") as f: suffix_lower = metadata_path.suffix.lower() - if suffix_lower == '.yaml' or suffix_lower == '.yml': + if suffix_lower == ".yaml" or suffix_lower == ".yml": return yaml.safe_load(f) or {} - elif metadata_path.suffix.lower() == '.json': + elif metadata_path.suffix.lower() == ".json": return json.load(f) or {} else: - print(f"Warning: Unknown metadata file format: " - f"{metadata_path}") + print(f"Warning: Unknown metadata file format: {metadata_path}") return {} except (yaml.YAMLError, json.JSONDecodeError, IOError) as e: print(f"Warning: Could not parse metadata file {metadata_path}: {e}") @@ -59,7 +59,7 @@ def load_folder_metadata(folder_path: Path) -> Dict[str, Any]: Dictionary containing the folder metadata """ # Try YAML first, then JSON for backwards compatibility - for filename in ['metadata.yaml', 'metadata.yml', 'metadata.json']: + for filename in ["metadata.yaml", "metadata.yml", "metadata.json"]: metadata_path = folder_path / filename if metadata_path.exists(): @@ -81,7 +81,7 @@ def get_metadata_file_path(folder_path: Path) -> str: String path to the metadata file (existing or suggested) """ # Preferred order: YAML first, then JSON - preferred_files = ['metadata.yaml', 'metadata.yml', 'metadata.json'] + preferred_files = ["metadata.yaml", "metadata.yml", "metadata.json"] for filename in preferred_files: metadata_path = folder_path / filename @@ -89,13 +89,10 @@ def get_metadata_file_path(folder_path: Path) -> str: return str(metadata_path) # If no file exists, suggest metadata.yaml (preferred format) - return str(folder_path / 'metadata.yaml') + return str(folder_path / "metadata.yaml") -def merge_metadata( - parent_metadata: Dict[str, Any], - child_metadata: Dict[str, Any] -) -> Dict[str, Any]: +def merge_metadata(parent_metadata: Dict[str, Any], child_metadata: Dict[str, Any]) -> Dict[str, Any]: """ Merge parent and child metadata, with child values overriding parent. @@ -111,10 +108,7 @@ def merge_metadata( return merged -def resolve_metadata_for_plot( - plot_path: Path, - inherited_metadata: Dict[str, Any] -) -> Dict[str, Any]: +def resolve_metadata_for_plot(plot_path: Path, inherited_metadata: Dict[str, Any]) -> Dict[str, Any]: """ Resolve metadata for a specific plot. @@ -131,7 +125,7 @@ def resolve_metadata_for_plot( plot_dir = plot_path.parent # Check for plot-specific metadata files - for suffix in ['.yaml', '.yml', '.json']: + for suffix in [".yaml", ".yml", ".json"]: plot_metadata_path = plot_dir / f"{plot_stem}{suffix}" if plot_metadata_path.exists(): plot_metadata = load_metadata_file(plot_metadata_path) @@ -141,10 +135,7 @@ def resolve_metadata_for_plot( return inherited_metadata.copy() -def save_metadata_cache( - web_dir: Path, - plot_metadata_cache: Dict[str, Dict[str, Any]] -) -> None: +def save_metadata_cache(web_dir: Path, plot_metadata_cache: Dict[str, Dict[str, Any]]) -> None: """ Save plot metadata cache to meta_cache.json in the web directory. @@ -154,7 +145,7 @@ def save_metadata_cache( """ cache_path = web_dir / "meta_cache.json" try: - with cache_path.open('w', encoding='utf-8') as f: + with cache_path.open("w", encoding="utf-8") as f: json.dump(plot_metadata_cache, f, indent=2, ensure_ascii=False) except IOError as e: print(f"Warning: Could not save metadata cache {cache_path}: {e}") diff --git a/gallery/utils/processing.py b/gallery/utils/processing.py index b1e548d..3768174 100644 --- a/gallery/utils/processing.py +++ b/gallery/utils/processing.py @@ -3,34 +3,31 @@ import shutil import subprocess from pathlib import Path -from typing import Any, Dict +from typing import Any, Dict, Optional + +from jinja2 import Template + +from gallery.config import GalleryConfig +from gallery.utils.metadata import ( + get_metadata_file_path, + resolve_metadata_for_plot, +) +from gallery.utils.stats import ( + calculate_directory_stats, + format_file_size, +) try: import fitz # PyMuPDF + _PYMUPDF_AVAILABLE = True except ImportError: _PYMUPDF_AVAILABLE = False _IMAGEMAGICK_AVAILABLE = shutil.which("convert") is not None -from jinja2 import Template -from gallery.utils.metadata import ( - resolve_metadata_for_plot, - get_metadata_file_path, -) -from gallery.utils.stats import ( - calculate_directory_stats, - format_file_size, -) -from gallery.config import GalleryConfig - - -def process_html_file( - html_file: Path, - web_dir: Path, - current_metadata: Dict[str, Any] = None -) -> dict: +def process_html_file(html_file: Path, web_dir: Path, current_metadata: Optional[Dict[str, Any]] = None) -> dict: """ Process HTML plot file, copying it to web directory. @@ -60,15 +57,15 @@ def process_html_file( "html_href": html_file.name, "is_html": True, "metadata": plot_metadata, - "creation_time": source_creation_time + "creation_time": source_creation_time, } def process_plot_files( - config: GalleryConfig, - plot_file: Path, - web_dir: Path, - current_metadata: Dict[str, Any] = None, + config: GalleryConfig, + plot_file: Path, + web_dir: Path, + current_metadata: Optional[Dict[str, Any]] = None, ) -> dict: """ Process plot files (PDF/PNG or HTML), handling conversion and copying. @@ -82,7 +79,7 @@ def process_plot_files( Returns: Dictionary containing plot information """ - if plot_file.suffix.lower() == '.html': + if plot_file.suffix.lower() == ".html": return process_html_file(plot_file, web_dir, current_metadata) # Handle PDF files @@ -111,7 +108,7 @@ def process_plot_files( "png_href": png_file.name, "is_html": False, "metadata": plot_metadata, - "creation_time": source_creation_time + "creation_time": source_creation_time, } @@ -122,8 +119,8 @@ def render_gallery_page( items: list, subdirs: list, relative_path: Path, - title: str = None, - metadata: dict = None + title: Optional[str] = None, + metadata: Optional[dict] = None, ) -> None: """ Unified template rendering for all gallery pages. @@ -139,8 +136,7 @@ def render_gallery_page( metadata: Metadata dictionary (optional) """ if title is None: - title = "Gallery" if relative_path == Path( - ".") else f"Gallery: {relative_path}" + title = "Gallery" if relative_path == Path(".") else f"Gallery: {relative_path}" if metadata is None: metadata = {} @@ -151,7 +147,7 @@ def render_gallery_page( "file_count": len(items), "folder_count": len(subdirs), "total_size": format_file_size(current_stats["total_size"]), - "total_size_bytes": current_stats["total_size"] + "total_size_bytes": current_stats["total_size"], } # Calculate relative path to assets @@ -185,7 +181,7 @@ def render_gallery_page( folder_metadata=metadata, assets_path=assets_path, source_dir=str(web_dir), - metadata_file_path=get_metadata_file_path(web_dir) + metadata_file_path=get_metadata_file_path(web_dir), ) f.write(rendered_html) @@ -232,13 +228,18 @@ def _convert_pdf_pymupdf(pdf_path: Path, png_path: Path, dpi: int) -> None: def _convert_pdf_imagemagick(pdf_path: Path, png_path: Path, dpi: int) -> None: - subprocess.run([ - "convert", - "-density", str(dpi), - str(pdf_path), - "-quality", "95", - str(png_path), - ], check=True) + subprocess.run( + [ + "convert", + "-density", + str(dpi), + str(pdf_path), + "-quality", + "95", + str(png_path), + ], + check=True, + ) def needs_update(source_file: Path, target_file: Path) -> bool: diff --git a/gallery/utils/stats.py b/gallery/utils/stats.py index 0af246d..6f79f06 100644 --- a/gallery/utils/stats.py +++ b/gallery/utils/stats.py @@ -30,9 +30,9 @@ def calculate_directory_stats(directory: Path) -> dict: size = item.stat().st_size stats["total_size"] += size - if item.suffix.lower() == '.pdf': + if item.suffix.lower() == ".pdf": stats["pdf_size"] += size - elif item.suffix.lower() == '.png': + elif item.suffix.lower() == ".png": stats["png_size"] += size elif item.is_dir(): stats["folder_count"] += 1 diff --git a/plotstyle/CLAUDE.md b/plotstyle/CLAUDE.md new file mode 100644 index 0000000..5fa7888 --- /dev/null +++ b/plotstyle/CLAUDE.md @@ -0,0 +1,320 @@ +# CLAUDE.md — `plotstyle` + +Guidance for Claude Code (or any coding agent) writing or editing scripts that +use `plotstyle`. This package is a **standalone matplotlib styling toolkit**, +decoupled from the `gallery/` package in this repo — `gallery/` never imports +it. The connection between the two is a file on disk: `plotstyle` produces +PDF figures, and `gallery` (elsewhere in this repo) turns a directory of PDFs +into an HTML gallery. See the bottom of this file for that handoff. + +## What it is + +A KIT (Karlsruhe Institute of Technology) corporate-design matplotlib theme +plus a handful of building-block functions, so every figure produced for a +thesis chapter or a talk slide looks consistent — validated color palette, +consistent spines/ticks/grid, LaTeX text in a modern sans font, figure +titles with a parameters subtitle, and legend/panel-label helpers. + +**Read `examples/plotstyle_showcase.ipynb` (repo root) for a fully rendered, +end-to-end tour** — it's the fastest way to see what every function actually +produces. Everything below is the reference; the notebook is the demo. + +## Install + +`plotstyle` is its own project (`plotstyle/pyproject.toml`, `uv_build` +backend, code under `plotstyle/src/plotstyle/`) and a member of this repo's +uv workspace (`[tool.uv.workspace]` in the root `pyproject.toml`) — not a +`gallery` extra. + +```bash +uv sync --all-packages # this repo's uv workflow — installs gallery + plotstyle together +``` + +`matplotlib>=3.7` is `plotstyle`'s own direct dependency — don't add it to +`gallery`'s dependencies to support this package; `gallery` should stay +installable without ever pulling in matplotlib. + +**Hard requirement: a working local LaTeX toolchain (`latex` + `dvipng`).** +`plotstyle.use()` sets `text.usetex = True` unconditionally — there is no +mathtext fallback. If a script using `plotstyle` needs to run somewhere LaTeX +isn't installed, that's a real environment gap to flag, not something to +silently work around in `plotstyle` itself (that decision was made +deliberately across several iterations of this package — don't reintroduce a +fallback without being asked). + +## Quick start + +```python +import numpy as np +import plotstyle as ps + +ps.use() # once, before creating any figure + +fig, ax = ps.new_figure( + "thesis-single", + title="Measured signal", + params={"N": 512, "sigma": 1.2, "seed": 42}, +) +ax.plot(np.linspace(0, 10, 200), np.sin(np.linspace(0, 10, 200)), label="signal") +ax.set_xlabel("Time (s)") +ax.set_ylabel(r"Amplitude $A(t)$") +ps.style_legend(ax, title="Series") +ps.savefig(fig, "plots/measured_signal", formats=("pdf",)) +``` + +## API reference + +Everything is re-exported at the top level (`import plotstyle as ps`); the +submodule layout (`style.py`, `colors.py`, `figures.py`, `annotations.py`) is +an implementation detail, not part of the interface agents should reach into. + +### `ps.use(cycle_linestyles: bool = False)` + +Applies the theme to matplotlib's global `rcParams`. **Call this once, near +the top of the script, before creating any figure.** Sets: + +- Only the bottom spine visible, colored black and heavier than default + (`axes.edgecolor`/`axes.linewidth`) — left/top/right spines off. +- Ticks on left + bottom only; x-axis gets shorter minor ticks between the + major ones (y-axis doesn't — its horizontal gridlines already mark + position). Major tick labels read as dark ink, minor tick labels lighter + grey. +- Horizontal-only, light-grey gridlines. +- Left-aligned axes titles (`axes.titlelocation: left`). +- `axes.prop_cycle` = the 9 KIT categorical colors, in fixed order. Color + only by default — pass `cycle_linestyles=True` to also cycle linestyle + (solid/dashed/dash-dot/dotted), which matters if a figure might be printed + in grayscale or viewed by someone with color-vision deficiency. +- `text.usetex = True` with Latin Modern Sans (`lmodern` + `sfmath` so + *math-mode* text is sans too, not just body text; `fontenc` T1 so plain + ASCII like `|` doesn't render as the wrong glyph under LaTeX's OT1 + default). + +`ps.reset()` restores matplotlib defaults (`plt.rcdefaults()`) — useful +between notebook cells or in tests, not normally needed in a script. + +### `ps.new_figure(preset="thesis-single", *, title=None, params=None, **subplots_kwargs)` + +Thin wrapper over `plt.subplots()`. Returns `(fig, ax)` or `(fig, axes)` +exactly like `plt.subplots()` — `**subplots_kwargs` (`nrows`, `ncols`, +`sharex`, ...) pass straight through. + +- `preset`: one of `ps.FIGSIZES` — `"thesis-single"` (6×4"), `"thesis-wide"` + (8×4.5"), `"slide-16x9"` (10×5.625"), `"square"` (5×5"). Or pass an + explicit `(w, h)` tuple in inches to bypass the presets. +- `title`: sets a **left-aligned, bold figure-level title** via + `fig.suptitle`. **Prefer this over `ax.set_title()` for a single-axes + figure** — it's the recommended, consistent way to title a plot in this + codebase. Reserve `ax.set_title()` for multi-axes figures, where each + panel needs its own title and no single figure title could cover all of + them (see the multi-panel example in the notebook). +- `params`: an optional dict rendered as a smaller subtitle line under the + title: `key1: value1 | key2: value2 | ...`. Good for recording the run + parameters that produced a plot (`params={"N": 512, "seed": 42}`). Note it + is *not* colored differently from the title (see "Known limitation" + below) — only smaller. + +### `ps.colorbar(mappable, ax, size="5%", pad=0.05, **kwargs)` + +Use this **instead of** `fig.colorbar(im, ax=ax)` whenever `ax` has +`set_aspect("equal")` (or anything else that visually shrinks it) — plain +`fig.colorbar` sizes to the axes' nominal bounding box and ends up taller +than what's actually drawn. This appends a matching-size axes via +`mpl_toolkits.axes_grid1.make_axes_locatable` and also turns off the +colorbar's own border (`cb.outline.set_visible(False)`), which otherwise +independently picks up the bold black spine styling as a stray box around +the colorbar. + +### `ps.no_spines(ax)` + +Hides all four spines on `ax` (or every Axes in an array, e.g. from +`new_figure(nrows=..., ncols=...)`). `use()` keeps only the bottom spine +visible by default, since most plots have a meaningful x baseline — but +pixel/bin-indexed plots (`imshow`, `pcolormesh`, 2D histograms) don't have +one, so the themed bottom spine implies an axis origin that doesn't mean +anything there. Call this on the Axes for that kind of plot instead of +leaving the bottom spine on or hand-rolling +`ax.spines[...].set_visible(False)`: + +```python +im = ax.imshow(image_data) +ps.no_spines(ax) +ps.colorbar(im, ax, label="Intensity") +``` + +### `ps.style_legend(ax, loc="outside right upper", frameon=False, title=None, **kwargs)` + +Builds a legend from `ax`'s handles/labels but attaches it to the **figure** +(`fig.legend(...)`), so it always sits outside the axes rather than +overlapping data. Pass `title=` — strongly encouraged; omitting it prints a +`UserWarning` (the legend still renders, so this won't break a script, but +an agent generating new plots should always pass one). + +### `ps.panel_label(ax, label, loc="lower right", fontweight="bold", box=True, **kwargs)` + +Adds a `(a)`/`(b)`/… label for multi-panel figures. Defaults to the +bottom-right corner (nudged up from the very edge so it clears the x-axis), +colored to match `ax`'s xlabel, on a light-grey semi-transparent rounded box +with a slim solid border. Pass `box=False` for bare text. Don't hand-roll +this with `ax.text(...)` — use the helper so every panel label in a figure +(and across figures) looks the same. + +### `ps.savefig(fig, path, formats=("pdf",), dpi=300)` + +Writes one file per format (`path` has no extension; each format is +appended). **Default to `formats=("pdf",)`** — see "Combining with +`gallery`" below for why PDF is what you almost always want here. Creates +parent directories automatically. + +### `ps.get_color(i)` / `ps.colors` + +`ps.get_color(i)` indexes the 9-color categorical palette (0-based) and +raises `ValueError` past the last slot — **never** wrap/cycle back to 0 +yourself past index 8; fold extra series into an "Other" bucket or facet +instead. Prefer relying on the default `prop_cycle` (i.e. just call +`ax.plot(...)` repeatedly without specifying `color=`) over calling +`get_color()` explicitly, unless you need a specific slot out of order (e.g. +matching a color used elsewhere in the same figure). + +`ps.colors` also exposes, if you need direct access: +- `CATEGORICAL` — the 9 hex strings, in order. +- `sequential_cmap()` — continuous KIT-blue colormap (light tint → brand + blue) for magnitude/heatmap data. +- `diverging_cmap()` — KIT blue ↔ KIT red through a neutral grey midpoint, + for signed data. Always pass symmetric `vmin`/`vmax` around the data's true + zero when using it. +- `STATUS` — fixed `good`/`warning`/`serious`/`critical` colors. **Never** + put these in a categorical series cycle; only use them for actual + good/bad-style status encoding, always paired with a label. +- `INK` — the grey/text roles (`primary`, `secondary`, `muted`, `gridline`, + `baseline`, `surface`) the theme itself is built from. + +## Best practices (for agents writing or reviewing plot scripts) + +1. **Call `ps.use()` once, before any figure is created.** Don't call it + again mid-script unless deliberately toggling `cycle_linestyles` back and + forth (rare — only useful when a notebook wants to show both modes). +2. **Prefer `new_figure(title=..., params=...)` over `ax.set_title()`** for + any single-axes figure. Use `ax.set_title()` only per-panel in multi-axes + figures. +3. **Never use literal `#` or `%` in any text passed to matplotlib** (titles, + labels, legend entries, annotations) while `plotstyle` is active — usetex + is always on, and those are LaTeX special characters that will break + rendering with a `RuntimeError` from `latex`. Rephrase instead of + escaping where possible (e.g. a hex color used as a *label* should be + spelled without its `#`; a percentage should read "42 percent" or use an + escaped `\%` if you specifically need the glyph). +4. **Don't hand-style spines/ticks/grid/legend/panel-labels manually** — + that's what `use()`, `style_legend()`, and `panel_label()` are for. If an + agent finds itself writing `ax.spines[...].set_visible(...)` or similar + in a script that already calls `ps.use()`, that's very likely fighting + the theme rather than working with it — stop and reconsider. The one + sanctioned exception is `ps.no_spines(ax)` on `imshow`/`pcolormesh`/2D + histogram Axes, where the themed bottom spine implies a baseline that + doesn't exist for pixel/bin data. +5. **Default `savefig(..., formats=("pdf",))`.** Only add `"png"`/`"svg"` if + there's a concrete reason (e.g. a quick raster preview outside the + gallery pipeline) — seeing `formats=("pdf", "png")` in a new script is a + signal to ask why, since the gallery already produces its own PNG + thumbnails from the PDF. +6. **This package has no test/CI dependency on a real LaTeX install being + absent** — the test suite (`tests/test_plotstyle.py`) assumes LaTeX *is* + present (this repo's dev machine has it), and exercises real rendering + rather than mocking it out. Don't add a mathtext-fallback code path to + make tests pass in a hypothetical no-LaTeX CI without being asked; that + would silently reintroduce the fallback behavior that was deliberately + removed. +7. **Known limitation, don't try to route around it:** a figure title and + its `params` subtitle can't have different colors (matplotlib's usetex + rendering tints an entire Text artist with one color; any in-source + `\color`/`\textcolor` is ignored). They're differentiated by size + (`\small`) only. If asked to make the subtitle a different color, the + real fix requires a second, independently-positioned Text artist with its + own color — flag the added complexity rather than quietly reaching for + `\textcolor` again. + +## Combining with `gallery`: producing plots the gallery will display + +`plotstyle` and `gallery` never share code or imports — the only connection +is that `gallery` recursively scans **source directories** (configured in +`gallery`'s `config.yaml`, see repo-root `CLAUDE.md`) for PDF/HTML files plus +`metadata.yaml`/`.yml`/`.json` files, and turns them into a static site. +`gallery` does its own PDF→PNG conversion at a configured DPI — so a +`plotstyle` script only needs to produce the PDF; **don't** also generate a +PNG "for the gallery" (that's `gallery`'s job, and a hand-made PNG would just +be redundant/inconsistent with the thumbnail `gallery` generates itself). + +### End-to-end workflow + +1. **Pick or create a source directory** for the project's plots — this can + be anywhere on disk, it does not need to live inside this repo (e.g. + `~/experiments/run42/plots/`). Subdirectories inside it become the + gallery's folder hierarchy. + +2. **Write the plotting script using `plotstyle`**, saving into that + directory: + + ```python + import plotstyle as ps + + ps.use() + fig, ax = ps.new_figure("thesis-single", title="Beam profile", params={"run": 42}) + # ... plot ... + ps.savefig(fig, "/home/user/experiments/run42/plots/beam_profile/x_projection", formats=("pdf",)) + ``` + +3. **Add a `metadata.yaml`** in any folder of that source tree to annotate + every plot within it (and its subfolders — metadata inherits downward, + child keys override parent keys). Fields are freeform YAML — there's no + fixed schema — but a few keys get special, prominent placement in the + per-plot popup UI: `title`, `description`, `plot_type`, `experiment`. + Everything else still displays, just under "Additional Information". + + ```yaml + # metadata.yaml + title: "Run 42 — Beam Profile Measurements" + description: "Transverse beam profiles at IP1, measured with the wire scanner." + experiment: "Run 42" + plot_type: "beam-profile" + + parameters: + beam_energy: "6.5 TeV" + bunch_intensity: "1.1e11" + + tags: + - "beam-diagnostics" + - "ip1" + ``` + + - Also accepts `.yml`/`.json` instead of `.yaml`. + - **Per-plot override**: create `.yaml` next to + `.pdf` (matching the PDF's stem) with just the keys to + override for that one plot — it's merged on top of the inherited + folder metadata. + - Long text values (>100 chars), lists, and nested mappings all render + sensibly in the UI automatically (truncated-with-"show more", tags, + nested key/value blocks respectively) — no special formatting needed + on the Python/YAML side. + - Metadata text values support inline LaTeX, rendered client-side via + MathJax, e.g. `formula: "$$E = mc^2$$"` or + `luminosity: "35.9 fb^{-1}"`. + +4. **Register the source** in `gallery`'s `config.yaml` if it isn't already + there: + + ```yaml + sources: + - name: "run42" + path: "/home/user/experiments/run42/plots" + ``` + +5. **Generate (or update) the gallery**: + + ```bash + gallery generate --source /home/user/experiments/run42/plots --verbose + ``` + + Incremental: `gallery` only reconverts a PDF to PNG if the PDF is newer + than the cached PNG (with a 30s buffer — see repo-root `CLAUDE.md`), so + re-running a `plotstyle` script that overwrites the same PDF path is + exactly the intended update flow. diff --git a/plotstyle/README.md b/plotstyle/README.md new file mode 100644 index 0000000..741cb72 --- /dev/null +++ b/plotstyle/README.md @@ -0,0 +1,40 @@ +# plotstyle + +A KIT (Karlsruhe Institute of Technology) corporate-design matplotlib +styling toolkit — a validated color palette, consistent spines/ticks/ +gridlines, LaTeX text in a modern sans font, and a few building-block +functions (figure titles with a parameters subtitle, a same-size colorbar +helper, an outside-axes legend, panel labels) for producing figures that +look consistent across a thesis and a slide deck. + +Requires a local LaTeX toolchain (`latex` + `dvipng`) — `plotstyle` always +renders text through real LaTeX, there's no fallback. + +```python +import numpy as np +import plotstyle as ps + +ps.use() # once, before creating any figure + +fig, ax = ps.new_figure( + "thesis-single", + title="Measured signal", + params={"N": 512, "seed": 42}, +) +x = np.linspace(0, 10, 200) +ax.plot(x, np.sin(x), label="signal") +ax.set_xlabel("Time (s)") +ax.set_ylabel(r"Amplitude $A(t)$") +ps.style_legend(ax, title="Series") + +ps.savefig(fig, "plots/measured_signal", formats=("pdf",)) +``` + +This package is developed as part of the +[ETPlot](https://git.larsbogner.de/lars/ETPlot) monorepo, where it is paired +with `gallery`, a static HTML gallery generator that turns directories of +plot PDFs into a browsable website — `plotstyle` has no code dependency on +`gallery`, the two only meet on disk via the PDF (and optional +`metadata.yaml`) files a `plotstyle` script writes out. See that repo's +`examples/plotstyle_showcase.ipynb` for a fully rendered tour of every +function, and `plotstyle/CLAUDE.md` for the full API reference. diff --git a/plotstyle/pyproject.toml b/plotstyle/pyproject.toml new file mode 100644 index 0000000..da96b22 --- /dev/null +++ b/plotstyle/pyproject.toml @@ -0,0 +1,37 @@ +[build-system] +requires = ["uv_build>=0.11.19,<0.12.0"] +build-backend = "uv_build" + +[project] +name = "plotstyle" +version = "0.1.0" +description = "KIT corporate-design matplotlib styling toolkit for consistent scientific figures" +readme = "README.md" +requires-python = ">=3.8" +license = {text = "MIT"} +authors = [ + {name = "K. Schmidt"}, +] +keywords = [ + "matplotlib", + "plotting", + "scientific-computing", + "styling", +] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering :: Visualization", +] + +dependencies = [ + "matplotlib>=3.7", +] diff --git a/plotstyle/src/plotstyle/__init__.py b/plotstyle/src/plotstyle/__init__.py new file mode 100644 index 0000000..9e040b9 --- /dev/null +++ b/plotstyle/src/plotstyle/__init__.py @@ -0,0 +1,31 @@ +"""Reusable matplotlib styling and building blocks for consistent, modern +scientific plots across presentations and thesis figures. + + import plotstyle as ps + + ps.use() + fig, ax = ps.new_figure("thesis-single") + ax.plot(x, y, label="A") + ps.style_legend(ax) + ps.savefig(fig, "plots/my_plot", formats=("pdf", "png")) +""" + +from . import colors +from .annotations import panel_label, style_legend +from .colors import get_color +from .figures import FIGSIZES, colorbar, new_figure, no_spines, savefig +from .style import reset, use + +__all__ = [ + "colors", + "get_color", + "use", + "reset", + "new_figure", + "colorbar", + "no_spines", + "savefig", + "FIGSIZES", + "style_legend", + "panel_label", +] diff --git a/plotstyle/src/plotstyle/annotations.py b/plotstyle/src/plotstyle/annotations.py new file mode 100644 index 0000000..34fc31e --- /dev/null +++ b/plotstyle/src/plotstyle/annotations.py @@ -0,0 +1,101 @@ +"""Legend and panel-label helpers for consistent multi-panel figures.""" + +from __future__ import annotations + +import warnings +from typing import Optional + +from matplotlib.axes import Axes +from matplotlib.colors import to_rgba + +from .colors import INK + +_PANEL_LOCS = { + "upper left": (0.02, 0.98, "left", "top"), + "upper right": (0.98, 0.98, "right", "top"), + "lower left": (0.02, 0.08, "left", "bottom"), + "lower right": (0.98, 0.08, "right", "bottom"), +} + + +def style_legend( + ax: Axes, + loc: str = "outside right upper", + frameon: bool = False, + title: Optional[str] = None, + **kwargs, +): + """Add a figure-level legend, placed outside the axes by default. + + Builds on `ax`'s handles/labels (or explicit `handles=`/`labels=` kwargs) + but attaches the legend to `ax`'s figure via `fig.legend(...)`, so it sits + outside the plot area rather than overlapping the data. + + A `title` is strongly encouraged: an untitled legend floating outside the + axes loses its visual link to what it's describing, e.g. + `style_legend(ax, title="Series")`. Without one, this emits a warning + rather than failing — the legend still renders. + """ + if title is None: + warnings.warn( + "style_legend() called without a title — an outside legend reads better with one, " + "e.g. style_legend(ax, title='Series').", + stacklevel=2, + ) + + fig = ax.get_figure() + assert fig is not None, "ax must be attached to a figure" + handles = kwargs.pop("handles", None) + labels = kwargs.pop("labels", None) + if handles is None or labels is None: + handles, labels = ax.get_legend_handles_labels() + + # matplotlib-stubs' `loc` Literal doesn't include the "outside ..." compound + # locations matplotlib actually supports at runtime (e.g. "outside right upper"). + legend = fig.legend(handles, labels, loc=loc, frameon=frameon, title=title, **kwargs) # ty: ignore[invalid-argument-type] + if legend.get_title() is not None: + legend.get_title().set_fontweight("bold") + return legend + + +def panel_label( + ax: Axes, + label: str, + loc: str = "lower right", + fontweight: str = "bold", + box: bool = True, + **kwargs, +): + """Add a panel label like "(a)" for multi-panel thesis/paper figures. + + Defaults to the bottom-right corner, colored to match the axes' xlabel, + on a light-grey semi-transparent rounded box with a slim solid border. + Pass `box=False` for bare text with no box. + """ + try: + x, y, ha, va = _PANEL_LOCS[loc] + except KeyError as exc: + raise ValueError(f"Unknown panel_label loc {loc!r}. Choose from {sorted(_PANEL_LOCS)}.") from exc + + kwargs.setdefault("color", ax.xaxis.label.get_color()) + if box: + kwargs.setdefault( + "bbox", + dict( + boxstyle="round,pad=0.3", + facecolor=to_rgba(INK["gridline"], alpha=0.8), + edgecolor=INK["baseline"], + linewidth=0.8, + ), + ) + + return ax.text( + x, + y, + f"({label})", + transform=ax.transAxes, + ha=ha, + va=va, + fontweight=fontweight, + **kwargs, + ) diff --git a/plotstyle/src/plotstyle/assets/plotstyle.mplstyle b/plotstyle/src/plotstyle/assets/plotstyle.mplstyle new file mode 100644 index 0000000..e729542 --- /dev/null +++ b/plotstyle/src/plotstyle/assets/plotstyle.mplstyle @@ -0,0 +1,80 @@ +# Base rcParams for plotstyle. Loaded via plt.style.use() from style.use(). +# Colors here mirror plotstyle.colors.INK (KIT black-70% gray family on white) — kept in sync by hand. + +figure.facecolor: ffffff +figure.edgecolor: ffffff +figure.constrained_layout.use: True + +axes.facecolor: ffffff +# axes.edgecolor/linewidth style the one visible spine (bottom — the rest are +# off below), so this is really "the bottom spine is black and heavier", not +# a general axes outline color. +axes.edgecolor: 000000 +axes.linewidth: 1.25 +axes.labelcolor: 6a6a6a +axes.titlecolor: 404040 +axes.titleweight: bold +axes.titlelocation: left +axes.grid: True +axes.grid.axis: y +axes.axisbelow: True +axes.spines.top: False +axes.spines.right: False +axes.spines.left: False +axes.spines.bottom: True + +grid.color: ececec +grid.linewidth: 0.8 +grid.alpha: 1.0 + +xtick.color: 969696 +ytick.color: 969696 +# Major tick labels read as the primary ("black") ink; minor tick labels are +# muted grey. rcParams only expose one labelcolor per axis (no major/minor +# split) — the per-major/minor distinction is applied in code by +# plotstyle.figures.new_figure() via ax.tick_params(which=...). These values +# are just the fallback/default for axes that bypass new_figure(). +xtick.labelcolor: 404040 +ytick.labelcolor: 404040 +xtick.direction: out +ytick.direction: out +xtick.bottom: True +xtick.top: False +ytick.left: True +ytick.right: False +# Minor ticks: x-axis only. The y-axis already has horizontal gridlines at +# major ticks, so y minor ticks would just add unlabeled clutter. +xtick.minor.visible: True +ytick.minor.visible: False +xtick.major.size: 6.0 +xtick.minor.size: 3.0 +xtick.major.width: 0.8 +xtick.minor.width: 0.6 +ytick.major.size: 6.0 +ytick.minor.size: 3.0 +ytick.major.width: 0.8 +ytick.minor.width: 0.6 + +lines.linewidth: 2.0 +lines.markersize: 6.0 +lines.solid_capstyle: round + +font.family: sans-serif +font.sans-serif: DejaVu Sans, Arial, Helvetica, sans-serif +font.size: 11 +axes.titlesize: 13 +axes.labelsize: 11 +xtick.labelsize: 10 +ytick.labelsize: 10 +legend.fontsize: 10 + +legend.frameon: False +legend.handlelength: 1.6 +legend.labelspacing: 0.4 +legend.title_fontsize: 10 + +savefig.facecolor: ffffff +savefig.edgecolor: ffffff +savefig.dpi: 300 +savefig.bbox: tight +savefig.pad_inches: 0.05 diff --git a/plotstyle/src/plotstyle/colors.py b/plotstyle/src/plotstyle/colors.py new file mode 100644 index 0000000..addf3cb --- /dev/null +++ b/plotstyle/src/plotstyle/colors.py @@ -0,0 +1,102 @@ +"""KIT (Karlsruhe Institute of Technology) corporate design color palette. + +Hex values for KIT green, KIT blue, black 70%, and the corporate accent +colors are taken verbatim from the KIT corporate design guide +(https://kit-cd.km.kit.edu/english/341.php) — do not hand-edit them without +checking that page. + +The categorical *order* below is not arbitrary: it was chosen by running +every hue through the CVD-safety/contrast checks described in the `dataviz` +skill (fixed hue order, OKLab CVD separation under simulated color-vision +deficiency, a normal-vision separation floor, contrast vs. a white surface) +and keeping the ordering that clears the adjacent-pair checks. KIT yellow +(#FCE500) is the one hue that cannot pass on its own (too light on a white +surface, ~1.3:1 contrast) — that is a property of the hex value itself, not +the ordering, so it is placed last and should always be paired with a +visible direct label rather than relied on as a fill alone. +""" + +from __future__ import annotations + +from matplotlib.colors import LinearSegmentedColormap + +# Fixed-order categorical hues (KIT primary + accent colors). Order is the +# CVD-safety mechanism: never reorder, and never cycle past the last slot +# (fold extra series into "Other"). +CATEGORICAL = [ + "#009682", # 0 KIT green (primary) + "#DF9B1B", # 1 orange + "#4664AA", # 2 KIT blue (primary) + "#A78230", # 3 brown + "#23A1E0", # 4 cyan + "#A3107C", # 5 purple + "#8CB63C", # 6 pea green + "#A22223", # 7 red + "#FCE500", # 8 yellow — low contrast on white; always pair with a direct label +] + +# Single-hue (KIT blue) sequential ramp, steps 100..700. Step 700 is the exact +# brand hex (the high/saturated end); lighter steps are tints blended toward +# white in sRGB — there is no darker-than-brand shade. +SEQUENTIAL_STEPS = [ + "#e3e8f2", # 100 + "#c9d2e6", # 200 + "#afbcda", # 300 + "#95a6ce", # 400 + "#7a90c2", # 500 + "#607ab6", # 600 + "#4664AA", # 700 (KIT blue) +] + +# Diverging KIT blue <-> KIT red, neutral gray midpoint. +DIVERGING = { + "low": "#4664AA", + "mid": "#f7f7f7", + "high": "#A22223", +} + +# Fixed, reserved status scale — deliberately NOT re-themed to KIT colors: +# status is a small fixed scale with reserved meaning that must stay visually +# distinct from the categorical slots so it never impersonates a series. +# Never put these in the categorical cycle; always pair with an icon/label. +STATUS = { + "good": "#0ca30c", + "warning": "#fab219", + "serious": "#ec835a", + "critical": "#d03b3b", +} + +# Chrome / ink roles, derived from KIT's specified "black 70%" (#404040, +# used by KIT for headings and continuous text) on a white surface. +INK = { + "surface": "#ffffff", + "primary": "#404040", # KIT black 70% — headings, titles, continuous text + "secondary": "#6a6a6a", + "muted": "#969696", + "gridline": "#ececec", + "baseline": "#c2c2c2", +} + + +def get_color(index: int) -> str: + """Return the categorical color for series `index` (0-based). + + Raises ValueError past the validated slots instead of silently wrapping + back to slot 0, which would collide two series on the same hue. + """ + if not 0 <= index < len(CATEGORICAL): + raise ValueError( + f"get_color({index}) out of range: only {len(CATEGORICAL)} validated categorical " + "colors exist. Fold extra series into an 'Other' bucket or facet instead of cycling." + ) + return CATEGORICAL[index] + + +def sequential_cmap(name: str = "ps_sequential") -> LinearSegmentedColormap: + """Continuous KIT-blue sequential colormap for magnitude encoding.""" + return LinearSegmentedColormap.from_list(name, SEQUENTIAL_STEPS) + + +def diverging_cmap(name: str = "ps_diverging") -> LinearSegmentedColormap: + """Continuous KIT blue-gray-red diverging colormap for polarity encoding.""" + return LinearSegmentedColormap.from_list(name, [DIVERGING["low"], DIVERGING["mid"], DIVERGING["high"]]) diff --git a/plotstyle/src/plotstyle/figures.py b/plotstyle/src/plotstyle/figures.py new file mode 100644 index 0000000..894cd53 --- /dev/null +++ b/plotstyle/src/plotstyle/figures.py @@ -0,0 +1,143 @@ +"""Figure creation, colorbar, and saving helpers.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Mapping, Sequence, Union + +import matplotlib.pyplot as plt +import numpy as np +from matplotlib.axes import Axes +from matplotlib.colorbar import Colorbar +from matplotlib.figure import Figure +from mpl_toolkits.axes_grid1 import make_axes_locatable + +from .colors import INK + +FIGSIZES = { + "thesis-single": (6.0, 4.0), + "thesis-wide": (8.0, 4.5), + "slide-16x9": (10.0, 5.625), + "square": (5.0, 5.0), +} + + +def _style_ticks(ax: Axes) -> None: + """Major tick labels read as primary ("black") ink; minor as muted grey. + + rcParams only expose a single labelcolor per axis (no major/minor split), + so this distinction has to be applied per-Axes in code. + """ + ax.tick_params(axis="both", which="major", labelcolor=INK["primary"]) + ax.tick_params(axis="both", which="minor", labelcolor=INK["muted"]) + + +def _format_params(params: Mapping) -> str: + return " | ".join(f"{key}: {value}" for key, value in params.items()) + + +def _set_figure_title(fig: Figure, title: Union[str, None], params: Union[Mapping, None]) -> None: + # A single Text artist gets one color under matplotlib's usetex rendering + # (dvipng rasterizes it as one greyscale mask, tinted uniformly — any + # in-source \color/\textcolor is ignored), so the subtitle is set apart + # from the title by size (\small) only, not color. + lines = [] + if title is not None: + lines.append(r"\textbf{" + title + "}") + if params: + lines.append(r"{\small " + _format_params(params) + "}") + if lines: + fig.suptitle("\n".join(lines), x=0.0, ha="left") + + +def new_figure( + preset: Union[str, tuple] = "thesis-single", + *, + title: Union[str, None] = None, + params: Union[Mapping, None] = None, + **subplots_kwargs, +): + """Create a figure/axes pair sized for a named preset or an explicit (w, h) tuple. + + Presets (inches): thesis-single, thesis-wide, slide-16x9, square. + + `title` sets a left-aligned, bold figure-level title (`fig.suptitle`) — + this is preferred over an axes title even when there's a single axes, so + it stays consistent for single- and multi-panel figures alike. `params` + is an optional dict rendered as a smaller, muted subtitle line below the + title, formatted as "key1: value1 | key2: value2 | ...". + """ + if isinstance(preset, str): + try: + figsize = FIGSIZES[preset] + except KeyError as exc: + raise ValueError( + f"Unknown figure preset {preset!r}. Choose from {sorted(FIGSIZES)} or pass an (w, h) tuple." + ) from exc + else: + figsize = preset + + subplots_kwargs.setdefault("figsize", figsize) + fig, axes = plt.subplots(**subplots_kwargs) + + for ax in [axes] if isinstance(axes, Axes) else np.ravel(axes): + _style_ticks(ax) + + _set_figure_title(fig, title, params) + + return fig, axes + + +def no_spines(ax: Union[Axes, np.ndarray]) -> None: + """Hide every spine on `ax` — pass a single Axes or an array of them. + + `use()` keeps only the bottom spine visible, since most plots have a + meaningful x baseline. Pixel/bin-indexed plots (`imshow`, `pcolormesh`, + 2D histograms) don't — there's no "zero" the bottom spine anchors to — + so call this on their Axes instead of leaving the themed bottom spine on + or hand-rolling `ax.spines[...].set_visible(False)`. + """ + for single_ax in [ax] if isinstance(ax, Axes) else np.ravel(ax): + for spine in single_ax.spines.values(): + spine.set_visible(False) + + +def colorbar(mappable, ax: Axes, size: str = "5%", pad: float = 0.05, **kwargs) -> Colorbar: + """Add a colorbar matched to `ax`'s actual on-screen size. + + `fig.colorbar(mappable, ax=ax)` sizes the colorbar to the axes' nominal + bounding box, which is taller than the axes once things like + `ax.set_aspect("equal")` have visually shrunk it (e.g. a non-square + `imshow`). This appends a same-size axes via `make_axes_locatable` + instead, so the colorbar always matches what's actually drawn. + """ + divider = make_axes_locatable(ax) + cax = divider.append_axes("right", size=size, pad=pad) + fig = ax.get_figure() + assert fig is not None, "ax must be attached to a figure" + cb = fig.colorbar(mappable, cax=cax, **kwargs) + # Colorbar draws its own border (a dedicated "outline" spine) that isn't + # covered by axes.spines.{left,right,top} — without this it'd pick up + # the bold black bottom-spine color/width from the main theme as a box + # around the whole colorbar, which reads as a stray, heavier-than-intended + # edge rather than the plain baseline it's styled to be elsewhere. + cb.outline.set_visible(False) + return cb + + +def savefig(fig: Figure, path: Union[str, Path], formats: Sequence[str] = ("pdf",), dpi: int = 300) -> list[Path]: + """Save `fig` to `path` once per format, creating parent directories as needed. + + `path` should have no extension — it's appended per format, e.g. + savefig(fig, "plots/my_plot", formats=("pdf", "png")) writes + plots/my_plot.pdf and plots/my_plot.png. + """ + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + + written = [] + for fmt in formats: + out_path = path.with_suffix(f".{fmt}") + fig.savefig(out_path, format=fmt, dpi=dpi) + written.append(out_path) + return written diff --git a/plotstyle/src/plotstyle/style.py b/plotstyle/src/plotstyle/style.py new file mode 100644 index 0000000..c990d89 --- /dev/null +++ b/plotstyle/src/plotstyle/style.py @@ -0,0 +1,64 @@ +"""Apply the plotstyle rcParams theme. + +Text (titles, axis labels, legends, tick labels, annotations — the entirety +of every string) is always rendered through a real LaTeX toolchain, using +Latin Modern Sans as a modern sans-serif LaTeX font (including math mode, via +`sfmath` — otherwise tick numbers fall back to a serif math font even with +`\\familydefault` set to sans). `fontenc`'s T1 encoding is loaded too — without +it, some plain ASCII characters (e.g. "|") render as the wrong glyph under +OT1, LaTeX's default. This requires a working local `latex`/`dvipng` install; +there is no mathtext fallback. + +Note: matplotlib's usetex rendering rasterizes each Text artist as a single +greyscale glyph mask via dvipng and then tints the *whole* thing with that +artist's one `color` — any in-source `\\color`/`\\textcolor` command is +ignored. So two differently-colored spans (e.g. a black title next to a grey +subtitle) can't live in one Text object; `figures.new_figure()`'s title/params +handling only varies font size (`\\small`) between lines, not color, for +exactly this reason. +""" + +from __future__ import annotations + +from importlib import resources + +import matplotlib.pyplot as plt +from cycler import cycler + +from .colors import CATEGORICAL + +_LINESTYLES = ["-", "--", "-.", ":"] + +_LATEX_PREAMBLE = ( + r"\usepackage[T1]{fontenc}\usepackage{amsmath}\usepackage{lmodern}\usepackage{sfmath}" + r"\renewcommand{\familydefault}{\sfdefault}" +) + + +def use(cycle_linestyles: bool = False) -> None: + """Apply the plotstyle theme to matplotlib's global rcParams. + + Call once at the top of a plotting script, before creating any figures. + + By default `axes.prop_cycle` only cycles color (all lines solid) — pass + `cycle_linestyles=True` to also cycle through a repeating linestyle + sequence, so series stay distinguishable even if color is lost + (grayscale printing, projector glare, color-vision deficiency). + """ + style_path = resources.files("plotstyle").joinpath("assets").joinpath("plotstyle.mplstyle") + plt.style.use(str(style_path)) + + if cycle_linestyles: + n = len(CATEGORICAL) + linestyles = (_LINESTYLES * (n // len(_LINESTYLES) + 1))[:n] + plt.rcParams["axes.prop_cycle"] = cycler(color=CATEGORICAL) + cycler(linestyle=linestyles) + else: + plt.rcParams["axes.prop_cycle"] = cycler(color=CATEGORICAL) + + plt.rcParams["text.usetex"] = True + plt.rcParams["text.latex.preamble"] = _LATEX_PREAMBLE + + +def reset() -> None: + """Restore matplotlib defaults (useful between tests/notebook cells).""" + plt.rcdefaults() diff --git a/pyproject.toml b/pyproject.toml index a621d53..757e0ca 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [build-system] -requires = ["setuptools>=65.0", "wheel"] -build-backend = "setuptools.build_meta" +requires = ["uv_build>=0.11.19,<0.12.0"] +build-backend = "uv_build" [project] name = "gallery" @@ -43,30 +43,26 @@ dependencies = [ "textual>=0.50", ] -[project.optional-dependencies] -dev = [ - "pytest>=7.0", - "black>=22.0", - "pylint>=2.0", - "mypy>=0.900", -] - [project.scripts] gallery = "gallery.cli:main" -[tool.setuptools] -packages = ["gallery", "gallery.utils", "gallery.config"] -package-data = {gallery = ["templates/*", "assets/css/*", "assets/js/*", "config/*"]} -include-package-data = true +[dependency-groups] +dev = [ + "pytest>=7.0", + "ruff>=0.6", + "ty>=0.0.1", + "pip-audit>=2.7", +] -[tool.black] +[tool.uv.workspace] +members = ["plotstyle"] + +[tool.uv.build-backend] +module-root = "" + +[tool.ruff] line-length = 120 -target-version = ['py38'] +target-version = "py38" -[tool.isort] -profile = "black" -line_length = 120 - -[tool.flake8] -max-line-length = 120 -extend-ignore = ["E203", "W503"] +[tool.ruff.lint] +select = ["E", "F", "I"] diff --git a/tests/__init__.py b/tests/__init__.py index 2889ef3..4646851 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,4 +1,3 @@ import sys - sys.path.append("..") diff --git a/tests/test_backup.py b/tests/test_backup.py deleted file mode 100644 index 635bed4..0000000 --- a/tests/test_backup.py +++ /dev/null @@ -1,214 +0,0 @@ -import zipfile -import datetime -from unittest.mock import patch -from utils import backup - - -def test_backup_creates_zip(tmp_path, monkeypatch): - # Setup fake web folder - web_folder = tmp_path / 'plots' - web_folder.mkdir() - (web_folder / 'file1.txt').write_text('abc') - (web_folder / 'file2.txt').write_text('def') - backup_folder = tmp_path / 'backups' - backup_folder.mkdir() - - # Patch the module variables - monkeypatch.setattr(backup, 'WEB_FOLDER', web_folder) - monkeypatch.setattr(backup, 'BACKUP_FOLDER', backup_folder) - - # Call the backup function - backup.create_backup() - - # Check that backup was created - today = datetime.date.today().strftime('%Y%m%d') - backup_name = f'backup-{today}.zip' - backup_path = backup_folder / backup_name - - assert backup_path.exists() - with zipfile.ZipFile(backup_path, 'r') as z: - names = z.namelist() - assert any('file1.txt' in n for n in names) - assert any('file2.txt' in n for n in names) - - # Cleanup: remove the backup file after test - backup_path.unlink() - - -def test_backup_with_subdirectories(tmp_path, monkeypatch): - # Setup fake web folder with subdirectories - web_folder = tmp_path / 'plots' - web_folder.mkdir() - (web_folder / 'file1.txt').write_text('content1') - - subdir = web_folder / 'subdir' - subdir.mkdir() - (subdir / 'file2.txt').write_text('content2') - - nested_subdir = subdir / 'nested' - nested_subdir.mkdir() - (nested_subdir / 'file3.txt').write_text('content3') - - backup_folder = tmp_path / 'backups' - backup_folder.mkdir() - - # Patch the module variables - monkeypatch.setattr(backup, 'WEB_FOLDER', web_folder) - monkeypatch.setattr(backup, 'BACKUP_FOLDER', backup_folder) - - # Call the backup function - backup.create_backup() - - # Check that backup was created with all files - today = datetime.date.today().strftime('%Y%m%d') - backup_name = f'backup-{today}.zip' - backup_path = backup_folder / backup_name - - assert backup_path.exists() - with zipfile.ZipFile(backup_path, 'r') as z: - names = z.namelist() - assert any('file1.txt' in n for n in names) - assert any('file2.txt' in n for n in names) - assert any('file3.txt' in n for n in names) - - # Cleanup - backup_path.unlink() - - -def test_backup_existing_file(tmp_path, monkeypatch, capsys): - # Setup fake web folder - web_folder = tmp_path / 'plots' - web_folder.mkdir() - (web_folder / 'file1.txt').write_text('abc') - - backup_folder = tmp_path / 'backups' - backup_folder.mkdir() - - # Create existing backup file - today = datetime.date.today().strftime('%Y%m%d') - backup_name = f'backup-{today}.zip' - backup_path = backup_folder / backup_name - backup_path.write_text('existing backup') - - # Patch the module variables - monkeypatch.setattr(backup, 'WEB_FOLDER', web_folder) - monkeypatch.setattr(backup, 'BACKUP_FOLDER', backup_folder) - - # Call the backup function - backup.create_backup() - - # Check that message about existing backup was printed - captured = capsys.readouterr() - assert f"Backup already exists: {backup_path}" in captured.out - - # Cleanup - backup_path.unlink() - - -def test_backup_empty_folder(tmp_path, monkeypatch): - # Setup empty web folder - web_folder = tmp_path / 'plots' - web_folder.mkdir() - - backup_folder = tmp_path / 'backups' - backup_folder.mkdir() - - # Patch the module variables - monkeypatch.setattr(backup, 'WEB_FOLDER', web_folder) - monkeypatch.setattr(backup, 'BACKUP_FOLDER', backup_folder) - - # Call the backup function - backup.create_backup() - - # Check that backup was created (empty) - today = datetime.date.today().strftime('%Y%m%d') - backup_name = f'backup-{today}.zip' - backup_path = backup_folder / backup_name - - assert backup_path.exists() - with zipfile.ZipFile(backup_path, 'r') as z: - assert len(z.namelist()) == 0 - - # Cleanup - backup_path.unlink() - - -def test_backup_nonexistent_web_folder(tmp_path, monkeypatch): - # Setup nonexistent web folder - web_folder = tmp_path / 'nonexistent_plots' - backup_folder = tmp_path / 'backups' - backup_folder.mkdir() - - # Patch the module variables - monkeypatch.setattr(backup, 'WEB_FOLDER', web_folder) - monkeypatch.setattr(backup, 'BACKUP_FOLDER', backup_folder) - - # Call the backup function - backup.create_backup() - - # Check that backup was created (empty since source doesn't exist) - today = datetime.date.today().strftime('%Y%m%d') - backup_name = f'backup-{today}.zip' - backup_path = backup_folder / backup_name - - assert backup_path.exists() - with zipfile.ZipFile(backup_path, 'r') as z: - assert len(z.namelist()) == 0 - - # Cleanup - backup_path.unlink() - - -@patch('datetime.date') -def test_backup_with_custom_date(mock_date, tmp_path, monkeypatch): - # Mock date to return a specific date - mock_date.today.return_value.strftime.return_value = "20230908" - - # Setup fake web folder - web_folder = tmp_path / 'plots' - web_folder.mkdir() - (web_folder / 'file1.txt').write_text('test') - - backup_folder = tmp_path / 'backups' - backup_folder.mkdir() - - # Patch the module variables - monkeypatch.setattr(backup, 'WEB_FOLDER', web_folder) - monkeypatch.setattr(backup, 'BACKUP_FOLDER', backup_folder) - - # Call the backup function - backup.create_backup() - - # Check that backup was created with custom date - backup_path = backup_folder / "backup-20230908.zip" - assert backup_path.exists() - - # Cleanup - backup_path.unlink() - - -def test_backup_folder_creation(tmp_path, monkeypatch): - # Setup fake web folder - web_folder = tmp_path / 'plots' - web_folder.mkdir() - (web_folder / 'file1.txt').write_text('test') - - # Don't create backup folder - let function create it - backup_folder = tmp_path / 'new_backups' - - # Patch the module variables - monkeypatch.setattr(backup, 'WEB_FOLDER', web_folder) - monkeypatch.setattr(backup, 'BACKUP_FOLDER', backup_folder) - - # Call the backup function - backup.create_backup() - - # Check that backup folder was created - assert backup_folder.exists() - assert backup_folder.is_dir() - - # Check that backup file was created - today = datetime.date.today().strftime('%Y%m%d') - backup_name = f'backup-{today}.zip' - backup_path = backup_folder / backup_name - assert backup_path.exists() \ No newline at end of file diff --git a/tests/test_config.py b/tests/test_config.py index e8df5ea..71b33b9 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -1,195 +1,183 @@ from pathlib import Path -import tempfile + import pytest import yaml -from utils import config + +from gallery.config import ConfigManager, GalleryConfig, GalleryDefaults, GallerySource -def test_path_config(): - pc = config.PathConfig(work_dir='/tmp', web_folder='/web') - assert pc.work_dir == '/tmp' - assert pc.web_folder == '/web' +def test_gallery_source_path_conversion(): + source = GallerySource(name="test", path="/test/path") + assert source.name == "test" + assert source.path == Path("/test/path") -def test_gallery_config(): - gc = config.GalleryConfig( - plot_root='plots', png_dpi=150, backup_folder='backups') - assert gc.plot_root == 'plots' - assert gc.png_dpi == 150 - assert gc.backup_folder == 'backups' +def test_gallery_defaults(): + defaults = GalleryDefaults() + assert defaults.png_dpi == 400 + assert defaults.plot_root == "gallery" + assert defaults.cache_enabled is True + assert defaults.inherit_from_parent is True -def test_ui_config(): - ui = config.UIConfig(max_recent_plots=10, search_debounce_ms=200) - assert ui.max_recent_plots == 10 - assert ui.search_debounce_ms == 200 +def test_gallery_config_defaults(): + cfg = GalleryConfig(web_folder="/web") + assert cfg.web_folder == Path("/web") + assert cfg.sources == [] + assert cfg.png_dpi == GalleryDefaults.png_dpi + assert cfg.plot_root == GalleryDefaults.plot_root + assert cfg.cache_enabled == GalleryDefaults.cache_enabled + assert cfg.inherit_from_parent == GalleryDefaults.inherit_from_parent -def test_metadata_config_defaults(): - mc = config.MetadataConfig() - assert mc.cache_enabled is True - assert mc.inherit_from_parent is True - assert mc.supported_formats == ['.yaml', '.yml', '.json'] +def test_gallery_config_sources_from_dicts(): + cfg = GalleryConfig(web_folder="/web", sources=[{"name": "s1", "path": "/p1"}]) + assert len(cfg.sources) == 1 + assert isinstance(cfg.sources[0], GallerySource) + assert cfg.sources[0].name == "s1" + assert cfg.sources[0].path == Path("/p1") -def test_metadata_config_custom(): - mc = config.MetadataConfig( - cache_enabled=False, - inherit_from_parent=False, - supported_formats=['.yaml'] - ) - assert mc.cache_enabled is False - assert mc.inherit_from_parent is False - assert mc.supported_formats == ['.yaml'] +def test_gallery_config_sources_invalid_type(): + with pytest.raises(TypeError): + GalleryConfig(web_folder="/web", sources=[123]) -def test_gallery_item(): - item = config.GalleryItem(name="test", path=Path("/test/path")) - assert item.name == "test" - assert item.path == Path("/test/path") +def test_gallery_config_from_yaml(tmp_path): + yaml_content = { + "paths": {"web_folder": "/test/web"}, + "gallery": {"plot_root": "test_plots", "png_dpi": 200}, + "metadata": {"cache_enabled": False, "inherit_from_parent": False}, + "sources": [ + {"name": "source1", "path": "/path1"}, + {"name": "source2", "path": "/path2"}, + ], + } + + yaml_file = tmp_path / "test_config.yaml" + with yaml_file.open("w") as f: + yaml.dump(yaml_content, f) + + cfg = GalleryConfig.from_yaml(yaml_file) + + assert cfg.web_folder == Path("/test/web") + assert cfg.plot_root == "test_plots" + assert cfg.png_dpi == 200 + assert cfg.cache_enabled is False + assert cfg.inherit_from_parent is False + assert len(cfg.sources) == 2 + assert cfg.sources[0].name == "source1" + assert cfg.sources[0].path == Path("/path1") -def test_config_creation(): - paths = config.PathConfig(work_dir="/work", web_folder="/web") - gallery = config.GalleryConfig( - plot_root="plots", png_dpi=300, backup_folder="backups") - ui = config.UIConfig(max_recent_plots=5, search_debounce_ms=100) - metadata = config.MetadataConfig() +def test_gallery_config_from_yaml_missing_file(): + with pytest.raises(FileNotFoundError): + GalleryConfig.from_yaml("/nonexistent/file.yaml") - cfg = config.Config( - paths=paths, - gallery=gallery, - ui=ui, - metadata=metadata - ) - assert cfg.paths == paths - assert cfg.gallery == gallery - assert cfg.ui == ui - assert cfg.metadata == metadata +def test_gallery_config_from_yaml_missing_web_folder(tmp_path): + yaml_file = tmp_path / "no_web_folder.yaml" + yaml_file.write_text(yaml.dump({"gallery": {"plot_root": "plots"}})) + + with pytest.raises(ValueError): + GalleryConfig.from_yaml(yaml_file) + + +def test_gallery_config_from_yaml_partial_data(tmp_path): + yaml_content = {"paths": {"web_folder": "/min_web"}} + + yaml_file = tmp_path / "minimal_config.yaml" + yaml_file.write_text(yaml.dump(yaml_content)) + + cfg = GalleryConfig.from_yaml(yaml_file) + + assert cfg.web_folder == Path("/min_web") + assert cfg.png_dpi == GalleryDefaults.png_dpi + assert cfg.plot_root == GalleryDefaults.plot_root + assert cfg.cache_enabled is True assert cfg.sources == [] -def test_config_backward_compatibility_properties(): - paths = config.PathConfig(work_dir="/work", web_folder="/web") - gallery = config.GalleryConfig( - plot_root="plots", png_dpi=300, backup_folder="backups") - ui = config.UIConfig(max_recent_plots=5, search_debounce_ms=100) - metadata = config.MetadataConfig() - - cfg = config.Config( - paths=paths, - gallery=gallery, - ui=ui, - metadata=metadata +def test_gallery_config_to_yaml_round_trip(tmp_path): + cfg = GalleryConfig( + web_folder="/web", + sources=[{"name": "test", "path": "/test"}], + plot_root="plots", + png_dpi=300, ) - assert cfg.web_folder == "/web" - assert cfg.png_dpi == 300 - assert cfg.plot_root == "plots" - assert cfg.backup_folder == "backups" - - -def test_config_from_yaml(tmp_path): - yaml_content = { - 'paths': { - 'work_dir': '/test/work', - 'web_folder': '/test/web' - }, - 'gallery': { - 'plot_root': 'test_plots', - 'png_dpi': 200, - 'backup_folder': 'test_backups' - }, - 'ui': { - 'max_recent_plots': 15, - 'search_debounce_ms': 300 - }, - 'metadata': { - 'cache_enabled': False, - 'inherit_from_parent': False - }, - 'sources': [ - {'name': 'source1', 'path': '/path1'}, - {'name': 'source2', 'path': '/path2'} - ] - } - - yaml_file = tmp_path / 'test_config.yaml' - with yaml_file.open('w') as f: - yaml.dump(yaml_content, f) - - cfg = config.Config.from_yaml(str(yaml_file)) - - assert cfg.paths.work_dir == '/test/work' - assert cfg.paths.web_folder == '/test/web' - assert cfg.gallery.plot_root == 'test_plots' - assert cfg.gallery.png_dpi == 200 - assert cfg.ui.max_recent_plots == 15 - assert cfg.metadata.cache_enabled is False - assert len(cfg.sources) == 2 - assert cfg.sources[0].name == 'source1' - assert cfg.sources[0].path == Path('/path1') - - -def test_config_from_yaml_missing_file(): - with pytest.raises(FileNotFoundError): - config.Config.from_yaml('/nonexistent/file.yaml') - - -def test_config_from_yaml_malformed(): - with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', - delete=False) as f: - f.write('invalid: yaml: content: [') - f.flush() - - with pytest.raises(yaml.YAMLError): - config.Config.from_yaml(f.name) - - -def test_config_to_yaml(tmp_path): - paths = config.PathConfig(work_dir="/work", web_folder="/web") - gallery = config.GalleryConfig( - plot_root="plots", png_dpi=300, backup_folder="backups") - ui = config.UIConfig(max_recent_plots=5, search_debounce_ms=100) - metadata = config.MetadataConfig() - sources = [config.GalleryItem(name="test", path=Path("/test"))] - - cfg = config.Config( - paths=paths, - gallery=gallery, - ui=ui, - metadata=metadata, - sources=sources - ) - - yaml_file = tmp_path / 'output_config.yaml' - cfg.to_yaml(str(yaml_file)) + yaml_file = tmp_path / "output_config.yaml" + cfg.to_yaml(yaml_file) assert yaml_file.exists() - # Just verify the file contains expected content (no Path parsing) - content = yaml_file.read_text() - assert 'work_dir: /work' in content - assert 'png_dpi: 300' in content - assert 'name: test' in content + reloaded = GalleryConfig.from_yaml(yaml_file) + assert reloaded.web_folder == cfg.web_folder + assert reloaded.plot_root == cfg.plot_root + assert reloaded.png_dpi == cfg.png_dpi + assert reloaded.sources[0].name == "test" -def test_config_from_yaml_partial_data(tmp_path): - # Test with minimal YAML data - yaml_content = { - 'paths': {'work_dir': '/min', 'web_folder': '/min_web'}, - 'gallery': {'plot_root': 'min_plots', 'png_dpi': 100, - 'backup_folder': 'min_backup'}, - 'ui': {'max_recent_plots': 3, 'search_debounce_ms': 50} - } +# --------------------------------------------------------------------------- +# ConfigManager +# --------------------------------------------------------------------------- - yaml_file = tmp_path / 'minimal_config.yaml' - with yaml_file.open('w') as f: - yaml.dump(yaml_content, f) - cfg = config.Config.from_yaml(str(yaml_file)) +@pytest.fixture +def config_manager(tmp_path): + path = tmp_path / "config.yaml" + path.write_text( + yaml.dump( + { + "paths": {"web_folder": "/web"}, + "gallery": {"plot_root": "gallery", "png_dpi": 400}, + "sources": [{"name": "existing", "path": "/existing"}], + } + ) + ) + return ConfigManager(path) - # Should use defaults for metadata and empty sources - assert cfg.metadata.cache_enabled is True # default - assert cfg.sources == [] # default empty list + +def test_config_manager_get(config_manager): + assert config_manager.get("gallery.png_dpi") == 400 + + +def test_config_manager_get_missing_key(config_manager): + with pytest.raises(KeyError): + config_manager.get("gallery.nonexistent") + + +def test_config_manager_set(config_manager): + config_manager.set("gallery.png_dpi", "600") + assert config_manager.get("gallery.png_dpi") == 600 + + +def test_config_manager_list_all(config_manager): + data = config_manager.list_all() + assert data["paths"]["web_folder"] == "/web" + + +def test_config_manager_add_source(config_manager): + config_manager.add_source("new_source", "/new/path") + sources = config_manager.list_sources() + assert {"name": "new_source", "path": "/new/path"} in sources + + +def test_config_manager_add_source_duplicate(config_manager): + with pytest.raises(ValueError): + config_manager.add_source("existing", "/other/path") + + +def test_config_manager_remove_source(config_manager): + config_manager.remove_source("existing") + assert config_manager.list_sources() == [] + + +def test_config_manager_remove_source_not_found(config_manager): + with pytest.raises(KeyError): + config_manager.remove_source("nonexistent") + + +def test_config_manager_list_sources(config_manager): + sources = config_manager.list_sources() + assert sources == [{"name": "existing", "path": "/existing"}] diff --git a/tests/test_container.py b/tests/test_container.py deleted file mode 100644 index de0451d..0000000 --- a/tests/test_container.py +++ /dev/null @@ -1,138 +0,0 @@ -import pytest -import tempfile -import time -import os -from pathlib import Path -import subprocess -import sys - - -def test_python_version(): - """Test that Python 3.9+ is available.""" - version = sys.version_info - assert version.major >= 3 - assert version.minor >= 9 - - -def test_required_modules(): - """Test that required Python modules are installed.""" - try: - import jinja2 # noqa: F401 - import yaml # noqa: F401 - except ImportError as e: - pytest.fail(f"Required module not found: {e}") - - -def test_imagemagick_available(): - """Test that ImageMagick is installed and accessible.""" - try: - result = subprocess.run(['convert', '-version'], capture_output=True, text=True, timeout=10) - assert result.returncode == 0 - assert 'ImageMagick' in result.stdout - except (subprocess.TimeoutExpired, FileNotFoundError): - pytest.fail("ImageMagick not available or not working") - - -def test_format_file_size(): - # Add current directory to path instead of /src - sys.path.insert(0, '.') - from gallery import format_file_size - assert format_file_size(0) == "0 B" - assert format_file_size(1024) == "1.0 KB" - assert format_file_size(1048576) == "1.0 MB" - assert format_file_size(1073741824) == "1.0 GB" - - -def test_needs_update(): - sys.path.insert(0, '.') - from gallery import needs_update - with tempfile.TemporaryDirectory() as temp_dir: - temp_path = Path(temp_dir) - source = temp_path / "source.txt" - target = temp_path / "target.txt" - source.write_text("test") - assert needs_update(source, target) - target.write_text("test") - time.sleep(0.1) - os.utime(target, (time.time(), time.time())) - assert not needs_update(source, target) - - -def test_metadata_loading(): - sys.path.insert(0, '.') - from utils.metadata import load_metadata_file - with tempfile.TemporaryDirectory() as temp_dir: - temp_path = Path(temp_dir) - yaml_file = temp_path / "test.yaml" - yaml_content = "title: Test\nauthor: Container Test\n" - yaml_file.write_text(yaml_content) - metadata = load_metadata_file(yaml_file) - assert metadata['title'] == 'Test' - assert metadata['author'] == 'Container Test' - - -def test_metadata_inheritance(): - sys.path.insert(0, '.') - from utils.metadata import merge_metadata - parent = {'project': 'Test', 'version': '1.0'} - child = {'experiment': 'A', 'version': '1.1'} - merged = merge_metadata(parent, child) - assert merged['project'] == 'Test' - assert merged['experiment'] == 'A' - assert merged['version'] == '1.1' - - -def create_mock_pdf(path: Path): - path.write_text("%PDF-1.4\nMock PDF for testing") - - -def test_pdf_conversion(tmpdir): - sys.path.insert(0, '/src') - from gallery import convert_pdf_to_png, GalleryConfig - with tempfile.TemporaryDirectory() as temp_dir: - temp_path = Path(temp_dir) - pdf_path = temp_path / "test.pdf" - create_mock_pdf(pdf_path) - try: - convert_pdf_to_png(pdf_path, GalleryConfig(tmpdir)) - png_path = pdf_path.with_suffix('.png') - assert png_path.exists() - except subprocess.CalledProcessError: - pytest.skip("Mock PDF not processable by ImageMagick") - - -def create_test_structure(source_dir): - pdf_path = source_dir / "test_plot.pdf" - pdf_path.write_text("%PDF-1.4\nTest plot content") - metadata_path = source_dir / "metadata.yaml" - metadata_path.write_text("title: Container Test\nauthor: CI Pipeline\n") - - -def test_build_gallery(tmpdir): - sys.path.insert(0, '.') - from gallery import build_gallery, GalleryConfig - from unittest.mock import patch - with tempfile.TemporaryDirectory() as temp_dir: - temp_path = Path(temp_dir) - source_dir = temp_path / "source" - web_dir = temp_path / "web" - source_dir.mkdir() - web_dir.mkdir() - create_test_structure(source_dir) - - # Mock the PDF conversion and create the expected PNG file - def mock_convert_pdf_to_png(pdf_path): - png_path = pdf_path.with_suffix('.png') - png_path.write_text("Mock PNG content") - - with patch('gallery.convert_pdf_to_png', side_effect=mock_convert_pdf_to_png): - try: - build_gallery(GalleryConfig(tmpdir), source_dir=source_dir, web_dir=web_dir) - html_file = web_dir / "index.html" - assert html_file.exists() - pdf_file = web_dir / "test_plot.pdf" - assert pdf_file.exists() - png_file = web_dir / "test_plot.png" - assert png_file.exists() - except Exception as e: - pytest.skip(f"Gallery generation failed: {e}") diff --git a/tests/test_generate_gallery.py b/tests/test_generate_gallery.py index 38ec3fc..54a5d42 100644 --- a/tests/test_generate_gallery.py +++ b/tests/test_generate_gallery.py @@ -1,17 +1,17 @@ import os +from datetime import datetime from pathlib import Path -from unittest.mock import patch, MagicMock -import pytest +from unittest.mock import patch + from gallery import ( - convert_pdf_to_png, - needs_update, build_gallery, calculate_directory_stats, - format_file_size, + convert_pdf_to_png, datetime_from_timestamp, - strftime_filter + format_file_size, + needs_update, + strftime_filter, ) -from datetime import datetime def test_format_file_size(): @@ -46,6 +46,7 @@ def test_needs_update_target_newer(tmp_path): # Make target newer by modifying its timestamp import time + time.sleep(0.1) target.touch() @@ -58,9 +59,10 @@ def test_needs_update_source_newer(tmp_path): target.write_text("test") import time + time.sleep(0.1) source.write_text("test") - + # Force different modification times with 31+ second buffer target_time = target.stat().st_mtime source_time = target_time + 40 # 40 seconds newer (> 30 second buffer) @@ -69,28 +71,24 @@ def test_needs_update_source_newer(tmp_path): assert needs_update(source, target) is True -@patch('subprocess.run') -def test_convert_pdf_to_png_success(mock_run, tmp_path): +@patch("gallery.utils.processing._convert_pdf_pymupdf") +def test_convert_pdf_to_png_success(mock_convert, tmp_path): from gallery import GalleryConfig pdf_path = tmp_path / "test.pdf" png_path = tmp_path / "test.png" pdf_path.write_text("fake pdf") - mock_run.return_value = MagicMock(returncode=0) + config = GalleryConfig(tmp_path) + convert_pdf_to_png(pdf_path, config) - convert_pdf_to_png(pdf_path, GalleryConfig(tmp_path)) - - mock_run.assert_called_once() - call_args = mock_run.call_args[0][0] - assert call_args[0] == "convert" - assert str(pdf_path) in call_args - assert str(png_path) in call_args + mock_convert.assert_called_once_with(pdf_path, png_path, config.png_dpi) -@patch('subprocess.run') -def test_convert_pdf_to_png_already_exists_newer(mock_run, tmp_path): +@patch("gallery.utils.processing._convert_pdf_pymupdf") +def test_convert_pdf_to_png_already_exists_newer(mock_convert, tmp_path): from gallery import GalleryConfig + pdf_path = tmp_path / "test.pdf" png_path = tmp_path / "test.png" @@ -104,27 +102,27 @@ def test_convert_pdf_to_png_already_exists_newer(mock_run, tmp_path): convert_pdf_to_png(pdf_path, GalleryConfig(tmp_path)) - # Should not call subprocess since PNG is newer - mock_run.assert_not_called() + # Should not convert since PNG is newer + mock_convert.assert_not_called() -@patch('subprocess.run') -def test_convert_pdf_to_png_pdf_newer(mock_run, tmp_path): +@patch("gallery.utils.processing._convert_pdf_pymupdf") +def test_convert_pdf_to_png_pdf_newer(mock_convert, tmp_path): from gallery import GalleryConfig + pdf_path = tmp_path / "test.pdf" png_path = tmp_path / "test.png" png_path.write_text("fake png") import time + time.sleep(0.1) pdf_path.write_text("fake pdf") - mock_run.return_value = MagicMock(returncode=0) - convert_pdf_to_png(pdf_path, GalleryConfig(tmp_path)) - # Should call subprocess since PDF is newer - mock_run.assert_called_once() + # Should convert since PDF is newer + mock_convert.assert_called_once() def test_calculate_directory_stats_empty(tmp_path): @@ -181,24 +179,17 @@ def test_strftime_filter(): assert formatted == "2023-09-08 14:30" -@patch('gallery.builder.render_gallery_page') -@patch('gallery.utils.metadata.save_metadata_cache') -@patch('gallery.utils.metadata.resolve_metadata_for_plot') -@patch('gallery.utils.metadata.merge_metadata') -@patch('gallery.utils.metadata.load_folder_metadata') -@patch('gallery.utils.processing.convert_pdf_to_png') -@patch('shutil.copy2') +@patch("gallery.builder.save_metadata_cache") +@patch("gallery.utils.processing.resolve_metadata_for_plot") +@patch("gallery.builder.merge_metadata") +@patch("gallery.builder.load_folder_metadata") +@patch("gallery.utils.processing.convert_pdf_to_png") +@patch("shutil.copy2") def test_build_gallery_basic( - mock_copy, - mock_convert, - mock_load_folder, - mock_merge, - mock_resolve, - mock_save_cache, - mock_template, - tmp_path + mock_copy, mock_convert, mock_load_folder, mock_merge, mock_resolve, mock_save_cache, tmp_path ): - from gallery import GalleryConfig + from gallery import GalleryConfig, get_template + source_dir = tmp_path / "source" web_dir = tmp_path / "web" source_dir.mkdir() @@ -214,29 +205,24 @@ def test_build_gallery_basic( mock_load_folder.return_value = {"folder": "metadata"} mock_merge.return_value = {"merged": "metadata"} mock_resolve.return_value = {"plot": "metadata"} - mock_template.render.return_value = "test" - build_gallery(GalleryConfig(tmp_path), source_dir, web_dir) + config = GalleryConfig(tmp_path) + build_gallery(config, source_dir, web_dir, template=get_template()) # Verify mocks were called - mock_convert.assert_called_once_with(pdf_file) + mock_convert.assert_called_once_with(pdf_file, config=config) mock_copy.assert_called() # Should be called for PDF mock_save_cache.assert_called_once() - # Check HTML file was created + # Check HTML file was created by the real render_gallery_page html_file = web_dir / "index.html" assert html_file.exists() -@patch('gallery.builder.render_gallery_page') -@patch('gallery.utils.metadata.save_metadata_cache') -@patch('gallery.utils.metadata.load_folder_metadata') -def test_build_gallery_with_subdirs( - mock_load_folder, - mock_save_cache, - mock_template, - tmp_path -): +@patch("gallery.builder.render_gallery_page") +@patch("gallery.builder.save_metadata_cache") +@patch("gallery.builder.load_folder_metadata") +def test_build_gallery_with_subdirs(mock_load_folder, mock_save_cache, mock_template, tmp_path): source_dir = tmp_path / "source" web_dir = tmp_path / "web" source_dir.mkdir() @@ -248,8 +234,9 @@ def test_build_gallery_with_subdirs( mock_load_folder.return_value = {} mock_template.render.return_value = "test" - + from gallery import GalleryConfig + build_gallery(config=GalleryConfig(tmp_path), source_dir=source_dir, web_dir=web_dir) # Check subdirectory was created in web @@ -258,8 +245,8 @@ def test_build_gallery_with_subdirs( assert web_subdir.is_dir() -@patch('gallery.utils.processing.needs_update') -@patch('shutil.copy2') +@patch("gallery.utils.processing.needs_update") +@patch("shutil.copy2") def test_build_gallery_skip_up_to_date(mock_copy, mock_needs_update, tmp_path): source_dir = tmp_path / "source" web_dir = tmp_path / "web" @@ -282,8 +269,10 @@ def test_build_gallery_skip_up_to_date(mock_copy, mock_needs_update, tmp_path): mock_needs_update.return_value = False from gallery import get_template + get_template() from gallery import GalleryConfig + build_gallery(GalleryConfig(tmp_path), source_dir, web_dir) # copy2 should not be called since files are up to date diff --git a/tests/test_metadata.py b/tests/test_metadata.py index 5dc8a70..8d95515 100644 --- a/tests/test_metadata.py +++ b/tests/test_metadata.py @@ -1,79 +1,81 @@ import json + import pytest -from utils import metadata import yaml +from gallery.utils import metadata + def test_load_metadata_file_yaml(tmp_path): - data = {'a': 1, 'b': 'test'} - yaml_path = tmp_path / 'meta.yaml' + data = {"a": 1, "b": "test"} + yaml_path = tmp_path / "meta.yaml" yaml_path.write_text(yaml.dump(data)) result = metadata.load_metadata_file(yaml_path) assert result == data def test_load_metadata_file_json(tmp_path): - data = {'x': 42, 'y': 'hello'} - json_path = tmp_path / 'meta.json' + data = {"x": 42, "y": "hello"} + json_path = tmp_path / "meta.json" json_path.write_text(json.dumps(data)) result = metadata.load_metadata_file(json_path) assert result == data def test_load_metadata_file_missing(tmp_path): - missing_path = tmp_path / 'nope.yaml' + missing_path = tmp_path / "nope.yaml" result = metadata.load_metadata_file(missing_path) assert result == {} def test_load_metadata_file_yml_extension(tmp_path): - data = {'test': 'yml_format'} - yml_path = tmp_path / 'meta.yml' + data = {"test": "yml_format"} + yml_path = tmp_path / "meta.yml" yml_path.write_text(yaml.dump(data)) result = metadata.load_metadata_file(yml_path) assert result == data def test_load_metadata_file_unknown_format(tmp_path): - txt_path = tmp_path / 'meta.txt' - txt_path.write_text('some text') + txt_path = tmp_path / "meta.txt" + txt_path.write_text("some text") result = metadata.load_metadata_file(txt_path) assert result == {} def test_load_metadata_file_malformed_yaml(tmp_path): - yaml_path = tmp_path / 'bad.yaml' - yaml_path.write_text('invalid: yaml: content: [') + yaml_path = tmp_path / "bad.yaml" + yaml_path.write_text("invalid: yaml: content: [") with pytest.raises(yaml.YAMLError): metadata.load_metadata_file(yaml_path) def test_load_metadata_file_malformed_json(tmp_path): - json_path = tmp_path / 'bad.json' + json_path = tmp_path / "bad.json" json_path.write_text('{"invalid": json}') with pytest.raises(json.JSONDecodeError): metadata.load_metadata_file(json_path) def test_load_folder_metadata_yaml(tmp_path): - data = {'folder': 'metadata'} - metadata_path = tmp_path / 'metadata.yaml' + data = {"folder": "metadata"} + metadata_path = tmp_path / "metadata.yaml" metadata_path.write_text(yaml.dump(data)) result = metadata.load_folder_metadata(tmp_path) assert result == data def test_load_folder_metadata_yml(tmp_path): - data = {'folder': 'metadata_yml'} - metadata_path = tmp_path / 'metadata.yml' + data = {"folder": "metadata_yml"} + metadata_path = tmp_path / "metadata.yml" metadata_path.write_text(yaml.dump(data)) result = metadata.load_folder_metadata(tmp_path) assert result == data def test_load_folder_metadata_json(tmp_path): - data = {'folder': 'metadata_json'} - metadata_path = tmp_path / 'metadata.json' + data = {"folder": "metadata_json"} + metadata_path = tmp_path / "metadata.json" metadata_path.write_text(json.dumps(data)) result = metadata.load_folder_metadata(tmp_path) assert result == data @@ -85,21 +87,21 @@ def test_load_folder_metadata_missing(tmp_path): def test_get_metadata_file_path_existing_yaml(tmp_path): - metadata_path = tmp_path / 'metadata.yaml' - metadata_path.write_text('test: data') + metadata_path = tmp_path / "metadata.yaml" + metadata_path.write_text("test: data") result = metadata.get_metadata_file_path(tmp_path) assert result == str(metadata_path) def test_get_metadata_file_path_existing_yml(tmp_path): - metadata_path = tmp_path / 'metadata.yml' - metadata_path.write_text('test: data') + metadata_path = tmp_path / "metadata.yml" + metadata_path.write_text("test: data") result = metadata.get_metadata_file_path(tmp_path) assert result == str(metadata_path) def test_get_metadata_file_path_existing_json(tmp_path): - metadata_path = tmp_path / 'metadata.json' + metadata_path = tmp_path / "metadata.json" metadata_path.write_text('{"test": "data"}') result = metadata.get_metadata_file_path(tmp_path) assert result == str(metadata_path) @@ -107,28 +109,27 @@ def test_get_metadata_file_path_existing_json(tmp_path): def test_get_metadata_file_path_none_existing(tmp_path): result = metadata.get_metadata_file_path(tmp_path) - expected = str(tmp_path / 'metadata.yaml') + expected = str(tmp_path / "metadata.yaml") assert result == expected def test_merge_metadata(): - parent = {'project': 'Test', 'version': '1.0', 'author': 'Parent'} - child = {'experiment': 'A', 'version': '1.1'} + parent = {"project": "Test", "version": "1.0", "author": "Parent"} + child = {"experiment": "A", "version": "1.1"} merged = metadata.merge_metadata(parent, child) - expected = {'project': 'Test', 'version': '1.1', - 'author': 'Parent', 'experiment': 'A'} + expected = {"project": "Test", "version": "1.1", "author": "Parent", "experiment": "A"} assert merged == expected def test_merge_metadata_empty_parent(): parent = {} - child = {'experiment': 'A', 'version': '1.1'} + child = {"experiment": "A", "version": "1.1"} merged = metadata.merge_metadata(parent, child) assert merged == child def test_merge_metadata_empty_child(): - parent = {'project': 'Test', 'version': '1.0'} + parent = {"project": "Test", "version": "1.0"} child = {} merged = metadata.merge_metadata(parent, child) assert merged == parent @@ -136,35 +137,34 @@ def test_merge_metadata_empty_child(): def test_resolve_metadata_for_plot_with_specific_yaml(tmp_path): # Create plot-specific metadata file - plot_path = tmp_path / 'test_plot.pdf' - plot_metadata_path = tmp_path / 'test_plot.yaml' - plot_metadata = {'specific': 'plot_data', 'override': 'plot_value'} + plot_path = tmp_path / "test_plot.pdf" + plot_metadata_path = tmp_path / "test_plot.yaml" + plot_metadata = {"specific": "plot_data", "override": "plot_value"} plot_metadata_path.write_text(yaml.dump(plot_metadata)) - inherited = {'general': 'data', 'override': 'inherited_value'} + inherited = {"general": "data", "override": "inherited_value"} result = metadata.resolve_metadata_for_plot(plot_path, inherited) - expected = {'general': 'data', - 'override': 'plot_value', 'specific': 'plot_data'} + expected = {"general": "data", "override": "plot_value", "specific": "plot_data"} assert result == expected def test_resolve_metadata_for_plot_with_specific_json(tmp_path): - plot_path = tmp_path / 'test_plot.pdf' - plot_metadata_path = tmp_path / 'test_plot.json' - plot_metadata = {'specific': 'plot_data_json'} + plot_path = tmp_path / "test_plot.pdf" + plot_metadata_path = tmp_path / "test_plot.json" + plot_metadata = {"specific": "plot_data_json"} plot_metadata_path.write_text(json.dumps(plot_metadata)) - inherited = {'general': 'data'} + inherited = {"general": "data"} result = metadata.resolve_metadata_for_plot(plot_path, inherited) - expected = {'general': 'data', 'specific': 'plot_data_json'} + expected = {"general": "data", "specific": "plot_data_json"} assert result == expected def test_resolve_metadata_for_plot_no_specific(tmp_path): - plot_path = tmp_path / 'test_plot.pdf' - inherited = {'general': 'data', 'inherited': 'value'} + plot_path = tmp_path / "test_plot.pdf" + inherited = {"general": "data", "inherited": "value"} result = metadata.resolve_metadata_for_plot(plot_path, inherited) # Should return copy of inherited metadata @@ -173,17 +173,14 @@ def test_resolve_metadata_for_plot_no_specific(tmp_path): def test_save_metadata_cache(tmp_path): - cache_data = { - 'plot1': {'title': 'Plot 1', 'author': 'Test'}, - 'plot2': {'title': 'Plot 2', 'experiment': 'B'} - } + cache_data = {"plot1": {"title": "Plot 1", "author": "Test"}, "plot2": {"title": "Plot 2", "experiment": "B"}} metadata.save_metadata_cache(tmp_path, cache_data) - cache_file = tmp_path / 'meta_cache.json' + cache_file = tmp_path / "meta_cache.json" assert cache_file.exists() - with cache_file.open('r') as f: + with cache_file.open("r") as f: loaded_data = json.load(f) assert loaded_data == cache_data @@ -193,10 +190,10 @@ def test_save_metadata_cache_empty(tmp_path): cache_data = {} metadata.save_metadata_cache(tmp_path, cache_data) - cache_file = tmp_path / 'meta_cache.json' + cache_file = tmp_path / "meta_cache.json" assert cache_file.exists() - with cache_file.open('r') as f: + with cache_file.open("r") as f: loaded_data = json.load(f) assert loaded_data == {} diff --git a/tests/test_plotstyle.py b/tests/test_plotstyle.py new file mode 100644 index 0000000..44759b8 --- /dev/null +++ b/tests/test_plotstyle.py @@ -0,0 +1,330 @@ +import matplotlib + +matplotlib.use("Agg") + +import matplotlib.pyplot as plt +import pytest +from matplotlib.colors import Colormap + +import plotstyle as ps +from plotstyle import colors + + +def test_categorical_palette_matches_kit_hex(): + assert colors.CATEGORICAL == [ + "#009682", + "#DF9B1B", + "#4664AA", + "#A78230", + "#23A1E0", + "#A3107C", + "#8CB63C", + "#A22223", + "#FCE500", + ] + + +def test_diverging_palette_matches_kit_hex(): + assert colors.DIVERGING == {"low": "#4664AA", "mid": "#f7f7f7", "high": "#A22223"} + + +def test_status_palette_matches_validated_hex(): + assert colors.STATUS == { + "good": "#0ca30c", + "warning": "#fab219", + "serious": "#ec835a", + "critical": "#d03b3b", + } + + +def test_get_color_returns_categorical_slot(): + assert colors.get_color(0) == colors.CATEGORICAL[0] + assert colors.get_color(len(colors.CATEGORICAL) - 1) == colors.CATEGORICAL[-1] + + +def test_get_color_out_of_range_raises(): + with pytest.raises(ValueError): + colors.get_color(len(colors.CATEGORICAL)) + + +def test_sequential_steps_are_kit_blue_variations(): + assert colors.SEQUENTIAL_STEPS[-1].lower() == "#4664aa" + # Lightest step should be a lighter (higher-lightness) tint than the brand color. + import colorsys + + def lightness(hex_color): + r, g, b = (int(hex_color.lstrip("#")[i : i + 2], 16) / 255 for i in (0, 2, 4)) + return colorsys.rgb_to_hls(r, g, b)[1] + + assert lightness(colors.SEQUENTIAL_STEPS[0]) > lightness(colors.SEQUENTIAL_STEPS[-1]) + + +def test_sequential_cmap_is_usable_colormap(): + cmap = colors.sequential_cmap() + assert isinstance(cmap, Colormap) + assert cmap(0.0) != cmap(1.0) + + +def test_diverging_cmap_is_usable_colormap(): + cmap = colors.diverging_cmap() + assert isinstance(cmap, Colormap) + assert cmap(0.0) != cmap(1.0) + + +def test_use_sets_expected_rcparams(): + ps.use() + try: + assert plt.rcParams["axes.facecolor"] == "#ffffff" + assert plt.rcParams["text.usetex"] is True + assert "lmodern" in plt.rcParams["text.latex.preamble"] + assert "sfmath" in plt.rcParams["text.latex.preamble"] + assert "fontenc" in plt.rcParams["text.latex.preamble"] + assert r"\sfdefault" in plt.rcParams["text.latex.preamble"] + cycle_colors = [entry["color"] for entry in plt.rcParams["axes.prop_cycle"]] + assert cycle_colors == colors.CATEGORICAL + + assert plt.rcParams["axes.spines.top"] is False + assert plt.rcParams["axes.spines.right"] is False + assert plt.rcParams["axes.spines.left"] is False + assert plt.rcParams["axes.spines.bottom"] is True + assert plt.rcParams["xtick.bottom"] is True + assert plt.rcParams["ytick.left"] is True + assert plt.rcParams["axes.edgecolor"] == "#000000" + assert plt.rcParams["axes.linewidth"] > 0.8 + + assert plt.rcParams["axes.grid"] is True + assert plt.rcParams["axes.grid.axis"] == "y" + assert plt.rcParams["axes.titlelocation"] == "left" + + assert plt.rcParams["xtick.minor.visible"] is True + assert plt.rcParams["ytick.minor.visible"] is False + assert plt.rcParams["xtick.major.size"] > plt.rcParams["xtick.minor.size"] + finally: + ps.reset() + + +def test_use_default_does_not_cycle_linestyles(): + ps.use() + try: + cycle_keys = plt.rcParams["axes.prop_cycle"].keys + assert cycle_keys == {"color"} + finally: + ps.reset() + + +def test_use_cycle_linestyles_opt_in(): + ps.use(cycle_linestyles=True) + try: + cycle_keys = plt.rcParams["axes.prop_cycle"].keys + assert cycle_keys == {"color", "linestyle"} + linestyles = {entry["linestyle"] for entry in plt.rcParams["axes.prop_cycle"]} + assert len(linestyles) > 1 + finally: + ps.reset() + + +def test_new_figure_styles_major_and_minor_tick_labels_differently(): + fig, ax = ps.new_figure("square") + try: + assert ax.xaxis.get_tick_params(which="major")["labelcolor"] == colors.INK["primary"] + assert ax.xaxis.get_tick_params(which="minor")["labelcolor"] == colors.INK["muted"] + assert ax.yaxis.get_tick_params(which="major")["labelcolor"] == colors.INK["primary"] + assert ax.yaxis.get_tick_params(which="minor")["labelcolor"] == colors.INK["muted"] + finally: + plt.close(fig) + + +def test_new_figure_preset_sizes(): + fig, ax = ps.new_figure("thesis-single") + try: + assert tuple(fig.get_size_inches()) == ps.FIGSIZES["thesis-single"] + finally: + plt.close(fig) + + +def test_new_figure_explicit_tuple(): + fig, ax = ps.new_figure((3.0, 2.0)) + try: + assert tuple(fig.get_size_inches()) == (3.0, 2.0) + finally: + plt.close(fig) + + +def test_new_figure_unknown_preset_raises(): + with pytest.raises(ValueError): + ps.new_figure("not-a-real-preset") + + +def test_new_figure_title_sets_left_aligned_figure_suptitle(): + fig, ax = ps.new_figure("square", title="My Title") + try: + assert fig._suptitle is not None + assert "My Title" in fig._suptitle.get_text() + assert fig._suptitle.get_ha() == "left" + assert ax.get_title() == "" + finally: + plt.close(fig) + + +def test_new_figure_params_adds_subtitle_line(): + fig, ax = ps.new_figure("square", title="My Title", params={"N": 100, "seed": 42}) + try: + text = fig._suptitle.get_text() + assert "My Title" in text + assert "N: 100" in text + assert "seed: 42" in text + assert "|" in text + finally: + plt.close(fig) + + +def test_new_figure_without_title_or_params_has_no_suptitle(): + fig, ax = ps.new_figure("square") + try: + assert fig._suptitle is None + finally: + plt.close(fig) + + +def test_colorbar_matches_axes_height(): + fig, ax = ps.new_figure("square") + try: + im = ax.imshow([[0, 1], [2, 3]]) + cb = ps.colorbar(im, ax) + fig.canvas.draw() + ax_bbox = ax.get_position() + cax_bbox = cb.ax.get_position() + assert ax_bbox.y0 == pytest.approx(cax_bbox.y0, abs=1e-6) + assert ax_bbox.y1 == pytest.approx(cax_bbox.y1, abs=1e-6) + finally: + plt.close(fig) + + +def test_colorbar_has_no_outline(): + fig, ax = ps.new_figure("square") + try: + im = ax.imshow([[0, 1], [2, 3]]) + cb = ps.colorbar(im, ax) + assert cb.outline.get_visible() is False + finally: + plt.close(fig) + + +def test_no_spines_hides_all_spines_on_single_axes(): + fig, ax = ps.new_figure("square") + try: + ax.imshow([[0, 1], [2, 3]]) + ps.no_spines(ax) + assert all(not spine.get_visible() for spine in ax.spines.values()) + finally: + plt.close(fig) + + +def test_no_spines_hides_all_spines_on_axes_array(): + fig, axes = ps.new_figure("square", nrows=1, ncols=2) + try: + ps.no_spines(axes) + for ax in axes: + assert all(not spine.get_visible() for spine in ax.spines.values()) + finally: + plt.close(fig) + + +def test_savefig_writes_requested_formats(tmp_path): + fig, ax = ps.new_figure("square") + ax.plot([0, 1], [0, 1]) + try: + out_dir = tmp_path / "nested" / "plots" + written = ps.savefig(fig, out_dir / "my_plot", formats=("pdf", "png")) + finally: + plt.close(fig) + + assert [p.name for p in written] == ["my_plot.pdf", "my_plot.png"] + for p in written: + assert p.exists() + assert p.stat().st_size > 0 + + +def test_style_legend_places_legend_on_figure_outside_axes(): + fig, ax = ps.new_figure("square") + try: + ax.plot([0, 1], [0, 1], label="series") + legend = ps.style_legend(ax, title="Series") + assert legend in fig.legends + assert ax.get_legend() is None + assert legend.get_title().get_text() == "Series" + finally: + plt.close(fig) + + +def test_style_legend_without_title_warns(): + fig, ax = ps.new_figure("square") + try: + ax.plot([0, 1], [0, 1], label="series") + with pytest.warns(UserWarning): + ps.style_legend(ax) + finally: + plt.close(fig) + + +def test_panel_label_does_not_raise(): + fig, ax = ps.new_figure("square") + try: + ax.plot([0, 1], [0, 1], label="series") + ps.panel_label(ax, "a") + finally: + plt.close(fig) + + +def test_panel_label_unknown_loc_raises(): + fig, ax = ps.new_figure("square") + try: + with pytest.raises(ValueError): + ps.panel_label(ax, "a", loc="middle") + finally: + plt.close(fig) + + +def test_panel_label_defaults_to_lower_right(): + fig, ax = ps.new_figure("square") + try: + text = ps.panel_label(ax, "a") + assert text.get_ha() == "right" + assert text.get_va() == "bottom" + x, y = text.get_position() + assert x > 0.5 + assert y < 0.5 + finally: + plt.close(fig) + + +def test_panel_label_color_matches_xlabel(): + fig, ax = ps.new_figure("square") + try: + ax.set_xlabel("Time (s)") + text = ps.panel_label(ax, "a") + assert text.get_color() == ax.xaxis.label.get_color() + finally: + plt.close(fig) + + +def test_panel_label_has_rounded_semi_transparent_box_by_default(): + fig, ax = ps.new_figure("square") + try: + text = ps.panel_label(ax, "a") + patch = text.get_bbox_patch() + assert patch is not None + assert "round" in patch.get_boxstyle().__class__.__name__.lower() + assert patch.get_facecolor()[3] < 1.0 + assert patch.get_edgecolor()[3] == 1.0 + finally: + plt.close(fig) + + +def test_panel_label_box_can_be_disabled(): + fig, ax = ps.new_figure("square") + try: + text = ps.panel_label(ax, "a", box=False) + assert text.get_bbox_patch() is None + finally: + plt.close(fig) diff --git a/tests/validate_metadata.py b/tests/validate_metadata.py new file mode 100644 index 0000000..ab87c6a --- /dev/null +++ b/tests/validate_metadata.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python3 +""" +Metadata Validation Utility + +This script validates metadata files in the gallery source directories, +checking for proper YAML/JSON syntax and common field validation. +""" + +import json +import sys +from pathlib import Path +from typing import List + +import yaml + + +def validate_metadata_file(file_path: Path) -> tuple[bool, List[str]]: + """ + Validate a single metadata file. + + Args: + file_path: Path to the metadata file + + Returns: + Tuple of (is_valid, error_messages) + """ + errors = [] + + if not file_path.exists(): + errors.append(f"File does not exist: {file_path}") + return False, errors + + try: + with file_path.open("r", encoding="utf-8") as f: + suffix_lower = file_path.suffix.lower() + if suffix_lower in [".yaml", ".yml"]: + data = yaml.safe_load(f) + elif suffix_lower == ".json": + data = json.load(f) + else: + errors.append(f"Unsupported file format: {file_path}") + return False, errors + + if data is None: + errors.append(f"Empty metadata file: {file_path}") + return False, errors + + # Basic validation + if not isinstance(data, dict): + errors.append(f"Metadata must be a dictionary: {file_path}") + return False, errors + + # Check for common issues + if "title" in data and not isinstance(data["title"], str): + errors.append(f"Title must be a string: {file_path}") + + if "tags" in data and not isinstance(data["tags"], list): + errors.append(f"Tags must be a list: {file_path}") + + if "author" in data and not isinstance(data["author"], dict): + errors.append(f"Author must be a dictionary: {file_path}") + + except (yaml.YAMLError, json.JSONDecodeError) as e: + errors.append(f"Parse error in {file_path}: {e}") + return False, errors + except Exception as e: + errors.append(f"Unexpected error reading {file_path}: {e}") + return False, errors + + return len(errors) == 0, errors + + +def find_metadata_files(root_dir: Path) -> List[Path]: + """ + Find all metadata files in a directory tree. + + Args: + root_dir: Root directory to search + + Returns: + List of metadata file paths + """ + metadata_files = [] + + for pattern in ["**/*.yaml", "**/*.yml", "**/*.json"]: + for file_path in root_dir.glob(pattern): + if file_path.name.startswith("meta.") or file_path.stem != file_path.name: + metadata_files.append(file_path) + + return metadata_files + + +def main(): + """Main validation function.""" + if len(sys.argv) != 2: + print("Usage: python validate_metadata.py ") + sys.exit(1) + + root_dir = Path(sys.argv[1]) + + if not root_dir.exists(): + print(f"Error: Directory does not exist: {root_dir}") + sys.exit(1) + + if not root_dir.is_dir(): + print(f"Error: Not a directory: {root_dir}") + sys.exit(1) + + print(f"Validating metadata files in: {root_dir}") + print("-" * 50) + + metadata_files = find_metadata_files(root_dir) + + if not metadata_files: + print("No metadata files found.") + return + + total_files = len(metadata_files) + valid_files = 0 + + for file_path in metadata_files: + is_valid, errors = validate_metadata_file(file_path) + + if is_valid: + print(f"✓ {file_path.relative_to(root_dir)}") + valid_files += 1 + else: + print(f"✗ {file_path.relative_to(root_dir)}") + for error in errors: + print(f" - {error}") + + print("-" * 50) + print(f"Summary: {valid_files}/{total_files} files valid") + + if valid_files != total_files: + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/uv.lock b/uv.lock index 0037677..30f4e5f 100644 --- a/uv.lock +++ b/uv.lock @@ -11,6 +11,12 @@ resolution-markers = [ "python_full_version < '3.8.1'", ] +[manifest] +members = [ + "gallery", + "plotstyle", +] + [[package]] name = "argcomplete" version = "3.6.3" @@ -21,39 +27,60 @@ wheels = [ ] [[package]] -name = "astroid" -version = "3.2.4" +name = "boolean-py" +version = "5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/cf/85379f13b76f3a69bca86b60237978af17d6aa0bc5998978c3b8cf05abb2/boolean_py-5.0.tar.gz", hash = "sha256:60cbc4bad079753721d32649545505362c754e121570ada4658b852a3a318d95", size = 37047, upload-time = "2025-04-03T10:39:49.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/ca/78d423b324b8d77900030fa59c4aa9054261ef0925631cd2501dd015b7b7/boolean_py-5.0-py3-none-any.whl", hash = "sha256:ef28a70bd43115208441b53a045d1549e2f0ec6e3d08a9d142cbc41c1938e8d9", size = 26577, upload-time = "2025-04-03T10:39:48.449Z" }, +] + +[[package]] +name = "cachecontrol" +version = "0.14.2" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.8.1' and python_full_version < '3.9'", "python_full_version < '3.8.1'", ] dependencies = [ - { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "msgpack", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "requests", version = "2.32.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9e/53/1067e1113ecaf58312357f2cd93063674924119d80d173adc3f6f2387aa2/astroid-3.2.4.tar.gz", hash = "sha256:0e14202810b30da1b735827f78f5157be2bbd4a7a59b7707ca0bfc2fb4c0063a", size = 397576, upload-time = "2024-07-20T12:57:43.26Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/a4/3390ac4dfa1773f661c8780368018230e8207ec4fd3800d2c0c3adee4456/cachecontrol-0.14.2.tar.gz", hash = "sha256:7d47d19f866409b98ff6025b6a0fca8e4c791fb31abbd95f622093894ce903a2", size = 28832, upload-time = "2025-01-07T15:48:23.709Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/80/96/b32bbbb46170a1c8b8b1f28c794202e25cfe743565e9d3469b8eb1e0cc05/astroid-3.2.4-py3-none-any.whl", hash = "sha256:413658a61eeca6202a59231abb473f932038fbcbf1666587f66d482083413a25", size = 276348, upload-time = "2024-07-20T12:57:40.886Z" }, + { url = "https://files.pythonhosted.org/packages/c8/63/baffb44ca6876e7b5fc8fe17b24a7c07bf479d604a592182db9af26ea366/cachecontrol-0.14.2-py3-none-any.whl", hash = "sha256:ebad2091bf12d0d200dfc2464330db638c5deb41d546f6d7aca079e87290f3b0", size = 21780, upload-time = "2025-01-07T15:48:21.034Z" }, +] + +[package.optional-dependencies] +filecache = [ + { name = "filelock", version = "3.16.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, ] [[package]] -name = "astroid" -version = "3.3.11" +name = "cachecontrol" +version = "0.14.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version == '3.9.*'", ] dependencies = [ - { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "msgpack", version = "1.1.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "requests", version = "2.32.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/18/74/dfb75f9ccd592bbedb175d4a32fc643cf569d7c218508bfbd6ea7ef9c091/astroid-3.3.11.tar.gz", hash = "sha256:1e5a5011af2920c7c67a53f65d536d65bfa7116feeaf2354d8b94f29573bb0ce", size = 400439, upload-time = "2025-07-13T18:04:23.177Z" } +sdist = { url = "https://files.pythonhosted.org/packages/58/3a/0cbeb04ea57d2493f3ec5a069a117ab467f85e4a10017c6d854ddcbff104/cachecontrol-0.14.3.tar.gz", hash = "sha256:73e7efec4b06b20d9267b441c1f733664f989fb8688391b670ca812d70795d11", size = 28985, upload-time = "2025-04-30T16:45:06.135Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/af/0f/3b8fdc946b4d9cc8cc1e8af42c4e409468c84441b933d037e101b3d72d86/astroid-3.3.11-py3-none-any.whl", hash = "sha256:54c760ae8322ece1abd213057c4b5bba7c49818853fc901ef09719a60dbf9dec", size = 275612, upload-time = "2025-07-13T18:04:21.07Z" }, + { url = "https://files.pythonhosted.org/packages/81/4c/800b0607b00b3fd20f1087f80ab53d6b4d005515b0f773e4831e37cfa83f/cachecontrol-0.14.3-py3-none-any.whl", hash = "sha256:b35e44a3113f17d2a31c1e6b27b9de6d4405f84ae51baa8c1d3cc5b633010cae", size = 21802, upload-time = "2025-04-30T16:45:03.863Z" }, +] + +[package.optional-dependencies] +filecache = [ + { name = "filelock", version = "3.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, ] [[package]] -name = "astroid" -version = "4.0.4" +name = "cachecontrol" +version = "0.14.4" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15'", @@ -62,184 +89,126 @@ resolution-markers = [ "python_full_version == '3.10.*'", ] dependencies = [ - { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "msgpack", version = "1.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "requests", version = "2.34.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/07/63/0adf26577da5eff6eb7a177876c1cfa213856be9926a000f65c4add9692b/astroid-4.0.4.tar.gz", hash = "sha256:986fed8bcf79fb82c78b18a53352a0b287a73817d6dbcfba3162da36667c49a0", size = 406358, upload-time = "2026-02-07T23:35:07.509Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f6/c972b32d80760fb79d6b9eeb0b3010a46b89c0b23cf6329417ff7886cd22/cachecontrol-0.14.4.tar.gz", hash = "sha256:e6220afafa4c22a47dd0badb319f84475d79108100d04e26e8542ef7d3ab05a1", size = 16150, upload-time = "2025-11-14T04:32:13.138Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/cf/1c5f42b110e57bc5502eb80dbc3b03d256926062519224835ef08134f1f9/astroid-4.0.4-py3-none-any.whl", hash = "sha256:52f39653876c7dec3e3afd4c2696920e05c83832b9737afc21928f2d2eb7a753", size = 276445, upload-time = "2026-02-07T23:35:05.344Z" }, + { url = "https://files.pythonhosted.org/packages/ef/79/c45f2d53efe6ada1110cf6f9fca095e4ff47a0454444aefdde6ac4789179/cachecontrol-0.14.4-py3-none-any.whl", hash = "sha256:b7ac014ff72ee199b5f8af1de29d60239954f223e948196fa3d84adaffc71d2b", size = 22247, upload-time = "2025-11-14T04:32:11.733Z" }, +] + +[package.optional-dependencies] +filecache = [ + { name = "filelock", version = "3.32.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, ] [[package]] -name = "black" -version = "24.8.0" +name = "certifi" +version = "2026.7.22" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.8.1' and python_full_version < '3.9'", - "python_full_version < '3.8.1'", -] -dependencies = [ - { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "mypy-extensions", marker = "python_full_version < '3.9'" }, - { name = "packaging", marker = "python_full_version < '3.9'" }, - { name = "pathspec", version = "0.12.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "platformdirs", version = "4.3.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "tomli", marker = "python_full_version < '3.9'" }, - { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/04/b0/46fb0d4e00372f4a86a6f8efa3cb193c9f64863615e39010b1477e010578/black-24.8.0.tar.gz", hash = "sha256:2500945420b6784c38b9ee885af039f5e7471ef284ab03fa35ecdde4688cd83f", size = 644810, upload-time = "2024-08-02T17:43:18.405Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/47/6e/74e29edf1fba3887ed7066930a87f698ffdcd52c5dbc263eabb06061672d/black-24.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:09cdeb74d494ec023ded657f7092ba518e8cf78fa8386155e4a03fdcc44679e6", size = 1632092, upload-time = "2024-08-02T17:47:26.911Z" }, - { url = "https://files.pythonhosted.org/packages/ab/49/575cb6c3faee690b05c9d11ee2e8dba8fbd6d6c134496e644c1feb1b47da/black-24.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:81c6742da39f33b08e791da38410f32e27d632260e599df7245cccee2064afeb", size = 1457529, upload-time = "2024-08-02T17:47:29.109Z" }, - { url = "https://files.pythonhosted.org/packages/7a/b4/d34099e95c437b53d01c4aa37cf93944b233066eb034ccf7897fa4e5f286/black-24.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:707a1ca89221bc8a1a64fb5e15ef39cd755633daa672a9db7498d1c19de66a42", size = 1757443, upload-time = "2024-08-02T17:46:20.306Z" }, - { url = "https://files.pythonhosted.org/packages/87/a0/6d2e4175ef364b8c4b64f8441ba041ed65c63ea1db2720d61494ac711c15/black-24.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:d6417535d99c37cee4091a2f24eb2b6d5ec42b144d50f1f2e436d9fe1916fe1a", size = 1418012, upload-time = "2024-08-02T17:47:20.33Z" }, - { url = "https://files.pythonhosted.org/packages/08/a6/0a3aa89de9c283556146dc6dbda20cd63a9c94160a6fbdebaf0918e4a3e1/black-24.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fb6e2c0b86bbd43dee042e48059c9ad7830abd5c94b0bc518c0eeec57c3eddc1", size = 1615080, upload-time = "2024-08-02T17:48:05.467Z" }, - { url = "https://files.pythonhosted.org/packages/db/94/b803d810e14588bb297e565821a947c108390a079e21dbdcb9ab6956cd7a/black-24.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:837fd281f1908d0076844bc2b801ad2d369c78c45cf800cad7b61686051041af", size = 1438143, upload-time = "2024-08-02T17:47:30.247Z" }, - { url = "https://files.pythonhosted.org/packages/a5/b5/f485e1bbe31f768e2e5210f52ea3f432256201289fd1a3c0afda693776b0/black-24.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62e8730977f0b77998029da7971fa896ceefa2c4c4933fcd593fa599ecbf97a4", size = 1738774, upload-time = "2024-08-02T17:46:17.837Z" }, - { url = "https://files.pythonhosted.org/packages/a8/69/a000fc3736f89d1bdc7f4a879f8aaf516fb03613bb51a0154070383d95d9/black-24.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:72901b4913cbac8972ad911dc4098d5753704d1f3c56e44ae8dce99eecb0e3af", size = 1427503, upload-time = "2024-08-02T17:46:22.654Z" }, - { url = "https://files.pythonhosted.org/packages/a2/a8/05fb14195cfef32b7c8d4585a44b7499c2a4b205e1662c427b941ed87054/black-24.8.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7c046c1d1eeb7aea9335da62472481d3bbf3fd986e093cffd35f4385c94ae368", size = 1646132, upload-time = "2024-08-02T17:49:52.843Z" }, - { url = "https://files.pythonhosted.org/packages/41/77/8d9ce42673e5cb9988f6df73c1c5c1d4e9e788053cccd7f5fb14ef100982/black-24.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:649f6d84ccbae73ab767e206772cc2d7a393a001070a4c814a546afd0d423aed", size = 1448665, upload-time = "2024-08-02T17:47:54.479Z" }, - { url = "https://files.pythonhosted.org/packages/cc/94/eff1ddad2ce1d3cc26c162b3693043c6b6b575f538f602f26fe846dfdc75/black-24.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b59b250fdba5f9a9cd9d0ece6e6d993d91ce877d121d161e4698af3eb9c1018", size = 1762458, upload-time = "2024-08-02T17:46:19.384Z" }, - { url = "https://files.pythonhosted.org/packages/28/ea/18b8d86a9ca19a6942e4e16759b2fa5fc02bbc0eb33c1b866fcd387640ab/black-24.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:6e55d30d44bed36593c3163b9bc63bf58b3b30e4611e4d88a0c3c239930ed5b2", size = 1436109, upload-time = "2024-08-02T17:46:52.97Z" }, - { url = "https://files.pythonhosted.org/packages/9f/d4/ae03761ddecc1a37d7e743b89cccbcf3317479ff4b88cfd8818079f890d0/black-24.8.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:505289f17ceda596658ae81b61ebbe2d9b25aa78067035184ed0a9d855d18afd", size = 1617322, upload-time = "2024-08-02T17:51:20.203Z" }, - { url = "https://files.pythonhosted.org/packages/14/4b/4dfe67eed7f9b1ddca2ec8e4418ea74f0d1dc84d36ea874d618ffa1af7d4/black-24.8.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b19c9ad992c7883ad84c9b22aaa73562a16b819c1d8db7a1a1a49fb7ec13c7d2", size = 1442108, upload-time = "2024-08-02T17:50:40.824Z" }, - { url = "https://files.pythonhosted.org/packages/97/14/95b3f91f857034686cae0e73006b8391d76a8142d339b42970eaaf0416ea/black-24.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f13f7f386f86f8121d76599114bb8c17b69d962137fc70efe56137727c7047e", size = 1745786, upload-time = "2024-08-02T17:46:02.939Z" }, - { url = "https://files.pythonhosted.org/packages/95/54/68b8883c8aa258a6dde958cd5bdfada8382bec47c5162f4a01e66d839af1/black-24.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:f490dbd59680d809ca31efdae20e634f3fae27fba3ce0ba3208333b713bc3920", size = 1426754, upload-time = "2024-08-02T17:46:38.603Z" }, - { url = "https://files.pythonhosted.org/packages/13/b2/b3f24fdbb46f0e7ef6238e131f13572ee8279b70f237f221dd168a9dba1a/black-24.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:eab4dd44ce80dea27dc69db40dab62d4ca96112f87996bca68cd75639aeb2e4c", size = 1631706, upload-time = "2024-08-02T17:49:57.606Z" }, - { url = "https://files.pythonhosted.org/packages/d9/35/31010981e4a05202a84a3116423970fd1a59d2eda4ac0b3570fbb7029ddc/black-24.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3c4285573d4897a7610054af5a890bde7c65cb466040c5f0c8b732812d7f0e5e", size = 1457429, upload-time = "2024-08-02T17:49:12.764Z" }, - { url = "https://files.pythonhosted.org/packages/27/25/3f706b4f044dd569a20a4835c3b733dedea38d83d2ee0beb8178a6d44945/black-24.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e84e33b37be070ba135176c123ae52a51f82306def9f7d063ee302ecab2cf47", size = 1756488, upload-time = "2024-08-02T17:46:08.067Z" }, - { url = "https://files.pythonhosted.org/packages/63/72/79375cd8277cbf1c5670914e6bd4c1b15dea2c8f8e906dc21c448d0535f0/black-24.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:73bbf84ed136e45d451a260c6b73ed674652f90a2b3211d6a35e78054563a9bb", size = 1417721, upload-time = "2024-08-02T17:46:42.637Z" }, - { url = "https://files.pythonhosted.org/packages/27/1e/83fa8a787180e1632c3d831f7e58994d7aaf23a0961320d21e84f922f919/black-24.8.0-py3-none-any.whl", hash = "sha256:972085c618ee94f402da1af548a4f218c754ea7e5dc70acb168bfaca4c2542ed", size = 206504, upload-time = "2024-08-02T17:43:15.747Z" }, + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, ] [[package]] -name = "black" -version = "25.11.0" +name = "charset-normalizer" +version = "3.4.9" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version == '3.9.*'", -] -dependencies = [ - { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "mypy-extensions", marker = "python_full_version == '3.9.*'" }, - { name = "packaging", marker = "python_full_version == '3.9.*'" }, - { name = "pathspec", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "platformdirs", version = "4.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "pytokens", marker = "python_full_version == '3.9.*'" }, - { name = "tomli", marker = "python_full_version == '3.9.*'" }, - { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8c/ad/33adf4708633d047950ff2dfdea2e215d84ac50ef95aff14a614e4b6e9b2/black-25.11.0.tar.gz", hash = "sha256:9a323ac32f5dc75ce7470501b887250be5005a01602e931a15e45593f70f6e08", size = 655669, upload-time = "2025-11-10T01:53:50.558Z" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/2a/23f34ec9d04624958e137efdc394888716353190e75f25dd22c7a2c7a8aa/charset_normalizer-3.4.9.tar.gz", hash = "sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b", size = 152439, upload-time = "2026-07-07T14:34:58.454Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/d2/6caccbc96f9311e8ec3378c296d4f4809429c43a6cd2394e3c390e86816d/black-25.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ec311e22458eec32a807f029b2646f661e6859c3f61bc6d9ffb67958779f392e", size = 1743501, upload-time = "2025-11-10T01:59:06.202Z" }, - { url = "https://files.pythonhosted.org/packages/69/35/b986d57828b3f3dccbf922e2864223197ba32e74c5004264b1c62bc9f04d/black-25.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1032639c90208c15711334d681de2e24821af0575573db2810b0763bcd62e0f0", size = 1597308, upload-time = "2025-11-10T01:57:58.633Z" }, - { url = "https://files.pythonhosted.org/packages/39/8e/8b58ef4b37073f52b64a7b2dd8c9a96c84f45d6f47d878d0aa557e9a2d35/black-25.11.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0c0f7c461df55cf32929b002335883946a4893d759f2df343389c4396f3b6b37", size = 1656194, upload-time = "2025-11-10T01:57:10.909Z" }, - { url = "https://files.pythonhosted.org/packages/8d/30/9c2267a7955ecc545306534ab88923769a979ac20a27cf618d370091e5dd/black-25.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:f9786c24d8e9bd5f20dc7a7f0cdd742644656987f6ea6947629306f937726c03", size = 1347996, upload-time = "2025-11-10T01:57:22.391Z" }, - { url = "https://files.pythonhosted.org/packages/c4/62/d304786b75ab0c530b833a89ce7d997924579fb7484ecd9266394903e394/black-25.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:895571922a35434a9d8ca67ef926da6bc9ad464522a5fe0db99b394ef1c0675a", size = 1727891, upload-time = "2025-11-10T02:01:40.507Z" }, - { url = "https://files.pythonhosted.org/packages/82/5d/ffe8a006aa522c9e3f430e7b93568a7b2163f4b3f16e8feb6d8c3552761a/black-25.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cb4f4b65d717062191bdec8e4a442539a8ea065e6af1c4f4d36f0cdb5f71e170", size = 1581875, upload-time = "2025-11-10T01:57:51.192Z" }, - { url = "https://files.pythonhosted.org/packages/cb/c8/7c8bda3108d0bb57387ac41b4abb5c08782b26da9f9c4421ef6694dac01a/black-25.11.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d81a44cbc7e4f73a9d6ae449ec2317ad81512d1e7dce7d57f6333fd6259737bc", size = 1642716, upload-time = "2025-11-10T01:56:51.589Z" }, - { url = "https://files.pythonhosted.org/packages/34/b9/f17dea34eecb7cc2609a89627d480fb6caea7b86190708eaa7eb15ed25e7/black-25.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:7eebd4744dfe92ef1ee349dc532defbf012a88b087bb7ddd688ff59a447b080e", size = 1352904, upload-time = "2025-11-10T01:59:26.252Z" }, - { url = "https://files.pythonhosted.org/packages/7f/12/5c35e600b515f35ffd737da7febdb2ab66bb8c24d88560d5e3ef3d28c3fd/black-25.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:80e7486ad3535636657aa180ad32a7d67d7c273a80e12f1b4bfa0823d54e8fac", size = 1772831, upload-time = "2025-11-10T02:03:47Z" }, - { url = "https://files.pythonhosted.org/packages/1a/75/b3896bec5a2bb9ed2f989a970ea40e7062f8936f95425879bbe162746fe5/black-25.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6cced12b747c4c76bc09b4db057c319d8545307266f41aaee665540bc0e04e96", size = 1608520, upload-time = "2025-11-10T01:58:46.895Z" }, - { url = "https://files.pythonhosted.org/packages/f3/b5/2bfc18330eddbcfb5aab8d2d720663cd410f51b2ed01375f5be3751595b0/black-25.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cb2d54a39e0ef021d6c5eef442e10fd71fcb491be6413d083a320ee768329dd", size = 1682719, upload-time = "2025-11-10T01:56:55.24Z" }, - { url = "https://files.pythonhosted.org/packages/96/fb/f7dc2793a22cdf74a72114b5ed77fe3349a2e09ef34565857a2f917abdf2/black-25.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:ae263af2f496940438e5be1a0c1020e13b09154f3af4df0835ea7f9fe7bfa409", size = 1362684, upload-time = "2025-11-10T01:57:07.639Z" }, - { url = "https://files.pythonhosted.org/packages/ad/47/3378d6a2ddefe18553d1115e36aea98f4a90de53b6a3017ed861ba1bd3bc/black-25.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0a1d40348b6621cc20d3d7530a5b8d67e9714906dfd7346338249ad9c6cedf2b", size = 1772446, upload-time = "2025-11-10T02:02:16.181Z" }, - { url = "https://files.pythonhosted.org/packages/ba/4b/0f00bfb3d1f7e05e25bfc7c363f54dc523bb6ba502f98f4ad3acf01ab2e4/black-25.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:51c65d7d60bb25429ea2bf0731c32b2a2442eb4bd3b2afcb47830f0b13e58bfd", size = 1607983, upload-time = "2025-11-10T02:02:52.502Z" }, - { url = "https://files.pythonhosted.org/packages/99/fe/49b0768f8c9ae57eb74cc10a1f87b4c70453551d8ad498959721cc345cb7/black-25.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:936c4dd07669269f40b497440159a221ee435e3fddcf668e0c05244a9be71993", size = 1682481, upload-time = "2025-11-10T01:57:12.35Z" }, - { url = "https://files.pythonhosted.org/packages/55/17/7e10ff1267bfa950cc16f0a411d457cdff79678fbb77a6c73b73a5317904/black-25.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:f42c0ea7f59994490f4dccd64e6b2dd49ac57c7c84f38b8faab50f8759db245c", size = 1363869, upload-time = "2025-11-10T01:58:24.608Z" }, - { url = "https://files.pythonhosted.org/packages/67/c0/cc865ce594d09e4cd4dfca5e11994ebb51604328489f3ca3ae7bb38a7db5/black-25.11.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:35690a383f22dd3e468c85dc4b915217f87667ad9cce781d7b42678ce63c4170", size = 1771358, upload-time = "2025-11-10T02:03:33.331Z" }, - { url = "https://files.pythonhosted.org/packages/37/77/4297114d9e2fd2fc8ab0ab87192643cd49409eb059e2940391e7d2340e57/black-25.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:dae49ef7369c6caa1a1833fd5efb7c3024bb7e4499bf64833f65ad27791b1545", size = 1612902, upload-time = "2025-11-10T01:59:33.382Z" }, - { url = "https://files.pythonhosted.org/packages/de/63/d45ef97ada84111e330b2b2d45e1dd163e90bd116f00ac55927fb6bf8adb/black-25.11.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bd4a22a0b37401c8e492e994bce79e614f91b14d9ea911f44f36e262195fdda", size = 1680571, upload-time = "2025-11-10T01:57:04.239Z" }, - { url = "https://files.pythonhosted.org/packages/ff/4b/5604710d61cdff613584028b4cb4607e56e148801ed9b38ee7970799dab6/black-25.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:aa211411e94fdf86519996b7f5f05e71ba34835d8f0c0f03c00a26271da02664", size = 1382599, upload-time = "2025-11-10T01:57:57.427Z" }, - { url = "https://files.pythonhosted.org/packages/d5/9a/5b2c0e3215fe748fcf515c2dd34658973a1210bf610e24de5ba887e4f1c8/black-25.11.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a3bb5ce32daa9ff0605d73b6f19da0b0e6c1f8f2d75594db539fdfed722f2b06", size = 1743063, upload-time = "2025-11-10T02:02:43.175Z" }, - { url = "https://files.pythonhosted.org/packages/a1/20/245164c6efc27333409c62ba54dcbfbe866c6d1957c9a6c0647786e950da/black-25.11.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9815ccee1e55717fe9a4b924cae1646ef7f54e0f990da39a34fc7b264fcf80a2", size = 1596867, upload-time = "2025-11-10T02:00:17.157Z" }, - { url = "https://files.pythonhosted.org/packages/ca/6f/1a3859a7da205f3d50cf3a8bec6bdc551a91c33ae77a045bb24c1f46ab54/black-25.11.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92285c37b93a1698dcbc34581867b480f1ba3a7b92acf1fe0467b04d7a4da0dc", size = 1655678, upload-time = "2025-11-10T01:57:09.028Z" }, - { url = "https://files.pythonhosted.org/packages/56/1a/6dec1aeb7be90753d4fcc273e69bc18bfd34b353223ed191da33f7519410/black-25.11.0-cp39-cp39-win_amd64.whl", hash = "sha256:43945853a31099c7c0ff8dface53b4de56c41294fa6783c0441a8b1d9bf668bc", size = 1347452, upload-time = "2025-11-10T01:57:01.871Z" }, - { url = "https://files.pythonhosted.org/packages/00/5d/aed32636ed30a6e7f9efd6ad14e2a0b0d687ae7c8c7ec4e4a557174b895c/black-25.11.0-py3-none-any.whl", hash = "sha256:e3f562da087791e96cefcd9dda058380a442ab322a02e222add53736451f604b", size = 204918, upload-time = "2025-11-10T01:53:48.917Z" }, -] - -[[package]] -name = "black" -version = "26.3.1" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.15'", - "python_full_version >= '3.12' and python_full_version < '3.15'", - "python_full_version == '3.11.*'", - "python_full_version == '3.10.*'", -] -dependencies = [ - { name = "click", version = "8.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "mypy-extensions", marker = "python_full_version >= '3.10'" }, - { name = "packaging", marker = "python_full_version >= '3.10'" }, - { name = "pathspec", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "platformdirs", version = "4.9.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "pytokens", marker = "python_full_version >= '3.10'" }, - { name = "tomli", marker = "python_full_version == '3.10.*'" }, - { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e1/c5/61175d618685d42b005847464b8fb4743a67b1b8fdb75e50e5a96c31a27a/black-26.3.1.tar.gz", hash = "sha256:2c50f5063a9641c7eed7795014ba37b0f5fa227f3d408b968936e24bc0566b07", size = 666155, upload-time = "2026-03-12T03:36:03.593Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/32/a8/11170031095655d36ebc6664fe0897866f6023892396900eec0e8fdc4299/black-26.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:86a8b5035fce64f5dcd1b794cf8ec4d31fe458cf6ce3986a30deb434df82a1d2", size = 1866562, upload-time = "2026-03-12T03:39:58.639Z" }, - { url = "https://files.pythonhosted.org/packages/69/ce/9e7548d719c3248c6c2abfd555d11169457cbd584d98d179111338423790/black-26.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5602bdb96d52d2d0672f24f6ffe5218795736dd34807fd0fd55ccd6bf206168b", size = 1703623, upload-time = "2026-03-12T03:40:00.347Z" }, - { url = "https://files.pythonhosted.org/packages/7f/0a/8d17d1a9c06f88d3d030d0b1d4373c1551146e252afe4547ed601c0e697f/black-26.3.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c54a4a82e291a1fee5137371ab488866b7c86a3305af4026bdd4dc78642e1ac", size = 1768388, upload-time = "2026-03-12T03:40:01.765Z" }, - { url = "https://files.pythonhosted.org/packages/52/79/c1ee726e221c863cde5164f925bacf183dfdf0397d4e3f94889439b947b4/black-26.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:6e131579c243c98f35bce64a7e08e87fb2d610544754675d4a0e73a070a5aa3a", size = 1412969, upload-time = "2026-03-12T03:40:03.252Z" }, - { url = "https://files.pythonhosted.org/packages/73/a5/15c01d613f5756f68ed8f6d4ec0a1e24b82b18889fa71affd3d1f7fad058/black-26.3.1-cp310-cp310-win_arm64.whl", hash = "sha256:5ed0ca58586c8d9a487352a96b15272b7fa55d139fc8496b519e78023a8dab0a", size = 1220345, upload-time = "2026-03-12T03:40:04.892Z" }, - { url = "https://files.pythonhosted.org/packages/17/57/5f11c92861f9c92eb9dddf515530bc2d06db843e44bdcf1c83c1427824bc/black-26.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:28ef38aee69e4b12fda8dba75e21f9b4f979b490c8ac0baa7cb505369ac9e1ff", size = 1851987, upload-time = "2026-03-12T03:40:06.248Z" }, - { url = "https://files.pythonhosted.org/packages/54/aa/340a1463660bf6831f9e39646bf774086dbd8ca7fc3cded9d59bbdf4ad0a/black-26.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bf9bf162ed91a26f1adba8efda0b573bc6924ec1408a52cc6f82cb73ec2b142c", size = 1689499, upload-time = "2026-03-12T03:40:07.642Z" }, - { url = "https://files.pythonhosted.org/packages/f3/01/b726c93d717d72733da031d2de10b92c9fa4c8d0c67e8a8a372076579279/black-26.3.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:474c27574d6d7037c1bc875a81d9be0a9a4f9ee95e62800dab3cfaadbf75acd5", size = 1754369, upload-time = "2026-03-12T03:40:09.279Z" }, - { url = "https://files.pythonhosted.org/packages/e3/09/61e91881ca291f150cfc9eb7ba19473c2e59df28859a11a88248b5cbbc4d/black-26.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:5e9d0d86df21f2e1677cc4bd090cd0e446278bcbbe49bf3659c308c3e402843e", size = 1413613, upload-time = "2026-03-12T03:40:10.943Z" }, - { url = "https://files.pythonhosted.org/packages/16/73/544f23891b22e7efe4d8f812371ab85b57f6a01b2fc45e3ba2e52ba985b8/black-26.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:9a5e9f45e5d5e1c5b5c29b3bd4265dcc90e8b92cf4534520896ed77f791f4da5", size = 1219719, upload-time = "2026-03-12T03:40:12.597Z" }, - { url = "https://files.pythonhosted.org/packages/dc/f8/da5eae4fc75e78e6dceb60624e1b9662ab00d6b452996046dfa9b8a6025b/black-26.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5e6f89631eb88a7302d416594a32faeee9fb8fb848290da9d0a5f2903519fc1", size = 1895920, upload-time = "2026-03-12T03:40:13.921Z" }, - { url = "https://files.pythonhosted.org/packages/2c/9f/04e6f26534da2e1629b2b48255c264cabf5eedc5141d04516d9d68a24111/black-26.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cd2012d35b47d589cb8a16faf8a32ef7a336f56356babd9fcf70939ad1897f", size = 1718499, upload-time = "2026-03-12T03:40:15.239Z" }, - { url = "https://files.pythonhosted.org/packages/04/91/a5935b2a63e31b331060c4a9fdb5a6c725840858c599032a6f3aac94055f/black-26.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f76ff19ec5297dd8e66eb64deda23631e642c9393ab592826fd4bdc97a4bce7", size = 1794994, upload-time = "2026-03-12T03:40:17.124Z" }, - { url = "https://files.pythonhosted.org/packages/e7/0a/86e462cdd311a3c2a8ece708d22aba17d0b2a0d5348ca34b40cdcbea512e/black-26.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:ddb113db38838eb9f043623ba274cfaf7d51d5b0c22ecb30afe58b1bb8322983", size = 1420867, upload-time = "2026-03-12T03:40:18.83Z" }, - { url = "https://files.pythonhosted.org/packages/5b/e5/22515a19cb7eaee3440325a6b0d95d2c0e88dd180cb011b12ae488e031d1/black-26.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:dfdd51fc3e64ea4f35873d1b3fb25326773d55d2329ff8449139ebaad7357efb", size = 1230124, upload-time = "2026-03-12T03:40:20.425Z" }, - { url = "https://files.pythonhosted.org/packages/f5/77/5728052a3c0450c53d9bb3945c4c46b91baa62b2cafab6801411b6271e45/black-26.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:855822d90f884905362f602880ed8b5df1b7e3ee7d0db2502d4388a954cc8c54", size = 1895034, upload-time = "2026-03-12T03:40:21.813Z" }, - { url = "https://files.pythonhosted.org/packages/52/73/7cae55fdfdfbe9d19e9a8d25d145018965fe2079fa908101c3733b0c55a0/black-26.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8a33d657f3276328ce00e4d37fe70361e1ec7614da5d7b6e78de5426cb56332f", size = 1718503, upload-time = "2026-03-12T03:40:23.666Z" }, - { url = "https://files.pythonhosted.org/packages/e1/87/af89ad449e8254fdbc74654e6467e3c9381b61472cc532ee350d28cfdafb/black-26.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f1cd08e99d2f9317292a311dfe578fd2a24b15dbce97792f9c4d752275c1fa56", size = 1793557, upload-time = "2026-03-12T03:40:25.497Z" }, - { url = "https://files.pythonhosted.org/packages/43/10/d6c06a791d8124b843bf325ab4ac7d2f5b98731dff84d6064eafd687ded1/black-26.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:c7e72339f841b5a237ff14f7d3880ddd0fc7f98a1199e8c4327f9a4f478c1839", size = 1422766, upload-time = "2026-03-12T03:40:27.14Z" }, - { url = "https://files.pythonhosted.org/packages/59/4f/40a582c015f2d841ac24fed6390bd68f0fc896069ff3a886317959c9daf8/black-26.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:afc622538b430aa4c8c853f7f63bc582b3b8030fd8c80b70fb5fa5b834e575c2", size = 1232140, upload-time = "2026-03-12T03:40:28.882Z" }, - { url = "https://files.pythonhosted.org/packages/d5/da/e36e27c9cebc1311b7579210df6f1c86e50f2d7143ae4fcf8a5017dc8809/black-26.3.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2d6bfaf7fd0993b420bed691f20f9492d53ce9a2bcccea4b797d34e947318a78", size = 1889234, upload-time = "2026-03-12T03:40:30.964Z" }, - { url = "https://files.pythonhosted.org/packages/0e/7b/9871acf393f64a5fa33668c19350ca87177b181f44bb3d0c33b2d534f22c/black-26.3.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f89f2ab047c76a9c03f78d0d66ca519e389519902fa27e7a91117ef7611c0568", size = 1720522, upload-time = "2026-03-12T03:40:32.346Z" }, - { url = "https://files.pythonhosted.org/packages/03/87/e766c7f2e90c07fb7586cc787c9ae6462b1eedab390191f2b7fc7f6170a9/black-26.3.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b07fc0dab849d24a80a29cfab8d8a19187d1c4685d8a5e6385a5ce323c1f015f", size = 1787824, upload-time = "2026-03-12T03:40:33.636Z" }, - { url = "https://files.pythonhosted.org/packages/ac/94/2424338fb2d1875e9e83eed4c8e9c67f6905ec25afd826a911aea2b02535/black-26.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:0126ae5b7c09957da2bdbd91a9ba1207453feada9e9fe51992848658c6c8e01c", size = 1445855, upload-time = "2026-03-12T03:40:35.442Z" }, - { url = "https://files.pythonhosted.org/packages/86/43/0c3338bd928afb8ee7471f1a4eec3bdbe2245ccb4a646092a222e8669840/black-26.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:92c0ec1f2cc149551a2b7b47efc32c866406b6891b0ee4625e95967c8f4acfb1", size = 1258109, upload-time = "2026-03-12T03:40:36.832Z" }, - { url = "https://files.pythonhosted.org/packages/8e/0d/52d98722666d6fc6c3dd4c76df339501d6efd40e0ff95e6186a7b7f0befd/black-26.3.1-py3-none-any.whl", hash = "sha256:2bd5aa94fc267d38bb21a70d7410a89f1a1d318841855f698746f8e7f51acd1b", size = 207542, upload-time = "2026-03-12T03:36:01.668Z" }, -] - -[[package]] -name = "click" -version = "8.1.8" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version == '3.9.*'", - "python_full_version >= '3.8.1' and python_full_version < '3.9'", - "python_full_version < '3.8.1'", -] -dependencies = [ - { name = "colorama", marker = "python_full_version < '3.10' and sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" }, -] - -[[package]] -name = "click" -version = "8.3.3" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.15'", - "python_full_version >= '3.12' and python_full_version < '3.15'", - "python_full_version == '3.11.*'", - "python_full_version == '3.10.*'", -] -dependencies = [ - { name = "colorama", marker = "python_full_version >= '3.10' and sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" }, + { url = "https://files.pythonhosted.org/packages/ad/81/8e983840c6e5b93b33c2ba81aa3d52c2e42f0e9a690ce7607a2e61da4a5c/charset_normalizer-3.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cd6280cf040f233bd7d3407b743b4b4c74f70e8e1c4199cb112a62c941c0772a", size = 322240, upload-time = "2026-07-07T14:32:36.236Z" }, + { url = "https://files.pythonhosted.org/packages/de/d1/b4319dc3229d8272fba305e206fc0a148e2de8d4087917ce62ae6382f359/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa99adc8f081b475a12843953db36831eaf83ec33eb46a90629ca6a5de45a616", size = 216475, upload-time = "2026-07-07T14:32:38.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/33/6c99c1b3e6b8bf730e1bc809b9a2608f224145069114c479a2e9e1494346/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c1225416b463483160e4af85d5fc3a9690ccb53fd4b1865a6437825f5ede3209", size = 238670, upload-time = "2026-07-07T14:32:39.658Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f4/ffbb83546e1f198ecc70ecd372b65cf2b50f9068b380abd67640f17a8e18/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:16d10d789dd9bcca1173c95af82c58433122564b7bc39385124be735a35cbe99", size = 233476, upload-time = "2026-07-07T14:32:41.155Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5f/b98b8da398637b551e427e7be922bdec19177dc54d6811dcdaa503f23aac/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bb41182d93ea91f60b4bc8fbf4c820c69ef8a12ab2d917f3f1834f1acad07e8", size = 223817, upload-time = "2026-07-07T14:32:42.592Z" }, + { url = "https://files.pythonhosted.org/packages/36/31/a276bb2e66243072a3fd06fdcab9cbb61a305b02143d70d2bda21d888fa8/charset_normalizer-3.4.9-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:bcf74c1df76758a395bf0af608c04c82257523f55c9868b334f06270d0f2112b", size = 207974, upload-time = "2026-07-07T14:32:44.258Z" }, + { url = "https://files.pythonhosted.org/packages/5e/be/7ee4453d7e88dfbc4104ccd34900b9f2c7c17dac22881865fe0e82424a25/charset_normalizer-3.4.9-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b5314963fce9b0b12743891de876e724997864ee22aa496f903f426c7e2fa5b2", size = 221655, upload-time = "2026-07-07T14:32:45.64Z" }, + { url = "https://files.pythonhosted.org/packages/1d/85/181c652953eb5276d198f375b1dd641047392050098100a3a02d6534f657/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e9701d0049d92c16703a42771b98d560b95248949f23f8cf7b4eddd201814fb9", size = 219229, upload-time = "2026-07-07T14:32:47.376Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e7/aaf6da33fc9f4691cda8f7efbc9f69179d3d39ec8a4799baf273ee1d8db0/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:65a7ff3f705e57d392f7261b6d0550fe137c3019477431f1c355e0db0a7d3e15", size = 209704, upload-time = "2026-07-07T14:32:48.855Z" }, + { url = "https://files.pythonhosted.org/packages/63/01/f2fb3bd3a73be48b173ee0c6aa8d2497af97d5663a8c4c4b491de4c62f7a/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79580094b00d1789d1f93ea55bc43cb2f611910c72235b7657f3482ddcc1b22d", size = 226243, upload-time = "2026-07-07T14:32:50.239Z" }, + { url = "https://files.pythonhosted.org/packages/c4/02/c57a22739fe05246b0b5783b3bfb6afaac4eebb46f3ececdfb2f048f780e/charset_normalizer-3.4.9-cp310-cp310-win32.whl", hash = "sha256:432786d3561e69aeeae6c7e8648964ce0ad05736120135601f87ac26b9c83381", size = 150935, upload-time = "2026-07-07T14:32:51.676Z" }, + { url = "https://files.pythonhosted.org/packages/37/8d/ca39a7559a4797505530d084fd3a49a2c959efbbbff146302fb7be4e3b35/charset_normalizer-3.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:8c041122946b7ba21bb32c45b1aa57b1be35527690aeb3c5c234521085632eee", size = 162314, upload-time = "2026-07-07T14:32:53.193Z" }, + { url = "https://files.pythonhosted.org/packages/01/da/a44bd7a13d426e69e4894557106cd58669097bfad4a8681123b618fbfc5d/charset_normalizer-3.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:375b83ed0aecfce76c16d198fbc21f3b11b337d68662bea0a995046682a11419", size = 153075, upload-time = "2026-07-07T14:32:54.554Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e3/85ec501f206fb049259288c1f3506e53876937fb00edb47009348e66756b/charset_normalizer-3.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0e94703ec9684807f20cfb5eed95c70f67f2a8f21ad620146d7b5a13677b93e5", size = 317075, upload-time = "2026-07-07T14:32:56.021Z" }, + { url = "https://files.pythonhosted.org/packages/c3/69/2a5385192e67175f7d8bd5ce4f57c24bc956439adeae5c13a99aa28a53d1/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a441ea71902098ffe78c5abe6c494f44160b4af614ed16c3d9a3b1d17fd8ee2", size = 213837, upload-time = "2026-07-07T14:32:57.78Z" }, + { url = "https://files.pythonhosted.org/packages/b3/46/03ddc7da576d814fe0a36dd1f0fd3258e95404b4b2e3c026b7923d7e133f/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:304b13570067b2547562e308af560b3963857b1fa90bd6afd978130130fe2d6a", size = 235503, upload-time = "2026-07-07T14:32:59.205Z" }, + { url = "https://files.pythonhosted.org/packages/4e/6e/de0229a7ef40f6f9d28a837eebf4ec47bdca5dab4e900c84f22919af636a/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4773092f8019072343a7447203308b176e10199920eb02d6195e81bbb3274c29", size = 229944, upload-time = "2026-07-07T14:33:00.803Z" }, + { url = "https://files.pythonhosted.org/packages/a5/34/49b9060e8418b14fb5cba9cf6bfb383111e2538a03a1fb18e66a95aeb3d5/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:04ce310cb89c15df659582aee80a0603788732a5e017d5bd5c81158106ce249c", size = 221276, upload-time = "2026-07-07T14:33:02.199Z" }, + { url = "https://files.pythonhosted.org/packages/44/95/80282cce0fae9c3061203d723ee87da996aed79679e65d8935050ee7ca1f/charset_normalizer-3.4.9-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:c0323c9daef75ef2e5083624b4585018a0c9d5e3b40f607eed81a311270b934b", size = 205260, upload-time = "2026-07-07T14:33:03.698Z" }, + { url = "https://files.pythonhosted.org/packages/0c/74/2f62c8821b969ea3bd67cc2e6976834f48ca5d12664d2559ebcd9bcfbed7/charset_normalizer-3.4.9-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:871ff67ea1aad4dfd91736464934d56b32dac49f9fbe16cddba36198a7b3a0db", size = 217786, upload-time = "2026-07-07T14:33:05.12Z" }, + { url = "https://files.pythonhosted.org/packages/d9/8d/feabb82cb49fcad14515b1d7d1ca4787b0da7fc723a212bf89bc9e0fac52/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:67830fc78e67501f47bb950471b2dcb9b35b140084429318e862895a8e89c993", size = 216798, upload-time = "2026-07-07T14:33:06.629Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ff/c946d63bc3786d5b84d960b0f7ab7e25b828486a946b5aa997625bcaf6a6/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3d92613ec25e43b05f042302531ec0f00b8445190e43325880cbd6ab7c2581da", size = 206429, upload-time = "2026-07-07T14:33:08.006Z" }, + { url = "https://files.pythonhosted.org/packages/af/ba/5e5007c370702f85d2ef75791fac7943ed41e080364a673b20142e430e3e/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:280081916dc341820640489a66e4696049401ef1cf6dd672f672e70ad915aca3", size = 223066, upload-time = "2026-07-07T14:33:09.783Z" }, + { url = "https://files.pythonhosted.org/packages/83/d5/9096aa3cf532dfad237861544eb47a0f20d5adbf1039760fed8eaae935d9/charset_normalizer-3.4.9-cp311-cp311-win32.whl", hash = "sha256:ac351b3b8014eead140e77e9717e2992c6bbe30b63bc3422422eb84865412e3d", size = 150456, upload-time = "2026-07-07T14:33:11.217Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a1/e29995109e455dc8eff8d0fac6ae509be39561318a7cfeac5d33ad029213/charset_normalizer-3.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:6366a16e1a25018694d6a5d784d09b046edc9eac40ea2b54065c3052672516a1", size = 161410, upload-time = "2026-07-07T14:33:12.743Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8d/1569f4d0032d6ba2a4fe4591c35bf87868c600c41a71eb5c2e1ffa8464c2/charset_normalizer-3.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:1d22856ffbe153a602df38e4a5464f0b748a54002e0d69ac6d2ad0a197cc99ec", size = 152649, upload-time = "2026-07-07T14:33:14.173Z" }, + { url = "https://files.pythonhosted.org/packages/70/4a/ecbd131485c07fcdfad54e28946d513e3da22ef3b4bd854dcafae54ec739/charset_normalizer-3.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0", size = 319300, upload-time = "2026-07-07T14:33:15.666Z" }, + { url = "https://files.pythonhosted.org/packages/ec/96/5d9364e3342d69f3a045e1777bc47c85c383e6e9466d561b33fdb419d1f9/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9", size = 215802, upload-time = "2026-07-07T14:33:17.031Z" }, + { url = "https://files.pythonhosted.org/packages/4b/4c/5361f9aa7f2cb58d94f2ab831b3d493f69efb1d239654b4744e3c09527cb/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44", size = 237171, upload-time = "2026-07-07T14:33:18.576Z" }, + { url = "https://files.pythonhosted.org/packages/50/78/ce342ca4ff30b2eb49fe6d9578df85974f90c67d294113e94efdd9664cbd/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9", size = 233075, upload-time = "2026-07-07T14:33:20.084Z" }, + { url = "https://files.pythonhosted.org/packages/01/c4/4fa4c8b3097a11f3c5f09a35b72ed6855fb1d332469504962ab7bafcc702/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd", size = 224256, upload-time = "2026-07-07T14:33:21.747Z" }, + { url = "https://files.pythonhosted.org/packages/87/3a/ad914516df7e358a81aae018caa5e0470ba827fa6d763b1d2e87d920a5f6/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84", size = 208784, upload-time = "2026-07-07T14:33:23.313Z" }, + { url = "https://files.pythonhosted.org/packages/d7/74/3c12f9755717dfe5c5c87da63f35d765fa0c00382ec26bf23f7fae34f2ba/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b", size = 219928, upload-time = "2026-07-07T14:33:24.814Z" }, + { url = "https://files.pythonhosted.org/packages/33/9a/895095b83e7907abd6d3d99aad3a38ad0d9686cc186cb0c94c24320fe63e/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde", size = 218489, upload-time = "2026-07-07T14:33:26.42Z" }, + { url = "https://files.pythonhosted.org/packages/a1/34/ef5c05f412f42520d7709b7d3784d19640839eb7366ded1755511585429f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39", size = 210267, upload-time = "2026-07-07T14:33:27.952Z" }, + { url = "https://files.pythonhosted.org/packages/83/dc/9b29fa4412b318bf3bfea985c35d67eb55e04b59a7c3f2237168b0e0be6f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62", size = 226030, upload-time = "2026-07-07T14:33:29.397Z" }, + { url = "https://files.pythonhosted.org/packages/0e/42/6dbc00b8cd16011691203e33570fa42ed5746599a2e878112d16eab403a3/charset_normalizer-3.4.9-cp312-cp312-win32.whl", hash = "sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642", size = 151185, upload-time = "2026-07-07T14:33:30.781Z" }, + { url = "https://files.pythonhosted.org/packages/80/cc/f920afd1a23c58ccd53c1d36085a71893a4737ff5e66e0371efab6809850/charset_normalizer-3.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0", size = 162557, upload-time = "2026-07-07T14:33:32.176Z" }, + { url = "https://files.pythonhosted.org/packages/f0/e6/0386d43a261ff4e4b30c5857af7df877254b46bec7b9d1b74b6bf969a90b/charset_normalizer-3.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2", size = 152665, upload-time = "2026-07-07T14:33:33.711Z" }, + { url = "https://files.pythonhosted.org/packages/b2/06/97ec2aeae780b31d742b6352218b43841a6871e2564578ca522dce4a45c3/charset_normalizer-3.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614", size = 317688, upload-time = "2026-07-07T14:33:35.408Z" }, + { url = "https://files.pythonhosted.org/packages/d0/39/8ff066c672434225f8d25f8b739f992af250944392173dcc88362681c9bf/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698", size = 214982, upload-time = "2026-07-07T14:33:36.996Z" }, + { url = "https://files.pythonhosted.org/packages/92/8f/3a47a3667c83c2df9483d91644c6c107de3bf8874aa1793da9d3012eb986/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b", size = 236460, upload-time = "2026-07-07T14:33:38.536Z" }, + { url = "https://files.pythonhosted.org/packages/f1/60/b22cdbee7e4013dab8b0d7647fc6181120fbbbc8f7025c226d15bd5a47fc/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9", size = 232003, upload-time = "2026-07-07T14:33:40.059Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f8/72eb13dcabe7257035cea8aefd922caad2f110d252bf9f67c4c2ca763aee/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33", size = 223149, upload-time = "2026-07-07T14:33:41.631Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3e/faee8f9de92b14ee1198e9163252bb15efee7301b31256a3b6d9ebfdd0dd/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63", size = 207901, upload-time = "2026-07-07T14:33:43.209Z" }, + { url = "https://files.pythonhosted.org/packages/3a/25/45f30093ae27dd7b92a793b61882a38685f993700113ca36e0c9c14965e1/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0", size = 219176, upload-time = "2026-07-07T14:33:44.725Z" }, + { url = "https://files.pythonhosted.org/packages/48/18/c8f397329c35e32f6a837e488986f4ae03bd2abebc453b48714991630c2f/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe", size = 217356, upload-time = "2026-07-07T14:33:46.192Z" }, + { url = "https://files.pythonhosted.org/packages/86/7e/5ce0bba863470fd1902d5e5843968951bddf38abe4742fc97116ef4598b3/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35", size = 209614, upload-time = "2026-07-07T14:33:47.705Z" }, + { url = "https://files.pythonhosted.org/packages/6c/ef/2473d3c4d869155be4af1191111d59c4d5c4e0173026f7e85b176e23bf65/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8", size = 224991, upload-time = "2026-07-07T14:33:49.238Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a3/53ddae3db108a088156aa8ddfafd411ebbc1340f48c5573f697b27f69a39/charset_normalizer-3.4.9-cp313-cp313-win32.whl", hash = "sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9", size = 150622, upload-time = "2026-07-07T14:33:50.711Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ef/6953a77c7cf2c2ff9998e6f575ab3e380119f100223381565a4f94c1f836/charset_normalizer-3.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115", size = 161947, upload-time = "2026-07-07T14:33:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/6e/fb/d560d1d1555debbfe7849d9cac6145c1b537709d79576bf22557ed803b82/charset_normalizer-3.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012", size = 152594, upload-time = "2026-07-07T14:33:53.486Z" }, + { url = "https://files.pythonhosted.org/packages/7e/8d/496817fa0944239ecae662dd57ea765cfeaec6a735f9f025d4b7b72e7143/charset_normalizer-3.4.9-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:0327fcd59a935777d83410750c50600ee9571af2846f71ce40f25b13da1ef380", size = 317253, upload-time = "2026-07-07T14:33:54.994Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f9/ef4a69ea338ad3c0deceea0f5f7d2380ae8b52132b06d652cb0d2cd86706/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a79d9f4d8001473a30c163556b3c3bfebec837495a412dde78b51672f6134f9", size = 215898, upload-time = "2026-07-07T14:33:56.334Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e7/5ddfd76fc061eb52de219658a4aa431cbacadf0a0219c8854f00da50d289/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:33bdcc2a32c0a0e861f60841a512c8acc658c87c2ac59d89e3a46dacf7d866e4", size = 236718, upload-time = "2026-07-07T14:33:57.9Z" }, + { url = "https://files.pythonhosted.org/packages/49/ba/768fa3f36048d81c477a0ce61f813bc1454d80917ccfe550abd9f44f5e24/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f840ed6d8ecba8255df8c42b87fadeda98ddfc6eeec05e2dc66e26d46dd6f58a", size = 232519, upload-time = "2026-07-07T14:33:59.811Z" }, + { url = "https://files.pythonhosted.org/packages/f4/c4/b3e049d2aa3766180c78507110543d9d50894cc97f57de543f1be521dcdc/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c25fe15c70c59eb7c5ce8c06a1f3fa1da0ecc5ea1e7a5922c40fd2fa9b0d5046", size = 223143, upload-time = "2026-07-07T14:34:01.517Z" }, + { url = "https://files.pythonhosted.org/packages/19/79/55c32d06d76ae4feafe053f061f3e3ab70bcf19f4007797ce8c3efda7830/charset_normalizer-3.4.9-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:f7fb7d750cfa0a070d2c24e831fd3481019a60dd317ea2b39acbcebc08b6ed81", size = 206742, upload-time = "2026-07-07T14:34:03.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/e0/47c079dd82d217c807479cd59ffd30af56307ea31c108b75758970459ad3/charset_normalizer-3.4.9-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4d1c96a7a18b9690a4d46df09e3e3382406ae3213727cd1019ebade1c4a81917", size = 219191, upload-time = "2026-07-07T14:34:04.657Z" }, + { url = "https://files.pythonhosted.org/packages/42/ab/b9bc2e77d6b44a7e46ef62ec5cac1c9a6ba7b9135a5d560f002696ec9995/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a4cfde78a9f2880208d16a93b795726a3017d5977e08d1e162a7a31322479c41", size = 218328, upload-time = "2026-07-07T14:34:06.115Z" }, + { url = "https://files.pythonhosted.org/packages/f1/78/c9c71d599f5aa2d42bcdd35cbbd46d7f535351a57e40ff7d8e5a7e219401/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4d6fcde76f94f5cb9e43e9e9a61f16dacefd228cbbf6f1a09bd9b219a92f1a1", size = 207406, upload-time = "2026-07-07T14:34:07.554Z" }, + { url = "https://files.pythonhosted.org/packages/f6/39/c914445c321a845097ce4f6ac7de9a18228a77b766272125a1ce00d851eb/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:898f0e9068ca27d37f8e83a5b962821df851532e6c4a7d615c1c033f9da6eedf", size = 225157, upload-time = "2026-07-07T14:34:09.061Z" }, + { url = "https://files.pythonhosted.org/packages/9b/f2/c0d4b8508565a36bc5c624e88ed297f5b0b1095011034d7f5b83a69908b5/charset_normalizer-3.4.9-cp314-cp314-win32.whl", hash = "sha256:c1c948747b03be832dceed96ca815cef7360de9aa19d37c730f8e3f6101aca48", size = 151095, upload-time = "2026-07-07T14:34:10.901Z" }, + { url = "https://files.pythonhosted.org/packages/49/fd/a1d26144398c67486422a72bf5812cda22cb4ccfcd95a290fb41ceb4b8e2/charset_normalizer-3.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:16b65ea0f2465b6fb52aa22de5eca612aa964ddfec00a912e26f4656cbef890b", size = 162796, upload-time = "2026-07-07T14:34:12.47Z" }, + { url = "https://files.pythonhosted.org/packages/20/95/d75e82f8ce9fd323ebf059c16c9aadefb22a1ecde13b7840b35835e4886c/charset_normalizer-3.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:40a126142a56b2dfc0aacbad1de8310cbf60da7656db0e6b16eebd48e3e93519", size = 153334, upload-time = "2026-07-07T14:34:14.044Z" }, + { url = "https://files.pythonhosted.org/packages/00/5e/17398df3a139985ba9d11ed072531986f408c8fca952835ef1ab1820c02b/charset_normalizer-3.4.9-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:609b3ba8fcc0fb5ab7af00719d0fb6ad0cb518e48e7712d12fd68f1327951198", size = 338848, upload-time = "2026-07-07T14:34:15.688Z" }, + { url = "https://files.pythonhosted.org/packages/cd/91/7253a32e86b7e1d1239b1b36ba6dd0f021a21107ab33054b53119cc083b9/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51447e9aa2684679af07ca5021c3db526e0284347ebf4ffcec1154c3350cfe32", size = 223022, upload-time = "2026-07-07T14:34:17.248Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/2e64bd2be10e89c61e57ebe6a93fd98ae88eb7ebe414b5121f22c96c69eb/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cc1b0fff8ead343dae06305f954eb8468ba0ec1a97881f42489d198e4ce3c632", size = 241590, upload-time = "2026-07-07T14:34:18.813Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ef/d96ec496cfea0c21db43b0ad03891308b02388d054cc902cf0e5a1ad6a88/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa36ec09ef71d158186bc79e359ff5fdd6e7996fe8ab638f00d6b93139ba4fcf", size = 239584, upload-time = "2026-07-07T14:34:20.52Z" }, + { url = "https://files.pythonhosted.org/packages/d4/ce/9af95f7876194bd7a14e3dfe4a4de2e0bff02666a3910d72beafd06cc297/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df115d4d83168fdf2cae48ef1ff6d1cb4c466364e30861b37121de0f3bf1b990", size = 230224, upload-time = "2026-07-07T14:34:22.189Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/af74dde74a3996bd959c350709bfe50e297823d70a8c1cbd54b838880863/charset_normalizer-3.4.9-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:f86c6358749bd4fda175388691e3ba8c46e24c5347d0afd20f9b7edfc9faf07d", size = 212667, upload-time = "2026-07-07T14:34:23.857Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f0/f1c4fe746c395922961b5916ed1d7d6e7d4c84851d19ed43cc89980ec953/charset_normalizer-3.4.9-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:32286a2c8d167e897177b673176c1e3e00d4057caf5d2b64eef9a3666b03018e", size = 227179, upload-time = "2026-07-07T14:34:25.586Z" }, + { url = "https://files.pythonhosted.org/packages/e4/56/6c745619ac397e8871e2bcd3cea1eec86b877488f33888b3aef5c3ed506e/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:83aed2c10721ddd90f68140685391b50811a880af20654c59af6b6c66c40513c", size = 225372, upload-time = "2026-07-07T14:34:27.212Z" }, + { url = "https://files.pythonhosted.org/packages/78/ad/98aae8630ac71f16711968e38a5acfecce41b778bf2f0312851020f565a8/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cd6c3d4b783c556fa00bf540854e42f135e2f256abd29669fcd0da0f2dec79c2", size = 215222, upload-time = "2026-07-07T14:34:28.774Z" }, + { url = "https://files.pythonhosted.org/packages/f7/40/9593d54209765207a7f11073c06494c1721e4ca4a0a426c597679bf7f91e/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ee2f2a527e3c1a6e6411eb4209642e138b544a2d72fe5d0d76daf77b24063534", size = 231958, upload-time = "2026-07-07T14:34:30.345Z" }, + { url = "https://files.pythonhosted.org/packages/b1/27/693ee5e8a18191eb38647360c51cd505013e2bd3b366aa43fd5344c21e3c/charset_normalizer-3.4.9-cp314-cp314t-win32.whl", hash = "sha256:0d861473f743244d349b50f850d10eb87aeb22bbdcc8e64f79273c94af5a8226", size = 155580, upload-time = "2026-07-07T14:34:31.884Z" }, + { url = "https://files.pythonhosted.org/packages/80/3f/bd97d3d9c613013d07cb7733d299385b41df37f0471310f5a73dc359f0b8/charset_normalizer-3.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:9b8e0f3107e2200b76f6054de99016eac3ee6762713587b36baaa7e4bd2ae177", size = 167620, upload-time = "2026-07-07T14:34:33.438Z" }, + { url = "https://files.pythonhosted.org/packages/3d/c6/eee9dca4439b1061f76373f06ea855678cc4a64c1c3c90b50e479edbb8eb/charset_normalizer-3.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:19ac87f93086ce37b86e098888555c4b4bc48102279bae3350098c0ed664b501", size = 158037, upload-time = "2026-07-07T14:34:35.018Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ec/81e22253f4b7091eca6515bb3da5e45d05a663f7f567bb745695dc60f892/charset_normalizer-3.4.9-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:253a4a220747e8b5faf57ec320c4f5efb0cef05f647420bf267143ec15dba10a", size = 306122, upload-time = "2026-07-07T14:34:36.607Z" }, + { url = "https://files.pythonhosted.org/packages/c8/53/a8c042eb9eee4716f4d42a0f5a571eb32a09ec429be9fb0b8b9d765393ba/charset_normalizer-3.4.9-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:68ce9f4d6b26d5ccbf7fd4459bf75f74a0a146677ebba80597df60cbdb20e6f4", size = 206284, upload-time = "2026-07-07T14:34:38.166Z" }, + { url = "https://files.pythonhosted.org/packages/14/cb/1db8b96547ee3186cd2dd7f2e59dd560a9b80748f3604171f3c153d62811/charset_normalizer-3.4.9-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:58150c9f9b9a552505912d182ccdf26f6396fb6094816ceebcbb20eecabaed94", size = 226837, upload-time = "2026-07-07T14:34:39.77Z" }, + { url = "https://files.pythonhosted.org/packages/6a/05/c94d5cd23396289c54c93b02e0273b4dd8921641d9968c4828caf9bbaad9/charset_normalizer-3.4.9-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:df7276909358e5635ae203673ab7e509ddd224225a8d6b0790bf13eb2bde1cc5", size = 222199, upload-time = "2026-07-07T14:34:41.391Z" }, + { url = "https://files.pythonhosted.org/packages/6d/46/79847edd07244a4a2d443c6655a7b6ee94203c21539414b059f32713c357/charset_normalizer-3.4.9-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c09a49d6cde137258beb3d551994a2927fd35ad5cf96aed573f61bbd67c5f84", size = 214344, upload-time = "2026-07-07T14:34:42.986Z" }, + { url = "https://files.pythonhosted.org/packages/ec/b4/ef5a49b2e77c00deb43bb3256592b115ba9e4346016e82c516b8d215bf68/charset_normalizer-3.4.9-cp39-cp39-manylinux_2_31_armv7l.whl", hash = "sha256:231ddcbb35e2ff8973e1365db41fe0572662893b99a05deb183b68ad4c0c8bd4", size = 199988, upload-time = "2026-07-07T14:34:44.685Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ca/ad1d7c7d3077dab873f539d3e1d083c0845a762cb0bafdfbe3ef93add598/charset_normalizer-3.4.9-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:920079c3f7456fa213e0829ed2073aaa727fd39d889ead5b4f35d0de5460d04f", size = 211908, upload-time = "2026-07-07T14:34:46.227Z" }, + { url = "https://files.pythonhosted.org/packages/ed/61/710738687f90d01c06a04ed52d6ca1e62dd9b1d8cc2567098167c4691034/charset_normalizer-3.4.9-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:0fa1aec2d32bcc03c8fa0f6f1712caad1adc38509f31142112e5c9daf5b9c833", size = 209320, upload-time = "2026-07-07T14:34:47.753Z" }, + { url = "https://files.pythonhosted.org/packages/5f/c0/6eec7bdabe6cbbcc274ec04596f6d93865751a0541d33d60d1ce179bd372/charset_normalizer-3.4.9-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:ad41ba96094304aa090f5a30cb6e4fb3b3f1c264c523394b4c39bbacc4dc92ba", size = 200980, upload-time = "2026-07-07T14:34:49.362Z" }, + { url = "https://files.pythonhosted.org/packages/eb/78/59344ff9a4a7b5f6530bf7bec2c980047cc42c3a616596cdbd8cb5c1a1af/charset_normalizer-3.4.9-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:43b9e366a31fdd1c87d0eb08f579b4a82b723ea54338f040d6b4e518a026ea29", size = 216545, upload-time = "2026-07-07T14:34:50.98Z" }, + { url = "https://files.pythonhosted.org/packages/17/6d/bff78a4bacc4891bc63ec5bdc6776d8c85e47fab93d0d5f6223068fad0a4/charset_normalizer-3.4.9-cp39-cp39-win32.whl", hash = "sha256:93d59d504b230e83c7a843251681959a0b6a9cd76f6e146ce1b8a80eb8739af9", size = 146256, upload-time = "2026-07-07T14:34:52.509Z" }, + { url = "https://files.pythonhosted.org/packages/a2/55/86048bde1c9d0352940bd7b87d825091a52aef67d01cde6c6f7342c5b552/charset_normalizer-3.4.9-cp39-cp39-win_amd64.whl", hash = "sha256:ddf4af30b417d9fe16481e9b81c27ab2a7cde1ff7ba3e85653b02db7d145dc7b", size = 156413, upload-time = "2026-07-07T14:34:54.117Z" }, + { url = "https://files.pythonhosted.org/packages/28/e9/9fb6099b868c82a40698a748ae0fbd4f31ccc13844c176a07158ba2abbfd/charset_normalizer-3.4.9-cp39-cp39-win_arm64.whl", hash = "sha256:476743fe6dfe14a2da12e3ac79125dc84a3b2cf8094369a47a1529b0cd8549fe", size = 147887, upload-time = "2026-07-07T14:34:55.51Z" }, + { url = "https://files.pythonhosted.org/packages/98/2b/f97f1c193fb855c345d678f5077d6926034db0722df74c8f057020e05a25/charset_normalizer-3.4.9-py3-none-any.whl", hash = "sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5", size = 64538, upload-time = "2026-07-07T14:34:56.993Z" }, ] [[package]] @@ -252,32 +221,382 @@ wheels = [ ] [[package]] -name = "dill" -version = "0.4.0" +name = "contourpy" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.8.1' and python_full_version < '3.9'", "python_full_version < '3.8.1'", ] -sdist = { url = "https://files.pythonhosted.org/packages/12/80/630b4b88364e9a8c8c5797f4602d0f76ef820909ee32f0bacb9f90654042/dill-0.4.0.tar.gz", hash = "sha256:0633f1d2df477324f53a895b02c901fb961bdbf65a17122586ea7019292cbcf0", size = 186976, upload-time = "2025-04-16T00:41:48.867Z" } +dependencies = [ + { name = "numpy", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/7d/087ee4295e7580d3f7eb8a8a4e0ec8c7847e60f34135248ccf831cf5bbfc/contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab", size = 13433167, upload-time = "2023-09-16T10:25:49.501Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/50/3d/9373ad9c56321fdab5b41197068e1d8c25883b3fea29dd361f9b55116869/dill-0.4.0-py3-none-any.whl", hash = "sha256:44f54bf6412c2c8464c14e8243eb163690a9800dbe2c367330883b19c7561049", size = 119668, upload-time = "2025-04-16T00:41:47.671Z" }, + { url = "https://files.pythonhosted.org/packages/fb/7f/c44a51a83a093bf5c84e07dd1e3cfe9f68c47b6499bd05a9de0c6dbdc2bc/contourpy-1.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:46e24f5412c948d81736509377e255f6040e94216bf1a9b5ea1eaa9d29f6ec1b", size = 247207, upload-time = "2023-09-16T10:20:32.848Z" }, + { url = "https://files.pythonhosted.org/packages/a9/65/544d66da0716b20084874297ff7596704e435cf011512f8e576638e83db2/contourpy-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e48694d6a9c5a26ee85b10130c77a011a4fedf50a7279fa0bdaf44bafb4299d", size = 232428, upload-time = "2023-09-16T10:20:36.337Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e6/697085cc34a294bd399548fd99562537a75408f113e3a815807e206246f0/contourpy-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a66045af6cf00e19d02191ab578a50cb93b2028c3eefed999793698e9ea768ae", size = 285304, upload-time = "2023-09-16T10:20:40.182Z" }, + { url = "https://files.pythonhosted.org/packages/69/4b/52d0d2e85c59f00f6ddbd6fea819f267008c58ee7708da96d112a293e91c/contourpy-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ebf42695f75ee1a952f98ce9775c873e4971732a87334b099dde90b6af6a916", size = 322655, upload-time = "2023-09-16T10:20:44.175Z" }, + { url = "https://files.pythonhosted.org/packages/82/fc/3decc656a547a6d5d5b4249f81c72668a1f3259a62b2def2504120d38746/contourpy-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6aec19457617ef468ff091669cca01fa7ea557b12b59a7908b9474bb9674cf0", size = 296430, upload-time = "2023-09-16T10:20:47.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/6b/e4b0f8708f22dd7c321f87eadbb98708975e115ac6582eb46d1f32197ce6/contourpy-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:462c59914dc6d81e0b11f37e560b8a7c2dbab6aca4f38be31519d442d6cde1a1", size = 301672, upload-time = "2023-09-16T10:20:51.395Z" }, + { url = "https://files.pythonhosted.org/packages/c3/87/201410522a756e605069078833d806147cad8532fdc164a96689d05c5afc/contourpy-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6d0a8efc258659edc5299f9ef32d8d81de8b53b45d67bf4bfa3067f31366764d", size = 820145, upload-time = "2023-09-16T10:20:58.426Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d9/42680a17d43edda04ab2b3f11125cf97b61bce5d3b52721a42960bf748bd/contourpy-1.1.1-cp310-cp310-win32.whl", hash = "sha256:d6ab42f223e58b7dac1bb0af32194a7b9311065583cc75ff59dcf301afd8a431", size = 399542, upload-time = "2023-09-16T10:21:02.719Z" }, + { url = "https://files.pythonhosted.org/packages/55/14/0dc1884e3c04f9b073a47283f5d424926644250891db392a07c56f05e5c5/contourpy-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:549174b0713d49871c6dee90a4b499d3f12f5e5f69641cd23c50a4542e2ca1eb", size = 477974, upload-time = "2023-09-16T10:21:07.565Z" }, + { url = "https://files.pythonhosted.org/packages/8b/4f/be28a39cd5e988b8d3c2cc642c2c7ffeeb28fe80a86df71b6d1e473c5038/contourpy-1.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:407d864db716a067cc696d61fa1ef6637fedf03606e8417fe2aeed20a061e6b2", size = 248613, upload-time = "2023-09-16T10:21:10.695Z" }, + { url = "https://files.pythonhosted.org/packages/2c/8e/656f8e7cd316aa68d9824744773e90dbd71f847429d10c82001e927480a2/contourpy-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe80c017973e6a4c367e037cb31601044dd55e6bfacd57370674867d15a899b", size = 233603, upload-time = "2023-09-16T10:21:13.771Z" }, + { url = "https://files.pythonhosted.org/packages/60/2a/4d4bd4541212ab98f3411f21bf58b0b246f333ae996e9f57e1acf12bcc45/contourpy-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e30aaf2b8a2bac57eb7e1650df1b3a4130e8d0c66fc2f861039d507a11760e1b", size = 287037, upload-time = "2023-09-16T10:21:17.622Z" }, + { url = "https://files.pythonhosted.org/packages/24/67/8abf919443381585a4eee74069e311c736350549dae02d3d014fef93d50a/contourpy-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3de23ca4f381c3770dee6d10ead6fff524d540c0f662e763ad1530bde5112532", size = 323274, upload-time = "2023-09-16T10:21:21.404Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6da11329dd35a2f2e404a95e5374b5702de6ac52e776e8b87dd6ea4b29d0/contourpy-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:566f0e41df06dfef2431defcfaa155f0acfa1ca4acbf8fd80895b1e7e2ada40e", size = 297801, upload-time = "2023-09-16T10:21:25.155Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f6/78f60fa0b6ae64971178e2542e8b3ad3ba5f4f379b918ab7b18038a3f897/contourpy-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b04c2f0adaf255bf756cf08ebef1be132d3c7a06fe6f9877d55640c5e60c72c5", size = 302821, upload-time = "2023-09-16T10:21:28.663Z" }, + { url = "https://files.pythonhosted.org/packages/da/25/6062395a1c6a06f46a577da821318886b8b939453a098b9cd61671bb497b/contourpy-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d0c188ae66b772d9d61d43c6030500344c13e3f73a00d1dc241da896f379bb62", size = 820121, upload-time = "2023-09-16T10:21:36.251Z" }, + { url = "https://files.pythonhosted.org/packages/41/5e/64e78b1e8682cbab10c13fc1a2c070d30acedb805ab2f42afbd3d88f7225/contourpy-1.1.1-cp311-cp311-win32.whl", hash = "sha256:0683e1ae20dc038075d92e0e0148f09ffcefab120e57f6b4c9c0f477ec171f33", size = 401590, upload-time = "2023-09-16T10:21:40.42Z" }, + { url = "https://files.pythonhosted.org/packages/e5/76/94bc17eb868f8c7397f8fdfdeae7661c1b9a35f3a7219da308596e8c252a/contourpy-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:8636cd2fc5da0fb102a2504fa2c4bea3cbc149533b345d72cdf0e7a924decc45", size = 480534, upload-time = "2023-09-16T10:21:45.724Z" }, + { url = "https://files.pythonhosted.org/packages/94/0f/07a5e26fec7176658f6aecffc615900ff1d303baa2b67bc37fd98ce67c87/contourpy-1.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:560f1d68a33e89c62da5da4077ba98137a5e4d3a271b29f2f195d0fba2adcb6a", size = 249799, upload-time = "2023-09-16T10:21:48.797Z" }, + { url = "https://files.pythonhosted.org/packages/32/0b/d7baca3f60d3b3a77c9ba1307c7792befd3c1c775a26c649dca1bfa9b6ba/contourpy-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:24216552104ae8f3b34120ef84825400b16eb6133af2e27a190fdc13529f023e", size = 232739, upload-time = "2023-09-16T10:21:51.854Z" }, + { url = "https://files.pythonhosted.org/packages/6d/62/a385b4d4b5718e3a933de5791528f45f1f5b364d3c79172ad0309c832041/contourpy-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56de98a2fb23025882a18b60c7f0ea2d2d70bbbcfcf878f9067234b1c4818442", size = 282171, upload-time = "2023-09-16T10:21:55.794Z" }, + { url = "https://files.pythonhosted.org/packages/91/21/8c6819747fea53557f3963ca936035b3e8bed87d591f5278ad62516a059d/contourpy-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:07d6f11dfaf80a84c97f1a5ba50d129d9303c5b4206f776e94037332e298dda8", size = 321182, upload-time = "2023-09-16T10:21:59.576Z" }, + { url = "https://files.pythonhosted.org/packages/22/29/d75da9002f9df09c755b12cf0357eb91b081c858e604f4e92b4b8bfc3c15/contourpy-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1eaac5257a8f8a047248d60e8f9315c6cff58f7803971170d952555ef6344a7", size = 295869, upload-time = "2023-09-16T10:22:03.248Z" }, + { url = "https://files.pythonhosted.org/packages/a7/47/4e7e66159f881c131e3b97d1cc5c0ea72be62bdd292c7f63fd13937d07f4/contourpy-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19557fa407e70f20bfaba7d55b4d97b14f9480856c4fb65812e8a05fe1c6f9bf", size = 298756, upload-time = "2023-09-16T10:22:06.663Z" }, + { url = "https://files.pythonhosted.org/packages/d3/bb/bffc99bc3172942b5eda8027ca0cb80ddd336fcdd634d68adce957d37231/contourpy-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:081f3c0880712e40effc5f4c3b08feca6d064cb8cfbb372ca548105b86fd6c3d", size = 818441, upload-time = "2023-09-16T10:22:13.805Z" }, + { url = "https://files.pythonhosted.org/packages/da/1b/904baf0aaaf6c6e2247801dcd1ff0d7bf84352839927d356b28ae804cbb0/contourpy-1.1.1-cp312-cp312-win32.whl", hash = "sha256:059c3d2a94b930f4dafe8105bcdc1b21de99b30b51b5bce74c753686de858cb6", size = 410294, upload-time = "2023-09-16T10:22:18.055Z" }, + { url = "https://files.pythonhosted.org/packages/75/d4/c3b7a9a0d1f99b528e5a46266b0b9f13aad5a0dd1156d071418df314c427/contourpy-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f44d78b61740e4e8c71db1cf1fd56d9050a4747681c59ec1094750a658ceb970", size = 486678, upload-time = "2023-09-16T10:22:23.249Z" }, + { url = "https://files.pythonhosted.org/packages/02/7e/ffaba1bf3719088be3ad6983a5e85e1fc9edccd7b406b98e433436ecef74/contourpy-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:70e5a10f8093d228bb2b552beeb318b8928b8a94763ef03b858ef3612b29395d", size = 247023, upload-time = "2023-09-16T10:22:26.954Z" }, + { url = "https://files.pythonhosted.org/packages/a6/82/29f5ff4ae074c3230e266bc9efef449ebde43721a727b989dd8ef8f97d73/contourpy-1.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8394e652925a18ef0091115e3cc191fef350ab6dc3cc417f06da66bf98071ae9", size = 232380, upload-time = "2023-09-16T10:22:30.423Z" }, + { url = "https://files.pythonhosted.org/packages/9b/cb/08f884c4c2efd433a38876b1b8069bfecef3f2d21ff0ce635d455962f70f/contourpy-1.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5bd5680f844c3ff0008523a71949a3ff5e4953eb7701b28760805bc9bcff217", size = 285830, upload-time = "2023-09-16T10:22:33.787Z" }, + { url = "https://files.pythonhosted.org/packages/8e/57/cd4d4c99d999a25e9d518f628b4793e64b1ecb8ad3147f8469d8d4a80678/contourpy-1.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66544f853bfa85c0d07a68f6c648b2ec81dafd30f272565c37ab47a33b220684", size = 322038, upload-time = "2023-09-16T10:22:37.627Z" }, + { url = "https://files.pythonhosted.org/packages/32/b6/c57ed305a6f86731107fc183e97c7e6a6005d145f5c5228a44718082ad12/contourpy-1.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0c02b75acfea5cab07585d25069207e478d12309557f90a61b5a3b4f77f46ce", size = 295797, upload-time = "2023-09-16T10:22:41.952Z" }, + { url = "https://files.pythonhosted.org/packages/8e/71/7f20855592cc929bc206810432b991ec4c702dc26b0567b132e52c85536f/contourpy-1.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41339b24471c58dc1499e56783fedc1afa4bb018bcd035cfb0ee2ad2a7501ef8", size = 301124, upload-time = "2023-09-16T10:22:45.993Z" }, + { url = "https://files.pythonhosted.org/packages/86/6d/52c2fc80f433e7cdc8624d82e1422ad83ad461463cf16a1953bbc7d10eb1/contourpy-1.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f29fb0b3f1217dfe9362ec55440d0743fe868497359f2cf93293f4b2701b8251", size = 819787, upload-time = "2023-09-16T10:22:53.511Z" }, + { url = "https://files.pythonhosted.org/packages/d0/b0/f8d4548e89f929d6c5ca329df9afad6190af60079ec77d8c31eb48cf6f82/contourpy-1.1.1-cp38-cp38-win32.whl", hash = "sha256:f9dc7f933975367251c1b34da882c4f0e0b2e24bb35dc906d2f598a40b72bfc7", size = 400031, upload-time = "2023-09-16T10:22:57.78Z" }, + { url = "https://files.pythonhosted.org/packages/96/1b/b05cd42c8d21767a0488b883b38658fb9a45f86c293b7b42521a8113dc5d/contourpy-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:498e53573e8b94b1caeb9e62d7c2d053c263ebb6aa259c81050766beb50ff8d9", size = 477949, upload-time = "2023-09-16T10:23:02.587Z" }, + { url = "https://files.pythonhosted.org/packages/16/d9/8a15ff67fc27c65939e454512955e1b240ec75cd201d82e115b3b63ef76d/contourpy-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ba42e3810999a0ddd0439e6e5dbf6d034055cdc72b7c5c839f37a7c274cb4eba", size = 247396, upload-time = "2023-09-16T10:23:06.429Z" }, + { url = "https://files.pythonhosted.org/packages/09/fe/086e6847ee53da10ddf0b6c5e5f877ab43e68e355d2f4c85f67561ee8a57/contourpy-1.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6c06e4c6e234fcc65435223c7b2a90f286b7f1b2733058bdf1345d218cc59e34", size = 232598, upload-time = "2023-09-16T10:23:11.009Z" }, + { url = "https://files.pythonhosted.org/packages/a3/9c/662925239e1185c6cf1da8c334e4c61bddcfa8e528f4b51083b613003170/contourpy-1.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca6fab080484e419528e98624fb5c4282148b847e3602dc8dbe0cb0669469887", size = 286436, upload-time = "2023-09-16T10:23:14.624Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7e/417cdf65da7140981079eda6a81ecd593ae0239bf8c738f2e2b3f6df8920/contourpy-1.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93df44ab351119d14cd1e6b52a5063d3336f0754b72736cc63db59307dabb718", size = 322629, upload-time = "2023-09-16T10:23:18.203Z" }, + { url = "https://files.pythonhosted.org/packages/a8/22/ffd88aef74cc045698c5e5c400e8b7cd62311199c109245ac7827290df2c/contourpy-1.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eafbef886566dc1047d7b3d4b14db0d5b7deb99638d8e1be4e23a7c7ac59ff0f", size = 297117, upload-time = "2023-09-16T10:23:21.586Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/24c34c41a180f875419b536125799c61e2330b997d77a5a818a3bc3e08cd/contourpy-1.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efe0fab26d598e1ec07d72cf03eaeeba8e42b4ecf6b9ccb5a356fde60ff08b85", size = 301855, upload-time = "2023-09-16T10:23:25.584Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ec/f9877f6378a580cd683bd76c8a781dcd972e82965e0da951a739d3364677/contourpy-1.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f08e469821a5e4751c97fcd34bcb586bc243c39c2e39321822060ba902eac49e", size = 820597, upload-time = "2023-09-16T10:23:33.133Z" }, + { url = "https://files.pythonhosted.org/packages/e1/3a/c41f4bc7122d3a06388acae1bed6f50a665c1031863ca42bd701094dcb1f/contourpy-1.1.1-cp39-cp39-win32.whl", hash = "sha256:bfc8a5e9238232a45ebc5cb3bfee71f1167064c8d382cadd6076f0d51cff1da0", size = 400031, upload-time = "2023-09-16T10:23:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/87/2b/9b49451f7412cc1a79198e94a771a4e52d65c479aae610b1161c0290ef2c/contourpy-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:c84fdf3da00c2827d634de4fcf17e3e067490c4aea82833625c4c8e6cdea0887", size = 435965, upload-time = "2023-09-16T10:23:42.512Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3c/fc36884b6793e2066a6ff25c86e21b8bd62553456b07e964c260bcf22711/contourpy-1.1.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:229a25f68046c5cf8067d6d6351c8b99e40da11b04d8416bf8d2b1d75922521e", size = 246493, upload-time = "2023-09-16T10:23:45.721Z" }, + { url = "https://files.pythonhosted.org/packages/3d/85/f4c5b09ce79828ed4553a8ae2ebdf937794f57b45848b1f5c95d9744ecc2/contourpy-1.1.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a10dab5ea1bd4401c9483450b5b0ba5416be799bbd50fc7a6cc5e2a15e03e8a3", size = 289240, upload-time = "2023-09-16T10:23:49.207Z" }, + { url = "https://files.pythonhosted.org/packages/18/d3/9d7c0a372baf5130c1417a4b8275079d5379c11355436cb9fc78af7d7559/contourpy-1.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4f9147051cb8fdb29a51dc2482d792b3b23e50f8f57e3720ca2e3d438b7adf23", size = 476043, upload-time = "2023-09-16T10:23:54.495Z" }, + { url = "https://files.pythonhosted.org/packages/e7/12/643242c3d9b031ca19f9a440f63e568dd883a04711056ca5d607f9bda888/contourpy-1.1.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a75cc163a5f4531a256f2c523bd80db509a49fc23721b36dd1ef2f60ff41c3cb", size = 246247, upload-time = "2023-09-16T10:23:58.204Z" }, + { url = "https://files.pythonhosted.org/packages/e1/37/95716fe235bf441422059e4afcd4b9b7c5821851c2aee992a06d1e9f831a/contourpy-1.1.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b53d5769aa1f2d4ea407c65f2d1d08002952fac1d9e9d307aa2e1023554a163", size = 289029, upload-time = "2023-09-16T10:24:02.085Z" }, + { url = "https://files.pythonhosted.org/packages/e5/fd/14852c4a688031e0d8a20d9a1b60078d45507186ef17042093835be2f01a/contourpy-1.1.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11b836b7dbfb74e049c302bbf74b4b8f6cb9d0b6ca1bf86cfa8ba144aedadd9c", size = 476043, upload-time = "2023-09-16T10:24:07.292Z" }, ] [[package]] -name = "dill" -version = "0.4.1" +name = "contourpy" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/f6/31a8f28b4a2a4fa0e01085e542f3081ab0588eff8e589d39d775172c9792/contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4", size = 13464370, upload-time = "2024-08-27T21:00:03.328Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/e0/be8dcc796cfdd96708933e0e2da99ba4bb8f9b2caa9d560a50f3f09a65f3/contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7", size = 265366, upload-time = "2024-08-27T20:50:09.947Z" }, + { url = "https://files.pythonhosted.org/packages/50/d6/c953b400219443535d412fcbbc42e7a5e823291236bc0bb88936e3cc9317/contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42", size = 249226, upload-time = "2024-08-27T20:50:16.1Z" }, + { url = "https://files.pythonhosted.org/packages/6f/b4/6fffdf213ffccc28483c524b9dad46bb78332851133b36ad354b856ddc7c/contourpy-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:92f8557cbb07415a4d6fa191f20fd9d2d9eb9c0b61d1b2f52a8926e43c6e9af7", size = 308460, upload-time = "2024-08-27T20:50:22.536Z" }, + { url = "https://files.pythonhosted.org/packages/cf/6c/118fc917b4050f0afe07179a6dcbe4f3f4ec69b94f36c9e128c4af480fb8/contourpy-1.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36f965570cff02b874773c49bfe85562b47030805d7d8360748f3eca570f4cab", size = 347623, upload-time = "2024-08-27T20:50:28.806Z" }, + { url = "https://files.pythonhosted.org/packages/f9/a4/30ff110a81bfe3abf7b9673284d21ddce8cc1278f6f77393c91199da4c90/contourpy-1.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cacd81e2d4b6f89c9f8a5b69b86490152ff39afc58a95af002a398273e5ce589", size = 317761, upload-time = "2024-08-27T20:50:35.126Z" }, + { url = "https://files.pythonhosted.org/packages/99/e6/d11966962b1aa515f5586d3907ad019f4b812c04e4546cc19ebf62b5178e/contourpy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69375194457ad0fad3a839b9e29aa0b0ed53bb54db1bfb6c3ae43d111c31ce41", size = 322015, upload-time = "2024-08-27T20:50:40.318Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e3/182383743751d22b7b59c3c753277b6aee3637049197624f333dac5b4c80/contourpy-1.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a52040312b1a858b5e31ef28c2e865376a386c60c0e248370bbea2d3f3b760d", size = 1262672, upload-time = "2024-08-27T20:50:55.643Z" }, + { url = "https://files.pythonhosted.org/packages/78/53/974400c815b2e605f252c8fb9297e2204347d1755a5374354ee77b1ea259/contourpy-1.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3faeb2998e4fcb256542e8a926d08da08977f7f5e62cf733f3c211c2a5586223", size = 1321688, upload-time = "2024-08-27T20:51:11.293Z" }, + { url = "https://files.pythonhosted.org/packages/52/29/99f849faed5593b2926a68a31882af98afbeac39c7fdf7de491d9c85ec6a/contourpy-1.3.0-cp310-cp310-win32.whl", hash = "sha256:36e0cff201bcb17a0a8ecc7f454fe078437fa6bda730e695a92f2d9932bd507f", size = 171145, upload-time = "2024-08-27T20:51:15.2Z" }, + { url = "https://files.pythonhosted.org/packages/a9/97/3f89bba79ff6ff2b07a3cbc40aa693c360d5efa90d66e914f0ff03b95ec7/contourpy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:87ddffef1dbe5e669b5c2440b643d3fdd8622a348fe1983fad7a0f0ccb1cd67b", size = 216019, upload-time = "2024-08-27T20:51:19.365Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1f/9375917786cb39270b0ee6634536c0e22abf225825602688990d8f5c6c19/contourpy-1.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fa4c02abe6c446ba70d96ece336e621efa4aecae43eaa9b030ae5fb92b309ad", size = 266356, upload-time = "2024-08-27T20:51:24.146Z" }, + { url = "https://files.pythonhosted.org/packages/05/46/9256dd162ea52790c127cb58cfc3b9e3413a6e3478917d1f811d420772ec/contourpy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:834e0cfe17ba12f79963861e0f908556b2cedd52e1f75e6578801febcc6a9f49", size = 250915, upload-time = "2024-08-27T20:51:28.683Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5d/3056c167fa4486900dfbd7e26a2fdc2338dc58eee36d490a0ed3ddda5ded/contourpy-1.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbc4c3217eee163fa3984fd1567632b48d6dfd29216da3ded3d7b844a8014a66", size = 310443, upload-time = "2024-08-27T20:51:33.675Z" }, + { url = "https://files.pythonhosted.org/packages/ca/c2/1a612e475492e07f11c8e267ea5ec1ce0d89971be496c195e27afa97e14a/contourpy-1.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4865cd1d419e0c7a7bf6de1777b185eebdc51470800a9f42b9e9decf17762081", size = 348548, upload-time = "2024-08-27T20:51:39.322Z" }, + { url = "https://files.pythonhosted.org/packages/45/cf/2c2fc6bb5874158277b4faf136847f0689e1b1a1f640a36d76d52e78907c/contourpy-1.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:303c252947ab4b14c08afeb52375b26781ccd6a5ccd81abcdfc1fafd14cf93c1", size = 319118, upload-time = "2024-08-27T20:51:44.717Z" }, + { url = "https://files.pythonhosted.org/packages/03/33/003065374f38894cdf1040cef474ad0546368eea7e3a51d48b8a423961f8/contourpy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637f674226be46f6ba372fd29d9523dd977a291f66ab2a74fbeb5530bb3f445d", size = 323162, upload-time = "2024-08-27T20:51:49.683Z" }, + { url = "https://files.pythonhosted.org/packages/42/80/e637326e85e4105a802e42959f56cff2cd39a6b5ef68d5d9aee3ea5f0e4c/contourpy-1.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76a896b2f195b57db25d6b44e7e03f221d32fe318d03ede41f8b4d9ba1bff53c", size = 1265396, upload-time = "2024-08-27T20:52:04.926Z" }, + { url = "https://files.pythonhosted.org/packages/7c/3b/8cbd6416ca1bbc0202b50f9c13b2e0b922b64be888f9d9ee88e6cfabfb51/contourpy-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e1fd23e9d01591bab45546c089ae89d926917a66dceb3abcf01f6105d927e2cb", size = 1324297, upload-time = "2024-08-27T20:52:21.843Z" }, + { url = "https://files.pythonhosted.org/packages/4d/2c/021a7afaa52fe891f25535506cc861c30c3c4e5a1c1ce94215e04b293e72/contourpy-1.3.0-cp311-cp311-win32.whl", hash = "sha256:d402880b84df3bec6eab53cd0cf802cae6a2ef9537e70cf75e91618a3801c20c", size = 171808, upload-time = "2024-08-27T20:52:25.163Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2f/804f02ff30a7fae21f98198828d0857439ec4c91a96e20cf2d6c49372966/contourpy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:6cb6cc968059db9c62cb35fbf70248f40994dfcd7aa10444bbf8b3faeb7c2d67", size = 217181, upload-time = "2024-08-27T20:52:29.13Z" }, + { url = "https://files.pythonhosted.org/packages/c9/92/8e0bbfe6b70c0e2d3d81272b58c98ac69ff1a4329f18c73bd64824d8b12e/contourpy-1.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:570ef7cf892f0afbe5b2ee410c507ce12e15a5fa91017a0009f79f7d93a1268f", size = 267838, upload-time = "2024-08-27T20:52:33.911Z" }, + { url = "https://files.pythonhosted.org/packages/e3/04/33351c5d5108460a8ce6d512307690b023f0cfcad5899499f5c83b9d63b1/contourpy-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:da84c537cb8b97d153e9fb208c221c45605f73147bd4cadd23bdae915042aad6", size = 251549, upload-time = "2024-08-27T20:52:39.179Z" }, + { url = "https://files.pythonhosted.org/packages/51/3d/aa0fe6ae67e3ef9f178389e4caaaa68daf2f9024092aa3c6032e3d174670/contourpy-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0be4d8425bfa755e0fd76ee1e019636ccc7c29f77a7c86b4328a9eb6a26d0639", size = 303177, upload-time = "2024-08-27T20:52:44.789Z" }, + { url = "https://files.pythonhosted.org/packages/56/c3/c85a7e3e0cab635575d3b657f9535443a6f5d20fac1a1911eaa4bbe1aceb/contourpy-1.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c0da700bf58f6e0b65312d0a5e695179a71d0163957fa381bb3c1f72972537c", size = 341735, upload-time = "2024-08-27T20:52:51.05Z" }, + { url = "https://files.pythonhosted.org/packages/dd/8d/20f7a211a7be966a53f474bc90b1a8202e9844b3f1ef85f3ae45a77151ee/contourpy-1.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb8b141bb00fa977d9122636b16aa67d37fd40a3d8b52dd837e536d64b9a4d06", size = 314679, upload-time = "2024-08-27T20:52:58.473Z" }, + { url = "https://files.pythonhosted.org/packages/6e/be/524e377567defac0e21a46e2a529652d165fed130a0d8a863219303cee18/contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3634b5385c6716c258d0419c46d05c8aa7dc8cb70326c9a4fb66b69ad2b52e09", size = 320549, upload-time = "2024-08-27T20:53:06.593Z" }, + { url = "https://files.pythonhosted.org/packages/0f/96/fdb2552a172942d888915f3a6663812e9bc3d359d53dafd4289a0fb462f0/contourpy-1.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0dce35502151b6bd35027ac39ba6e5a44be13a68f55735c3612c568cac3805fd", size = 1263068, upload-time = "2024-08-27T20:53:23.442Z" }, + { url = "https://files.pythonhosted.org/packages/2a/25/632eab595e3140adfa92f1322bf8915f68c932bac468e89eae9974cf1c00/contourpy-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea348f053c645100612b333adc5983d87be69acdc6d77d3169c090d3b01dc35", size = 1322833, upload-time = "2024-08-27T20:53:39.243Z" }, + { url = "https://files.pythonhosted.org/packages/73/e3/69738782e315a1d26d29d71a550dbbe3eb6c653b028b150f70c1a5f4f229/contourpy-1.3.0-cp312-cp312-win32.whl", hash = "sha256:90f73a5116ad1ba7174341ef3ea5c3150ddf20b024b98fb0c3b29034752c8aeb", size = 172681, upload-time = "2024-08-27T20:53:43.05Z" }, + { url = "https://files.pythonhosted.org/packages/0c/89/9830ba00d88e43d15e53d64931e66b8792b46eb25e2050a88fec4a0df3d5/contourpy-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b11b39aea6be6764f84360fce6c82211a9db32a7c7de8fa6dd5397cf1d079c3b", size = 218283, upload-time = "2024-08-27T20:53:47.232Z" }, + { url = "https://files.pythonhosted.org/packages/53/a1/d20415febfb2267af2d7f06338e82171824d08614084714fb2c1dac9901f/contourpy-1.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3e1c7fa44aaae40a2247e2e8e0627f4bea3dd257014764aa644f319a5f8600e3", size = 267879, upload-time = "2024-08-27T20:53:51.597Z" }, + { url = "https://files.pythonhosted.org/packages/aa/45/5a28a3570ff6218d8bdfc291a272a20d2648104815f01f0177d103d985e1/contourpy-1.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:364174c2a76057feef647c802652f00953b575723062560498dc7930fc9b1cb7", size = 251573, upload-time = "2024-08-27T20:53:55.659Z" }, + { url = "https://files.pythonhosted.org/packages/39/1c/d3f51540108e3affa84f095c8b04f0aa833bb797bc8baa218a952a98117d/contourpy-1.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32b238b3b3b649e09ce9aaf51f0c261d38644bdfa35cbaf7b263457850957a84", size = 303184, upload-time = "2024-08-27T20:54:00.225Z" }, + { url = "https://files.pythonhosted.org/packages/00/56/1348a44fb6c3a558c1a3a0cd23d329d604c99d81bf5a4b58c6b71aab328f/contourpy-1.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d51fca85f9f7ad0b65b4b9fe800406d0d77017d7270d31ec3fb1cc07358fdea0", size = 340262, upload-time = "2024-08-27T20:54:05.234Z" }, + { url = "https://files.pythonhosted.org/packages/2b/23/00d665ba67e1bb666152131da07e0f24c95c3632d7722caa97fb61470eca/contourpy-1.3.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:732896af21716b29ab3e988d4ce14bc5133733b85956316fb0c56355f398099b", size = 313806, upload-time = "2024-08-27T20:54:09.889Z" }, + { url = "https://files.pythonhosted.org/packages/5a/42/3cf40f7040bb8362aea19af9a5fb7b32ce420f645dd1590edcee2c657cd5/contourpy-1.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d73f659398a0904e125280836ae6f88ba9b178b2fed6884f3b1f95b989d2c8da", size = 319710, upload-time = "2024-08-27T20:54:14.536Z" }, + { url = "https://files.pythonhosted.org/packages/05/32/f3bfa3fc083b25e1a7ae09197f897476ee68e7386e10404bdf9aac7391f0/contourpy-1.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c6c7c2408b7048082932cf4e641fa3b8ca848259212f51c8c59c45aa7ac18f14", size = 1264107, upload-time = "2024-08-27T20:54:29.735Z" }, + { url = "https://files.pythonhosted.org/packages/1c/1e/1019d34473a736664f2439542b890b2dc4c6245f5c0d8cdfc0ccc2cab80c/contourpy-1.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f317576606de89da6b7e0861cf6061f6146ead3528acabff9236458a6ba467f8", size = 1322458, upload-time = "2024-08-27T20:54:45.507Z" }, + { url = "https://files.pythonhosted.org/packages/22/85/4f8bfd83972cf8909a4d36d16b177f7b8bdd942178ea4bf877d4a380a91c/contourpy-1.3.0-cp313-cp313-win32.whl", hash = "sha256:31cd3a85dbdf1fc002280c65caa7e2b5f65e4a973fcdf70dd2fdcb9868069294", size = 172643, upload-time = "2024-08-27T20:55:52.754Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4a/fb3c83c1baba64ba90443626c228ca14f19a87c51975d3b1de308dd2cf08/contourpy-1.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4553c421929ec95fb07b3aaca0fae668b2eb5a5203d1217ca7c34c063c53d087", size = 218301, upload-time = "2024-08-27T20:55:56.509Z" }, + { url = "https://files.pythonhosted.org/packages/76/65/702f4064f397821fea0cb493f7d3bc95a5d703e20954dce7d6d39bacf378/contourpy-1.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:345af746d7766821d05d72cb8f3845dfd08dd137101a2cb9b24de277d716def8", size = 278972, upload-time = "2024-08-27T20:54:50.347Z" }, + { url = "https://files.pythonhosted.org/packages/80/85/21f5bba56dba75c10a45ec00ad3b8190dbac7fd9a8a8c46c6116c933e9cf/contourpy-1.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3bb3808858a9dc68f6f03d319acd5f1b8a337e6cdda197f02f4b8ff67ad2057b", size = 263375, upload-time = "2024-08-27T20:54:54.909Z" }, + { url = "https://files.pythonhosted.org/packages/0a/64/084c86ab71d43149f91ab3a4054ccf18565f0a8af36abfa92b1467813ed6/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:420d39daa61aab1221567b42eecb01112908b2cab7f1b4106a52caaec8d36973", size = 307188, upload-time = "2024-08-27T20:55:00.184Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ff/d61a4c288dc42da0084b8d9dc2aa219a850767165d7d9a9c364ff530b509/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d63ee447261e963af02642ffcb864e5a2ee4cbfd78080657a9880b8b1868e18", size = 345644, upload-time = "2024-08-27T20:55:05.673Z" }, + { url = "https://files.pythonhosted.org/packages/ca/aa/00d2313d35ec03f188e8f0786c2fc61f589306e02fdc158233697546fd58/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:167d6c890815e1dac9536dca00828b445d5d0df4d6a8c6adb4a7ec3166812fa8", size = 317141, upload-time = "2024-08-27T20:55:11.047Z" }, + { url = "https://files.pythonhosted.org/packages/8d/6a/b5242c8cb32d87f6abf4f5e3044ca397cb1a76712e3fa2424772e3ff495f/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:710a26b3dc80c0e4febf04555de66f5fd17e9cf7170a7b08000601a10570bda6", size = 323469, upload-time = "2024-08-27T20:55:15.914Z" }, + { url = "https://files.pythonhosted.org/packages/6f/a6/73e929d43028a9079aca4bde107494864d54f0d72d9db508a51ff0878593/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:75ee7cb1a14c617f34a51d11fa7524173e56551646828353c4af859c56b766e2", size = 1260894, upload-time = "2024-08-27T20:55:31.553Z" }, + { url = "https://files.pythonhosted.org/packages/2b/1e/1e726ba66eddf21c940821df8cf1a7d15cb165f0682d62161eaa5e93dae1/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:33c92cdae89ec5135d036e7218e69b0bb2851206077251f04a6c4e0e21f03927", size = 1314829, upload-time = "2024-08-27T20:55:47.837Z" }, + { url = "https://files.pythonhosted.org/packages/b3/e3/b9f72758adb6ef7397327ceb8b9c39c75711affb220e4f53c745ea1d5a9a/contourpy-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a11077e395f67ffc2c44ec2418cfebed032cd6da3022a94fc227b6faf8e2acb8", size = 265518, upload-time = "2024-08-27T20:56:01.333Z" }, + { url = "https://files.pythonhosted.org/packages/ec/22/19f5b948367ab5260fb41d842c7a78dae645603881ea6bc39738bcfcabf6/contourpy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e8134301d7e204c88ed7ab50028ba06c683000040ede1d617298611f9dc6240c", size = 249350, upload-time = "2024-08-27T20:56:05.432Z" }, + { url = "https://files.pythonhosted.org/packages/26/76/0c7d43263dd00ae21a91a24381b7e813d286a3294d95d179ef3a7b9fb1d7/contourpy-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e12968fdfd5bb45ffdf6192a590bd8ddd3ba9e58360b29683c6bb71a7b41edca", size = 309167, upload-time = "2024-08-27T20:56:10.034Z" }, + { url = "https://files.pythonhosted.org/packages/96/3b/cadff6773e89f2a5a492c1a8068e21d3fccaf1a1c1df7d65e7c8e3ef60ba/contourpy-1.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fd2a0fc506eccaaa7595b7e1418951f213cf8255be2600f1ea1b61e46a60c55f", size = 348279, upload-time = "2024-08-27T20:56:15.41Z" }, + { url = "https://files.pythonhosted.org/packages/e1/86/158cc43aa549d2081a955ab11c6bdccc7a22caacc2af93186d26f5f48746/contourpy-1.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4cfb5c62ce023dfc410d6059c936dcf96442ba40814aefbfa575425a3a7f19dc", size = 318519, upload-time = "2024-08-27T20:56:21.813Z" }, + { url = "https://files.pythonhosted.org/packages/05/11/57335544a3027e9b96a05948c32e566328e3a2f84b7b99a325b7a06d2b06/contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a32389b06b82c2fdd68276148d7b9275b5f5cf13e5417e4252f6d1a34f72a2", size = 321922, upload-time = "2024-08-27T20:56:26.983Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e3/02114f96543f4a1b694333b92a6dcd4f8eebbefcc3a5f3bbb1316634178f/contourpy-1.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:94e848a6b83da10898cbf1311a815f770acc9b6a3f2d646f330d57eb4e87592e", size = 1258017, upload-time = "2024-08-27T20:56:42.246Z" }, + { url = "https://files.pythonhosted.org/packages/f3/3b/bfe4c81c6d5881c1c643dde6620be0b42bf8aab155976dd644595cfab95c/contourpy-1.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d78ab28a03c854a873787a0a42254a0ccb3cb133c672f645c9f9c8f3ae9d0800", size = 1316773, upload-time = "2024-08-27T20:56:58.58Z" }, + { url = "https://files.pythonhosted.org/packages/f1/17/c52d2970784383cafb0bd918b6fb036d98d96bbf0bc1befb5d1e31a07a70/contourpy-1.3.0-cp39-cp39-win32.whl", hash = "sha256:81cb5ed4952aae6014bc9d0421dec7c5835c9c8c31cdf51910b708f548cf58e5", size = 171353, upload-time = "2024-08-27T20:57:02.718Z" }, + { url = "https://files.pythonhosted.org/packages/53/23/db9f69676308e094d3c45f20cc52e12d10d64f027541c995d89c11ad5c75/contourpy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:14e262f67bd7e6eb6880bc564dcda30b15e351a594657e55b7eec94b6ef72843", size = 211817, upload-time = "2024-08-27T20:57:06.328Z" }, + { url = "https://files.pythonhosted.org/packages/d1/09/60e486dc2b64c94ed33e58dcfb6f808192c03dfc5574c016218b9b7680dc/contourpy-1.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fe41b41505a5a33aeaed2a613dccaeaa74e0e3ead6dd6fd3a118fb471644fd6c", size = 261886, upload-time = "2024-08-27T20:57:10.863Z" }, + { url = "https://files.pythonhosted.org/packages/19/20/b57f9f7174fcd439a7789fb47d764974ab646fa34d1790551de386457a8e/contourpy-1.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca7e17a65f72a5133bdbec9ecf22401c62bcf4821361ef7811faee695799779", size = 311008, upload-time = "2024-08-27T20:57:15.588Z" }, + { url = "https://files.pythonhosted.org/packages/74/fc/5040d42623a1845d4f17a418e590fd7a79ae8cb2bad2b2f83de63c3bdca4/contourpy-1.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ec4dc6bf570f5b22ed0d7efba0dfa9c5b9e0431aeea7581aa217542d9e809a4", size = 215690, upload-time = "2024-08-27T20:57:19.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/24/dc3dcd77ac7460ab7e9d2b01a618cb31406902e50e605a8d6091f0a8f7cc/contourpy-1.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:00ccd0dbaad6d804ab259820fa7cb0b8036bda0686ef844d24125d8287178ce0", size = 261894, upload-time = "2024-08-27T20:57:23.873Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/531642a01cfec39d1682e46b5457b07cf805e3c3c584ec27e2a6223f8f6c/contourpy-1.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ca947601224119117f7c19c9cdf6b3ab54c5726ef1d906aa4a69dfb6dd58102", size = 311099, upload-time = "2024-08-27T20:57:28.58Z" }, + { url = "https://files.pythonhosted.org/packages/38/1e/94bda024d629f254143a134eead69e21c836429a2a6ce82209a00ddcb79a/contourpy-1.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6ec93afeb848a0845a18989da3beca3eec2c0f852322efe21af1931147d12cb", size = 215838, upload-time = "2024-08-27T20:57:32.913Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" }, + { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" }, + { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" }, + { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" }, + { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" }, + { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" }, + { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" }, + { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" }, + { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" }, + { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" }, + { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload-time = "2025-04-15T17:37:03.105Z" }, + { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload-time = "2025-04-15T17:37:07.026Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload-time = "2025-04-15T17:37:11.481Z" }, + { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload-time = "2025-04-15T17:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload-time = "2025-04-15T17:37:22.76Z" }, + { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload-time = "2025-04-15T17:37:33.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload-time = "2025-04-15T17:37:48.64Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload-time = "2025-04-15T17:38:06.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload-time = "2025-04-15T17:38:10.338Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload-time = "2025-04-15T17:38:14.239Z" }, + { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload-time = "2025-04-15T17:38:19.142Z" }, + { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload-time = "2025-04-15T17:38:23.688Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload-time = "2025-04-15T17:38:28.238Z" }, + { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload-time = "2025-04-15T17:38:33.502Z" }, + { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload-time = "2025-04-15T17:38:38.672Z" }, + { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload-time = "2025-04-15T17:38:43.712Z" }, + { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload-time = "2025-04-15T17:39:00.224Z" }, + { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload-time = "2025-04-15T17:43:29.649Z" }, + { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload-time = "2025-04-15T17:44:44.532Z" }, + { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload-time = "2025-04-15T17:44:48.194Z" }, + { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload-time = "2025-04-15T17:43:34.084Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload-time = "2025-04-15T17:43:38.626Z" }, + { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload-time = "2025-04-15T17:43:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload-time = "2025-04-15T17:43:49.545Z" }, + { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload-time = "2025-04-15T17:43:54.203Z" }, + { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload-time = "2025-04-15T17:44:01.025Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload-time = "2025-04-15T17:44:17.322Z" }, + { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload-time = "2025-04-15T17:44:33.43Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload-time = "2025-04-15T17:44:37.092Z" }, + { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload-time = "2025-04-15T17:44:40.827Z" }, + { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" }, + { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" }, + { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" }, + { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, +] +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/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, + { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, + { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, + { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, + { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { 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" }, + { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, + { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, + { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, +] + +[[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 = "cyclonedx-python-lib" +version = "7.6.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +dependencies = [ + { name = "license-expression", version = "30.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "packageurl-python", marker = "python_full_version < '3.9'" }, + { name = "py-serializable", version = "1.1.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "sortedcontainers", marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/8f/a2de02ce7263312b51cb3946593b608ef996949295b69b31a9ed0e71ec92/cyclonedx_python_lib-7.6.2.tar.gz", hash = "sha256:31186c5725ac0cfcca433759a407b1424686cdc867b47cc86e6cf83691310903", size = 1124315, upload-time = "2024-10-07T13:21:28.128Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/27/9ec1959eb4c23bdbec690f17a64562e664746762c0b8becf3ec2e95579d7/cyclonedx_python_lib-7.6.2-py3-none-any.whl", hash = "sha256:c42fab352cc0f7418d1b30def6751d9067ebcf0e8e4be210fc14d6e742a9edcc", size = 361381, upload-time = "2024-10-07T13:21:25.718Z" }, +] + +[[package]] +name = "cyclonedx-python-lib" +version = "9.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "license-expression", version = "30.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "packageurl-python", marker = "python_full_version == '3.9.*'" }, + { name = "py-serializable", version = "2.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "sortedcontainers", marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/fc/abaad5482f7b59c9a0a9d8f354ce4ce23346d582a0d85730b559562bbeb4/cyclonedx_python_lib-9.1.0.tar.gz", hash = "sha256:86935f2c88a7b47a529b93c724dbd3e903bc573f6f8bd977628a7ca1b5dadea1", size = 1048735, upload-time = "2025-02-27T17:23:40.367Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/53/f1/f3be2e9820a2c26fa77622223e91f9c504e1581830930d477e06146073f4/cyclonedx_python_lib-9.1.0-py3-none-any.whl", hash = "sha256:55693fca8edaecc3363b24af14e82cc6e659eb1e8353e58b587c42652ce0fb52", size = 374968, upload-time = "2025-02-27T17:23:37.766Z" }, +] + +[[package]] +name = "cyclonedx-python-lib" +version = "11.11.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15'", "python_full_version >= '3.12' and python_full_version < '3.15'", "python_full_version == '3.11.*'", "python_full_version == '3.10.*'", - "python_full_version == '3.9.*'", ] -sdist = { url = "https://files.pythonhosted.org/packages/81/e1/56027a71e31b02ddc53c7d65b01e68edf64dea2932122fe7746a516f75d5/dill-0.4.1.tar.gz", hash = "sha256:423092df4182177d4d8ba8290c8a5b640c66ab35ec7da59ccfa00f6fa3eea5fa", size = 187315, upload-time = "2026-01-19T02:36:56.85Z" } +dependencies = [ + { name = "license-expression", version = "30.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "packageurl-python", marker = "python_full_version >= '3.10'" }, + { name = "py-serializable", version = "2.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "sortedcontainers", marker = "python_full_version >= '3.10'" }, + { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10' and python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/c9/5d0ccdd19bc7d8ab803b90695c1706aa2ea8529685d18e682dc2524d2630/cyclonedx_python_lib-11.11.0.tar.gz", hash = "sha256:4b3194db72b613717f2912447e67ab618c75ff7dcac6c4af3c0e9e1ac617c102", size = 1442983, upload-time = "2026-06-17T11:57:49.055Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" }, + { url = "https://files.pythonhosted.org/packages/22/f3/56ccb2884aaa3db5622368e5191a3384b15f35392aa93df8b2f508c660d2/cyclonedx_python_lib-11.11.0-py3-none-any.whl", hash = "sha256:3049fc83e06a059b5c5907a527625a8ed5073caab10607ed4c9e5503b590fd44", size = 528689, upload-time = "2026-06-17T11:57:47.358Z" }, +] + +[[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]] @@ -293,9 +612,241 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, ] +[[package]] +name = "filelock" +version = "3.16.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/db/3ef5bb276dae18d6ec2124224403d1d67bccdbefc17af4cc8f553e341ab1/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435", size = 18037, upload-time = "2024-09-17T19:02:01.779Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163, upload-time = "2024-09-17T19:02:00.268Z" }, +] + +[[package]] +name = "filelock" +version = "3.19.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/40/bb/0ab3e58d22305b6f5440629d20683af28959bf793d98d11950e305c1c326/filelock-3.19.1.tar.gz", hash = "sha256:66eda1888b0171c998b35be2bcc0f6d75c388a7ce20c3f3f37aa8e96c2dddf58", size = 17687, upload-time = "2025-08-14T16:56:03.016Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/14/42b2651a2f46b022ccd948bca9f2d5af0fd8929c4eec235b8d6d844fbe67/filelock-3.19.1-py3-none-any.whl", hash = "sha256:d38e30481def20772f5baf097c122c3babc4fcdb7e14e57049eb9d88c6dc017d", size = 15988, upload-time = "2025-08-14T16:56:01.633Z" }, +] + +[[package]] +name = "filelock" +version = "3.32.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/80/8232b582c4b318b817cf1274ba74976b07b34d35ef439b3eb948f98645a1/filelock-3.32.0.tar.gz", hash = "sha256:7be2ad23a14607ccc71808e68fe30848aeace7058ace17852f68e2a68e310402", size = 213757, upload-time = "2026-07-21T13:17:42.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/79/b4c714bef36bc4ec2beeae1e0c124f0223888cd8c6feb1cdc56038116920/filelock-3.32.0-py3-none-any.whl", hash = "sha256:d396bea984af47333ef05e50eae7eff88c84256de6112aea0ec48a233c064fe3", size = 97732, upload-time = "2026-07-21T13:17:41.55Z" }, +] + +[[package]] +name = "fonttools" +version = "4.57.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/03/2d/a9a0b6e3a0cf6bd502e64fc16d894269011930cabfc89aee20d1635b1441/fonttools-4.57.0.tar.gz", hash = "sha256:727ece10e065be2f9dd239d15dd5d60a66e17eac11aea47d447f9f03fdbc42de", size = 3492448, upload-time = "2025-04-03T11:07:13.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/17/3ddfd1881878b3f856065130bb603f5922e81ae8a4eb53bce0ea78f765a8/fonttools-4.57.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:babe8d1eb059a53e560e7bf29f8e8f4accc8b6cfb9b5fd10e485bde77e71ef41", size = 2756260, upload-time = "2025-04-03T11:05:28.582Z" }, + { url = "https://files.pythonhosted.org/packages/26/2b/6957890c52c030b0bf9e0add53e5badab4682c6ff024fac9a332bb2ae063/fonttools-4.57.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:81aa97669cd726349eb7bd43ca540cf418b279ee3caba5e2e295fb4e8f841c02", size = 2284691, upload-time = "2025-04-03T11:05:31.526Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8e/c043b4081774e5eb06a834cedfdb7d432b4935bc8c4acf27207bdc34dfc4/fonttools-4.57.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0e9618630edd1910ad4f07f60d77c184b2f572c8ee43305ea3265675cbbfe7e", size = 4566077, upload-time = "2025-04-03T11:05:33.559Z" }, + { url = "https://files.pythonhosted.org/packages/59/bc/e16ae5d9eee6c70830ce11d1e0b23d6018ddfeb28025fda092cae7889c8b/fonttools-4.57.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:34687a5d21f1d688d7d8d416cb4c5b9c87fca8a1797ec0d74b9fdebfa55c09ab", size = 4608729, upload-time = "2025-04-03T11:05:35.49Z" }, + { url = "https://files.pythonhosted.org/packages/25/13/e557bf10bb38e4e4c436d3a9627aadf691bc7392ae460910447fda5fad2b/fonttools-4.57.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:69ab81b66ebaa8d430ba56c7a5f9abe0183afefd3a2d6e483060343398b13fb1", size = 4759646, upload-time = "2025-04-03T11:05:37.963Z" }, + { url = "https://files.pythonhosted.org/packages/bc/c9/5e2952214d4a8e31026bf80beb18187199b7001e60e99a6ce19773249124/fonttools-4.57.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d639397de852f2ccfb3134b152c741406752640a266d9c1365b0f23d7b88077f", size = 4941652, upload-time = "2025-04-03T11:05:40.089Z" }, + { url = "https://files.pythonhosted.org/packages/df/04/e80242b3d9ec91a1f785d949edc277a13ecfdcfae744de4b170df9ed77d8/fonttools-4.57.0-cp310-cp310-win32.whl", hash = "sha256:cc066cb98b912f525ae901a24cd381a656f024f76203bc85f78fcc9e66ae5aec", size = 2159432, upload-time = "2025-04-03T11:05:41.754Z" }, + { url = "https://files.pythonhosted.org/packages/33/ba/e858cdca275daf16e03c0362aa43734ea71104c3b356b2100b98543dba1b/fonttools-4.57.0-cp310-cp310-win_amd64.whl", hash = "sha256:7a64edd3ff6a7f711a15bd70b4458611fb240176ec11ad8845ccbab4fe6745db", size = 2203869, upload-time = "2025-04-03T11:05:43.712Z" }, + { url = "https://files.pythonhosted.org/packages/81/1f/e67c99aa3c6d3d2f93d956627e62a57ae0d35dc42f26611ea2a91053f6d6/fonttools-4.57.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3871349303bdec958360eedb619169a779956503ffb4543bb3e6211e09b647c4", size = 2757392, upload-time = "2025-04-03T11:05:45.715Z" }, + { url = "https://files.pythonhosted.org/packages/aa/f1/f75770d0ddc67db504850898d96d75adde238c35313409bfcd8db4e4a5fe/fonttools-4.57.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c59375e85126b15a90fcba3443eaac58f3073ba091f02410eaa286da9ad80ed8", size = 2285609, upload-time = "2025-04-03T11:05:47.977Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d3/bc34e4953cb204bae0c50b527307dce559b810e624a733351a654cfc318e/fonttools-4.57.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:967b65232e104f4b0f6370a62eb33089e00024f2ce143aecbf9755649421c683", size = 4873292, upload-time = "2025-04-03T11:05:49.921Z" }, + { url = "https://files.pythonhosted.org/packages/41/b8/d5933559303a4ab18c799105f4c91ee0318cc95db4a2a09e300116625e7a/fonttools-4.57.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39acf68abdfc74e19de7485f8f7396fa4d2418efea239b7061d6ed6a2510c746", size = 4902503, upload-time = "2025-04-03T11:05:52.17Z" }, + { url = "https://files.pythonhosted.org/packages/32/13/acb36bfaa316f481153ce78de1fa3926a8bad42162caa3b049e1afe2408b/fonttools-4.57.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9d077f909f2343daf4495ba22bb0e23b62886e8ec7c109ee8234bdbd678cf344", size = 5077351, upload-time = "2025-04-03T11:05:54.162Z" }, + { url = "https://files.pythonhosted.org/packages/b5/23/6d383a2ca83b7516d73975d8cca9d81a01acdcaa5e4db8579e4f3de78518/fonttools-4.57.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:46370ac47a1e91895d40e9ad48effbe8e9d9db1a4b80888095bc00e7beaa042f", size = 5275067, upload-time = "2025-04-03T11:05:57.375Z" }, + { url = "https://files.pythonhosted.org/packages/bc/ca/31b8919c6da0198d5d522f1d26c980201378c087bdd733a359a1e7485769/fonttools-4.57.0-cp311-cp311-win32.whl", hash = "sha256:ca2aed95855506b7ae94e8f1f6217b7673c929e4f4f1217bcaa236253055cb36", size = 2158263, upload-time = "2025-04-03T11:05:59.567Z" }, + { url = "https://files.pythonhosted.org/packages/13/4c/de2612ea2216eb45cfc8eb91a8501615dd87716feaf5f8fb65cbca576289/fonttools-4.57.0-cp311-cp311-win_amd64.whl", hash = "sha256:17168a4670bbe3775f3f3f72d23ee786bd965395381dfbb70111e25e81505b9d", size = 2204968, upload-time = "2025-04-03T11:06:02.16Z" }, + { url = "https://files.pythonhosted.org/packages/cb/98/d4bc42d43392982eecaaca117d79845734d675219680cd43070bb001bc1f/fonttools-4.57.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:889e45e976c74abc7256d3064aa7c1295aa283c6bb19810b9f8b604dfe5c7f31", size = 2751824, upload-time = "2025-04-03T11:06:03.782Z" }, + { url = "https://files.pythonhosted.org/packages/1a/62/7168030eeca3742fecf45f31e63b5ef48969fa230a672216b805f1d61548/fonttools-4.57.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0425c2e052a5f1516c94e5855dbda706ae5a768631e9fcc34e57d074d1b65b92", size = 2283072, upload-time = "2025-04-03T11:06:05.533Z" }, + { url = "https://files.pythonhosted.org/packages/5d/82/121a26d9646f0986ddb35fbbaf58ef791c25b59ecb63ffea2aab0099044f/fonttools-4.57.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44c26a311be2ac130f40a96769264809d3b0cb297518669db437d1cc82974888", size = 4788020, upload-time = "2025-04-03T11:06:07.249Z" }, + { url = "https://files.pythonhosted.org/packages/5b/26/e0f2fb662e022d565bbe280a3cfe6dafdaabf58889ff86fdef2d31ff1dde/fonttools-4.57.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84c41ba992df5b8d680b89fd84c6a1f2aca2b9f1ae8a67400c8930cd4ea115f6", size = 4859096, upload-time = "2025-04-03T11:06:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/9e/44/9075e323347b1891cdece4b3f10a3b84a8f4c42a7684077429d9ce842056/fonttools-4.57.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ea1e9e43ca56b0c12440a7c689b1350066595bebcaa83baad05b8b2675129d98", size = 4964356, upload-time = "2025-04-03T11:06:11.294Z" }, + { url = "https://files.pythonhosted.org/packages/48/28/caa8df32743462fb966be6de6a79d7f30393859636d7732e82efa09fbbb4/fonttools-4.57.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:84fd56c78d431606332a0627c16e2a63d243d0d8b05521257d77c6529abe14d8", size = 5226546, upload-time = "2025-04-03T11:06:13.6Z" }, + { url = "https://files.pythonhosted.org/packages/f6/46/95ab0f0d2e33c5b1a4fc1c0efe5e286ba9359602c0a9907adb1faca44175/fonttools-4.57.0-cp312-cp312-win32.whl", hash = "sha256:f4376819c1c778d59e0a31db5dc6ede854e9edf28bbfa5b756604727f7f800ac", size = 2146776, upload-time = "2025-04-03T11:06:15.643Z" }, + { url = "https://files.pythonhosted.org/packages/06/5d/1be5424bb305880e1113631f49a55ea7c7da3a5fe02608ca7c16a03a21da/fonttools-4.57.0-cp312-cp312-win_amd64.whl", hash = "sha256:57e30241524879ea10cdf79c737037221f77cc126a8cdc8ff2c94d4a522504b9", size = 2193956, upload-time = "2025-04-03T11:06:17.534Z" }, + { url = "https://files.pythonhosted.org/packages/e9/2f/11439f3af51e4bb75ac9598c29f8601aa501902dcedf034bdc41f47dd799/fonttools-4.57.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:408ce299696012d503b714778d89aa476f032414ae57e57b42e4b92363e0b8ef", size = 2739175, upload-time = "2025-04-03T11:06:19.583Z" }, + { url = "https://files.pythonhosted.org/packages/25/52/677b55a4c0972dc3820c8dba20a29c358197a78229daa2ea219fdb19e5d5/fonttools-4.57.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bbceffc80aa02d9e8b99f2a7491ed8c4a783b2fc4020119dc405ca14fb5c758c", size = 2276583, upload-time = "2025-04-03T11:06:21.753Z" }, + { url = "https://files.pythonhosted.org/packages/64/79/184555f8fa77b827b9460a4acdbbc0b5952bb6915332b84c615c3a236826/fonttools-4.57.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f022601f3ee9e1f6658ed6d184ce27fa5216cee5b82d279e0f0bde5deebece72", size = 4766437, upload-time = "2025-04-03T11:06:23.521Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ad/c25116352f456c0d1287545a7aa24e98987b6d99c5b0456c4bd14321f20f/fonttools-4.57.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4dea5893b58d4637ffa925536462ba626f8a1b9ffbe2f5c272cdf2c6ebadb817", size = 4838431, upload-time = "2025-04-03T11:06:25.423Z" }, + { url = "https://files.pythonhosted.org/packages/53/ae/398b2a833897297797a44f519c9af911c2136eb7aa27d3f1352c6d1129fa/fonttools-4.57.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dff02c5c8423a657c550b48231d0a48d7e2b2e131088e55983cfe74ccc2c7cc9", size = 4951011, upload-time = "2025-04-03T11:06:27.41Z" }, + { url = "https://files.pythonhosted.org/packages/b7/5d/7cb31c4bc9ffb9a2bbe8b08f8f53bad94aeb158efad75da645b40b62cb73/fonttools-4.57.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:767604f244dc17c68d3e2dbf98e038d11a18abc078f2d0f84b6c24571d9c0b13", size = 5205679, upload-time = "2025-04-03T11:06:29.804Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/6934513ec2c4d3d69ca1bc3bd34d5c69dafcbf68c15388dd3bb062daf345/fonttools-4.57.0-cp313-cp313-win32.whl", hash = "sha256:8e2e12d0d862f43d51e5afb8b9751c77e6bec7d2dc00aad80641364e9df5b199", size = 2144833, upload-time = "2025-04-03T11:06:31.737Z" }, + { url = "https://files.pythonhosted.org/packages/c4/0d/2177b7fdd23d017bcfb702fd41e47d4573766b9114da2fddbac20dcc4957/fonttools-4.57.0-cp313-cp313-win_amd64.whl", hash = "sha256:f1d6bc9c23356908db712d282acb3eebd4ae5ec6d8b696aa40342b1d84f8e9e3", size = 2190799, upload-time = "2025-04-03T11:06:34.784Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3f/c16dbbec7221783f37dcc2022d5a55f0d704ffc9feef67930f6eb517e8ce/fonttools-4.57.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:9d57b4e23ebbe985125d3f0cabbf286efa191ab60bbadb9326091050d88e8213", size = 2753756, upload-time = "2025-04-03T11:06:36.875Z" }, + { url = "https://files.pythonhosted.org/packages/48/9f/5b4a3d6aed5430b159dd3494bb992d4e45102affa3725f208e4f0aedc6a3/fonttools-4.57.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:579ba873d7f2a96f78b2e11028f7472146ae181cae0e4d814a37a09e93d5c5cc", size = 2283179, upload-time = "2025-04-03T11:06:39.095Z" }, + { url = "https://files.pythonhosted.org/packages/17/b2/4e887b674938b4c3848029a4134ac90dd8653ea80b4f464fa1edeae37f25/fonttools-4.57.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e3e1ec10c29bae0ea826b61f265ec5c858c5ba2ce2e69a71a62f285cf8e4595", size = 4647139, upload-time = "2025-04-03T11:06:41.315Z" }, + { url = "https://files.pythonhosted.org/packages/a5/0e/b6314a09a4d561aaa7e09de43fa700917be91e701f07df6178865962666c/fonttools-4.57.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1968f2a2003c97c4ce6308dc2498d5fd4364ad309900930aa5a503c9851aec8", size = 4691211, upload-time = "2025-04-03T11:06:43.566Z" }, + { url = "https://files.pythonhosted.org/packages/bf/1d/b9f4b70d165c25f5c9aee61eb6ae90b0e9b5787b2c0a45e4f3e50a839274/fonttools-4.57.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:aff40f8ac6763d05c2c8f6d240c6dac4bb92640a86d9b0c3f3fff4404f34095c", size = 4873755, upload-time = "2025-04-03T11:06:45.457Z" }, + { url = "https://files.pythonhosted.org/packages/3b/fa/a731c8f42ae2c6761d1c22bd3c90241d5b2b13cabb70598abc74a828b51f/fonttools-4.57.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:d07f1b64008e39fceae7aa99e38df8385d7d24a474a8c9872645c4397b674481", size = 5070072, upload-time = "2025-04-03T11:06:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/1f/1e/6a988230109a2ba472e5de0a4c3936d49718cfc4b700b6bad53eca414bcf/fonttools-4.57.0-cp38-cp38-win32.whl", hash = "sha256:51d8482e96b28fb28aa8e50b5706f3cee06de85cbe2dce80dbd1917ae22ec5a6", size = 1484098, upload-time = "2025-04-03T11:06:50.167Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7a/2b3666e8c13d035adf656a8ae391380656144760353c97f74747c64fd3e5/fonttools-4.57.0-cp38-cp38-win_amd64.whl", hash = "sha256:03290e818782e7edb159474144fca11e36a8ed6663d1fcbd5268eb550594fd8e", size = 1529536, upload-time = "2025-04-03T11:06:52.468Z" }, + { url = "https://files.pythonhosted.org/packages/d2/c7/3bddafbb95447f6fbabdd0b399bf468649321fd4029e356b4f6bd70fbc1b/fonttools-4.57.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7339e6a3283e4b0ade99cade51e97cde3d54cd6d1c3744459e886b66d630c8b3", size = 2758942, upload-time = "2025-04-03T11:06:54.679Z" }, + { url = "https://files.pythonhosted.org/packages/d4/a2/8dd7771022e365c90e428b1607174c3297d5c0a2cc2cf4cdccb2221945b7/fonttools-4.57.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:05efceb2cb5f6ec92a4180fcb7a64aa8d3385fd49cfbbe459350229d1974f0b1", size = 2285959, upload-time = "2025-04-03T11:06:56.792Z" }, + { url = "https://files.pythonhosted.org/packages/58/5a/2fd29c5e38b14afe1fae7d472373e66688e7c7a98554252f3cf44371e033/fonttools-4.57.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a97bb05eb24637714a04dee85bdf0ad1941df64fe3b802ee4ac1c284a5f97b7c", size = 4571677, upload-time = "2025-04-03T11:06:59.002Z" }, + { url = "https://files.pythonhosted.org/packages/bf/30/b77cf81923f1a67ff35d6765a9db4718c0688eb8466c464c96a23a2e28d4/fonttools-4.57.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:541cb48191a19ceb1a2a4b90c1fcebd22a1ff7491010d3cf840dd3a68aebd654", size = 4616644, upload-time = "2025-04-03T11:07:01.238Z" }, + { url = "https://files.pythonhosted.org/packages/06/33/376605898d8d553134144dff167506a49694cb0e0cf684c14920fbc1e99f/fonttools-4.57.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:cdef9a056c222d0479a1fdb721430f9efd68268014c54e8166133d2643cb05d9", size = 4761314, upload-time = "2025-04-03T11:07:03.162Z" }, + { url = "https://files.pythonhosted.org/packages/48/e4/e0e48f5bae04bc1a1c6b4fcd7d1ca12b29f1fe74221534b7ff83ed0db8fe/fonttools-4.57.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:3cf97236b192a50a4bf200dc5ba405aa78d4f537a2c6e4c624bb60466d5b03bd", size = 4945563, upload-time = "2025-04-03T11:07:05.313Z" }, + { url = "https://files.pythonhosted.org/packages/61/98/2dacfc6d70f2d93bde1bbf814286be343cb17f53057130ad3b843144dd00/fonttools-4.57.0-cp39-cp39-win32.whl", hash = "sha256:e952c684274a7714b3160f57ec1d78309f955c6335c04433f07d36c5eb27b1f9", size = 2159997, upload-time = "2025-04-03T11:07:07.467Z" }, + { url = "https://files.pythonhosted.org/packages/93/fa/e61cc236f40d504532d2becf90c297bfed8e40abc0c8b08375fbb83eff29/fonttools-4.57.0-cp39-cp39-win_amd64.whl", hash = "sha256:a2a722c0e4bfd9966a11ff55c895c817158fcce1b2b6700205a376403b546ad9", size = 2204508, upload-time = "2025-04-03T11:07:09.632Z" }, + { url = "https://files.pythonhosted.org/packages/90/27/45f8957c3132917f91aaa56b700bcfc2396be1253f685bd5c68529b6f610/fonttools-4.57.0-py3-none-any.whl", hash = "sha256:3122c604a675513c68bd24c6a8f9091f1c2376d18e8f5fe5a101746c81b3e98f", size = 1093605, upload-time = "2025-04-03T11:07:11.341Z" }, +] + +[[package]] +name = "fonttools" +version = "4.60.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/3e/c4/db6a7b5eb0656534c3aa2596c2c5e18830d74f1b9aa5aa8a7dff63a0b11d/fonttools-4.60.2.tar.gz", hash = "sha256:d29552e6b155ebfc685b0aecf8d429cb76c14ab734c22ef5d3dea6fdf800c92c", size = 3562254, upload-time = "2025-12-09T13:38:11.835Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/de/9e10a99fb3070accb8884886a41a4ce54e49bf2fa4fc63f48a6cf2061713/fonttools-4.60.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4e36fadcf7e8ca6e34d490eef86ed638d6fd9c55d2f514b05687622cfc4a7050", size = 2850403, upload-time = "2025-12-09T13:35:53.14Z" }, + { url = "https://files.pythonhosted.org/packages/e4/40/d5b369d1073b134f600a94a287e13b5bdea2191ba6347d813fa3da00e94a/fonttools-4.60.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6e500fc9c04bee749ceabfc20cb4903f6981c2139050d85720ea7ada61b75d5c", size = 2398629, upload-time = "2025-12-09T13:35:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b5/123819369aaf99d1e4dc49f1de1925d4edc7379114d15a56a7dd2e9d56e6/fonttools-4.60.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22efea5e784e1d1cd8d7b856c198e360a979383ebc6dea4604743b56da1cbc34", size = 4893471, upload-time = "2025-12-09T13:35:58.927Z" }, + { url = "https://files.pythonhosted.org/packages/24/29/f8f8acccb9716b899be4be45e9ce770d6aa76327573863e68448183091b0/fonttools-4.60.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:677aa92d84d335e4d301d8ba04afca6f575316bc647b6782cb0921943fcb6343", size = 4854686, upload-time = "2025-12-09T13:36:01.767Z" }, + { url = "https://files.pythonhosted.org/packages/5a/0d/f3f51d7519f44f2dd5c9a60d7cd41185ebcee4348f073e515a3a93af15ff/fonttools-4.60.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:edd49d3defbf35476e78b61ff737ff5efea811acff68d44233a95a5a48252334", size = 4871233, upload-time = "2025-12-09T13:36:06.094Z" }, + { url = "https://files.pythonhosted.org/packages/cc/3f/4d4fd47d3bc40ab4d76718555185f8adffb5602ea572eac4bbf200c47d22/fonttools-4.60.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:126839492b69cecc5baf2bddcde60caab2ffafd867bbae2a88463fce6078ca3a", size = 4988936, upload-time = "2025-12-09T13:36:08.42Z" }, + { url = "https://files.pythonhosted.org/packages/01/6f/83bbdefa43f2c3ae206fd8c4b9a481f3c913eef871b1ce9a453069239e39/fonttools-4.60.2-cp310-cp310-win32.whl", hash = "sha256:ffcab6f5537136046ca902ed2491ab081ba271b07591b916289b7c27ff845f96", size = 2278044, upload-time = "2025-12-09T13:36:10.641Z" }, + { url = "https://files.pythonhosted.org/packages/d4/04/7d9a137e919d6c9ef26704b7f7b2580d9cfc5139597588227aacebc0e3b7/fonttools-4.60.2-cp310-cp310-win_amd64.whl", hash = "sha256:9c68b287c7ffcd29dd83b5f961004b2a54a862a88825d52ea219c6220309ba45", size = 2326522, upload-time = "2025-12-09T13:36:12.981Z" }, + { url = "https://files.pythonhosted.org/packages/e0/80/b7693d37c02417e162cc83cdd0b19a4f58be82c638b5d4ce4de2dae050c4/fonttools-4.60.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a2aed0a7931401b3875265717a24c726f87ecfedbb7b3426c2ca4d2812e281ae", size = 2847809, upload-time = "2025-12-09T13:36:14.884Z" }, + { url = "https://files.pythonhosted.org/packages/f9/9a/9c2c13bf8a6496ac21607d704e74e9cc68ebf23892cf924c9a8b5c7566b9/fonttools-4.60.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:dea6868e9d2b816c9076cfea77754686f3c19149873bdbc5acde437631c15df1", size = 2397302, upload-time = "2025-12-09T13:36:17.151Z" }, + { url = "https://files.pythonhosted.org/packages/56/f6/ce38ff6b2d2d58f6fd981d32f3942365bfa30eadf2b47d93b2d48bf6097f/fonttools-4.60.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2fa27f34950aa1fe0f0b1abe25eed04770a3b3b34ad94e5ace82cc341589678a", size = 5054418, upload-time = "2025-12-09T13:36:19.062Z" }, + { url = "https://files.pythonhosted.org/packages/88/06/5353bea128ff39e857c31de3dd605725b4add956badae0b31bc9a50d4c8e/fonttools-4.60.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:13a53d479d187b09bfaa4a35ffcbc334fc494ff355f0a587386099cb66674f1e", size = 5031652, upload-time = "2025-12-09T13:36:21.206Z" }, + { url = "https://files.pythonhosted.org/packages/71/05/ebca836437f6ebd57edd6428e7eff584e683ff0556ddb17d62e3b731f46c/fonttools-4.60.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fac5e921d3bd0ca3bb8517dced2784f0742bc8ca28579a68b139f04ea323a779", size = 5030321, upload-time = "2025-12-09T13:36:23.515Z" }, + { url = "https://files.pythonhosted.org/packages/57/f9/eb9d2a2ce30c99f840c1cc3940729a970923cf39d770caf88909d98d516b/fonttools-4.60.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:648f4f9186fd7f1f3cd57dbf00d67a583720d5011feca67a5e88b3a491952cfb", size = 5154255, upload-time = "2025-12-09T13:36:25.879Z" }, + { url = "https://files.pythonhosted.org/packages/08/a2/088b6ceba8272a9abb629d3c08f9c1e35e5ce42db0ccfe0c1f9f03e60d1d/fonttools-4.60.2-cp311-cp311-win32.whl", hash = "sha256:3274e15fad871bead5453d5ce02658f6d0c7bc7e7021e2a5b8b04e2f9e40da1a", size = 2276300, upload-time = "2025-12-09T13:36:27.772Z" }, + { url = "https://files.pythonhosted.org/packages/de/2f/8e4c3d908cc5dade7bb1316ce48589f6a24460c1056fd4b8db51f1fa309a/fonttools-4.60.2-cp311-cp311-win_amd64.whl", hash = "sha256:91d058d5a483a1525b367803abb69de0923fbd45e1f82ebd000f5c8aa65bc78e", size = 2327574, upload-time = "2025-12-09T13:36:30.89Z" }, + { url = "https://files.pythonhosted.org/packages/c0/30/530c9eddcd1c39219dc0aaede2b5a4c8ab80e0bb88d1b3ffc12944c4aac3/fonttools-4.60.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e0164b7609d2b5c5dd4e044b8085b7bd7ca7363ef8c269a4ab5b5d4885a426b2", size = 2847196, upload-time = "2025-12-09T13:36:33.262Z" }, + { url = "https://files.pythonhosted.org/packages/19/2f/4077a482836d5bbe3bc9dac1c004d02ee227cf04ed62b0a2dfc41d4f0dfd/fonttools-4.60.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1dd3d9574fc595c1e97faccae0f264dc88784ddf7fbf54c939528378bacc0033", size = 2395842, upload-time = "2025-12-09T13:36:35.47Z" }, + { url = "https://files.pythonhosted.org/packages/dd/05/aae5bb99c5398f8ed4a8b784f023fd9dd3568f0bd5d5b21e35b282550f11/fonttools-4.60.2-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:98d0719f1b11c2817307d2da2e94296a3b2a3503f8d6252a101dca3ee663b917", size = 4949713, upload-time = "2025-12-09T13:36:37.874Z" }, + { url = "https://files.pythonhosted.org/packages/b4/37/49067349fc78ff0efbf09fadefe80ddf41473ca8f8a25400e3770da38328/fonttools-4.60.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9d3ea26957dd07209f207b4fff64c702efe5496de153a54d3b91007ec28904dd", size = 4999907, upload-time = "2025-12-09T13:36:39.853Z" }, + { url = "https://files.pythonhosted.org/packages/16/31/d0f11c758bd0db36b664c92a0f9dfdcc2d7313749aa7d6629805c6946f21/fonttools-4.60.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1ee301273b0850f3a515299f212898f37421f42ff9adfc341702582ca5073c13", size = 4939717, upload-time = "2025-12-09T13:36:43.075Z" }, + { url = "https://files.pythonhosted.org/packages/d9/bc/1cff0d69522e561bf1b99bee7c3911c08c25e919584827c3454a64651ce9/fonttools-4.60.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c6eb4694cc3b9c03b7c01d65a9cf35b577f21aa6abdbeeb08d3114b842a58153", size = 5089205, upload-time = "2025-12-09T13:36:45.468Z" }, + { url = "https://files.pythonhosted.org/packages/05/e6/fb174f0069b7122e19828c551298bfd34fdf9480535d2a6ac2ed37afacd3/fonttools-4.60.2-cp312-cp312-win32.whl", hash = "sha256:57f07b616c69c244cc1a5a51072eeef07dddda5ebef9ca5c6e9cf6d59ae65b70", size = 2264674, upload-time = "2025-12-09T13:36:49.238Z" }, + { url = "https://files.pythonhosted.org/packages/75/57/6552ffd6b582d3e6a9f01780c5275e6dfff1e70ca146101733aa1c12a129/fonttools-4.60.2-cp312-cp312-win_amd64.whl", hash = "sha256:310035802392f1fe5a7cf43d76f6ff4a24c919e4c72c0352e7b8176e2584b8a0", size = 2314701, upload-time = "2025-12-09T13:36:51.09Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e4/8381d0ca6b6c6c484660b03517ec5b5b81feeefca3808726dece36c652a9/fonttools-4.60.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2bb5fd231e56ccd7403212636dcccffc96c5ae0d6f9e4721fa0a32cb2e3ca432", size = 2842063, upload-time = "2025-12-09T13:36:53.468Z" }, + { url = "https://files.pythonhosted.org/packages/b4/2c/4367117ee8ff4f4374787a1222da0bd413d80cf3522111f727a7b8f80d1d/fonttools-4.60.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:536b5fab7b6fec78ccf59b5c59489189d9d0a8b0d3a77ed1858be59afb096696", size = 2393792, upload-time = "2025-12-09T13:36:55.742Z" }, + { url = "https://files.pythonhosted.org/packages/49/b7/a76b6dffa193869e54e32ca2f9abb0d0e66784bc8a24e6f86eb093015481/fonttools-4.60.2-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6b9288fc38252ac86a9570f19313ecbc9ff678982e0f27c757a85f1f284d3400", size = 4924020, upload-time = "2025-12-09T13:36:58.229Z" }, + { url = "https://files.pythonhosted.org/packages/bd/4e/0078200e2259f0061c86a74075f507d64c43dd2ab38971956a5c0012d344/fonttools-4.60.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93fcb420791d839ef592eada2b69997c445d0ce9c969b5190f2e16828ec10607", size = 4980070, upload-time = "2025-12-09T13:37:00.311Z" }, + { url = "https://files.pythonhosted.org/packages/85/1f/d87c85a11cb84852c975251581862681e4a0c1c3bd456c648792203f311b/fonttools-4.60.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7916a381b094db4052ac284255186aebf74c5440248b78860cb41e300036f598", size = 4921411, upload-time = "2025-12-09T13:37:02.345Z" }, + { url = "https://files.pythonhosted.org/packages/75/c0/7efad650f5ed8e317c2633133ef3c64917e7adf2e4e2940c798f5d57ec6e/fonttools-4.60.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:58c8c393d5e16b15662cfc2d988491940458aa87894c662154f50c7b49440bef", size = 5063465, upload-time = "2025-12-09T13:37:04.836Z" }, + { url = "https://files.pythonhosted.org/packages/18/a8/750518c4f8cdd79393b386bc81226047ade80239e58c6c9f5dbe1fdd8ea1/fonttools-4.60.2-cp313-cp313-win32.whl", hash = "sha256:19c6e0afd8b02008caa0aa08ab896dfce5d0bcb510c49b2c499541d5cb95a963", size = 2263443, upload-time = "2025-12-09T13:37:06.762Z" }, + { url = "https://files.pythonhosted.org/packages/b8/22/026c60376f165981f80a0e90bd98a79ae3334e9d89a3d046c4d2e265c724/fonttools-4.60.2-cp313-cp313-win_amd64.whl", hash = "sha256:6a500dc59e11b2338c2dba1f8cf11a4ae8be35ec24af8b2628b8759a61457b76", size = 2313800, upload-time = "2025-12-09T13:37:08.713Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ab/7cf1f5204e1366ddf9dc5cdc2789b571feb9eebcee0e3463c3f457df5f52/fonttools-4.60.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9387c532acbe323bbf2a920f132bce3c408a609d5f9dcfc6532fbc7e37f8ccbb", size = 2841690, upload-time = "2025-12-09T13:37:10.696Z" }, + { url = "https://files.pythonhosted.org/packages/00/3c/0bf83c6f863cc8b934952567fa2bf737cfcec8fc4ffb59b3f93820095f89/fonttools-4.60.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e6f1c824185b5b8fb681297f315f26ae55abb0d560c2579242feea8236b1cfef", size = 2392191, upload-time = "2025-12-09T13:37:12.954Z" }, + { url = "https://files.pythonhosted.org/packages/00/f0/40090d148b8907fbea12e9bdf1ff149f30cdf1769e3b2c3e0dbf5106b88d/fonttools-4.60.2-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:55a3129d1e4030b1a30260f1b32fe76781b585fb2111d04a988e141c09eb6403", size = 4873503, upload-time = "2025-12-09T13:37:15.142Z" }, + { url = "https://files.pythonhosted.org/packages/dc/e0/d8b13f99e58b8c293781288ba62fe634f1f0697c9c4c0ae104d3215f3a10/fonttools-4.60.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b196e63753abc33b3b97a6fd6de4b7c4fef5552c0a5ba5e562be214d1e9668e0", size = 4968493, upload-time = "2025-12-09T13:37:18.272Z" }, + { url = "https://files.pythonhosted.org/packages/46/c5/960764d12c92bc225f02401d3067048cb7b282293d9e48e39fe2b0ec38a9/fonttools-4.60.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:de76c8d740fb55745f3b154f0470c56db92ae3be27af8ad6c2e88f1458260c9a", size = 4920015, upload-time = "2025-12-09T13:37:20.334Z" }, + { url = "https://files.pythonhosted.org/packages/4b/ab/839d8caf253d1eef3653ef4d34427d0326d17a53efaec9eb04056b670fff/fonttools-4.60.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6ba6303225c95998c9fda2d410aa792c3d2c1390a09df58d194b03e17583fa25", size = 5031165, upload-time = "2025-12-09T13:37:23.57Z" }, + { url = "https://files.pythonhosted.org/packages/de/bf/3bc862796a6841cbe0725bb5512d272239b809dba631a4b0301df885e62d/fonttools-4.60.2-cp314-cp314-win32.whl", hash = "sha256:0a89728ce10d7c816fedaa5380c06d2793e7a8a634d7ce16810e536c22047384", size = 2267526, upload-time = "2025-12-09T13:37:25.821Z" }, + { url = "https://files.pythonhosted.org/packages/fc/a1/c1909cacf00c76dc37b4743451561fbaaf7db4172c22a6d9394081d114c3/fonttools-4.60.2-cp314-cp314-win_amd64.whl", hash = "sha256:fa8446e6ab8bd778b82cb1077058a2addba86f30de27ab9cc18ed32b34bc8667", size = 2319096, upload-time = "2025-12-09T13:37:28.058Z" }, + { url = "https://files.pythonhosted.org/packages/29/b3/f66e71433f08e3a931b2b31a665aeed17fcc5e6911fc73529c70a232e421/fonttools-4.60.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4063bc81ac5a4137642865cb63dd270e37b3cd1f55a07c0d6e41d072699ccca2", size = 2925167, upload-time = "2025-12-09T13:37:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/2e/13/eeb491ff743594bbd0bee6e49422c03a59fe9c49002d3cc60eeb77414285/fonttools-4.60.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebfdb66fa69732ed604ab8e2a0431e6deff35e933a11d73418cbc7823d03b8e1", size = 2430923, upload-time = "2025-12-09T13:37:32.817Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e5/db609f785e460796e53c4dbc3874a5f4948477f27beceb5e2d24b2537666/fonttools-4.60.2-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50b10b3b1a72d1d54c61b0e59239e1a94c0958f4a06a1febf97ce75388dd91a4", size = 4877729, upload-time = "2025-12-09T13:37:35.858Z" }, + { url = "https://files.pythonhosted.org/packages/5f/d6/85e4484dd4bfb03fee7bd370d65888cccbd3dee2681ee48c869dd5ccb23f/fonttools-4.60.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:beae16891a13b4a2ddec9b39b4de76092a3025e4d1c82362e3042b62295d5e4d", size = 5096003, upload-time = "2025-12-09T13:37:37.862Z" }, + { url = "https://files.pythonhosted.org/packages/30/49/1a98e44b71030b83d2046f981373b80571868259d98e6dae7bc20099dac6/fonttools-4.60.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:522f017fdb3766fd5d2d321774ef351cc6ce88ad4e6ac9efe643e4a2b9d528db", size = 4974410, upload-time = "2025-12-09T13:37:40.166Z" }, + { url = "https://files.pythonhosted.org/packages/42/07/d6f775d950ee8a841012472c7303f8819423d8cc3b4530915de7265ebfa2/fonttools-4.60.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82cceceaf9c09a965a75b84a4b240dd3768e596ffb65ef53852681606fe7c9ba", size = 5002036, upload-time = "2025-12-09T13:37:42.639Z" }, + { url = "https://files.pythonhosted.org/packages/73/f6/ba6458f83ce1a9f8c3b17bd8f7b8a2205a126aac1055796b7e7cfebbd38f/fonttools-4.60.2-cp314-cp314t-win32.whl", hash = "sha256:bbfbc918a75437fe7e6d64d1b1e1f713237df1cf00f3a36dedae910b2ba01cee", size = 2330985, upload-time = "2025-12-09T13:37:45.157Z" }, + { url = "https://files.pythonhosted.org/packages/91/24/fea0ba4d3a32d4ed1103a1098bfd99dc78b5fe3bb97202920744a37b73dc/fonttools-4.60.2-cp314-cp314t-win_amd64.whl", hash = "sha256:0e5cd9b0830f6550d58c84f3ab151a9892b50c4f9d538c5603c0ce6fff2eb3f1", size = 2396226, upload-time = "2025-12-09T13:37:47.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/ae/a6d9446cb258d3fe87e311c2d7bacf8e8da3e5809fbdc3a8306db4f6b14e/fonttools-4.60.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:a3c75b8b42f7f93906bdba9eb1197bb76aecbe9a0a7cf6feec75f7605b5e8008", size = 2857184, upload-time = "2025-12-09T13:37:49.96Z" }, + { url = "https://files.pythonhosted.org/packages/3a/f3/1b41d0b6a8b908aa07f652111155dd653ebbf0b3385e66562556c5206685/fonttools-4.60.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0f86c8c37bc0ec0b9c141d5e90c717ff614e93c187f06d80f18c7057097f71bc", size = 2401877, upload-time = "2025-12-09T13:37:52.307Z" }, + { url = "https://files.pythonhosted.org/packages/71/57/048fd781680c38b05c5463657d0d95d5f2391a51972176e175c01de29d42/fonttools-4.60.2-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe905403fe59683b0e9a45f234af2866834376b8821f34633b1c76fb731b6311", size = 4878073, upload-time = "2025-12-09T13:37:56.477Z" }, + { url = "https://files.pythonhosted.org/packages/45/bb/363364f052a893cebd3d449588b21244a9d873620fda03ad92702d2e1bc7/fonttools-4.60.2-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38ce703b60a906e421e12d9e3a7f064883f5e61bb23e8961f4be33cfe578500b", size = 4835385, upload-time = "2025-12-09T13:37:58.882Z" }, + { url = "https://files.pythonhosted.org/packages/1c/38/e392bb930b2436287e6021672345db26441bf1f85f1e98f8b9784334e41d/fonttools-4.60.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9e810c06f3e79185cecf120e58b343ea5a89b54dd695fd644446bcf8c026da5e", size = 4853084, upload-time = "2025-12-09T13:38:01.578Z" }, + { url = "https://files.pythonhosted.org/packages/65/60/0d77faeaecf7a3276a8a6dc49e2274357e6b3ed6a1774e2fdb2a7f142db0/fonttools-4.60.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:38faec8cc1d12122599814d15a402183f5123fb7608dac956121e7c6742aebc5", size = 4971144, upload-time = "2025-12-09T13:38:03.748Z" }, + { url = "https://files.pythonhosted.org/packages/ba/c7/6d3ac3afbcd598631bce24c3ecb919e7d0644a82fea8ddc4454312fc0be6/fonttools-4.60.2-cp39-cp39-win32.whl", hash = "sha256:80a45cf7bf659acb7b36578f300231873daba67bd3ca8cce181c73f861f14a37", size = 1499411, upload-time = "2025-12-09T13:38:05.586Z" }, + { url = "https://files.pythonhosted.org/packages/5a/1c/9dedf6420e23f9fa630bb97941839dddd2e1e57d1b2b85a902378dbe0bd2/fonttools-4.60.2-cp39-cp39-win_amd64.whl", hash = "sha256:c355d5972071938e1b1e0f5a1df001f68ecf1a62f34a3407dc8e0beccf052501", size = 1547943, upload-time = "2025-12-09T13:38:07.604Z" }, + { url = "https://files.pythonhosted.org/packages/79/6c/10280af05b44fafd1dff69422805061fa1af29270bc52dce031ac69540bf/fonttools-4.60.2-py3-none-any.whl", hash = "sha256:73cf92eeda67cf6ff10c8af56fc8f4f07c1647d989a979be9e388a49be26552a", size = 1144610, upload-time = "2025-12-09T13:38:09.5Z" }, +] + +[[package]] +name = "fonttools" +version = "4.63.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +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/f2/c9/4141c90a90db20f807c7e10bfd689fe53eb8f7f4caff58ee4d4dfe46919f/fonttools-4.63.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e3297a6a4059b4acc3a1e9a8b04741f240a80044eef08ebd32e8b5bcdddce75b", size = 2884632, upload-time = "2026-05-14T12:02:38.56Z" }, + { url = "https://files.pythonhosted.org/packages/b8/46/ad12b5c10eae602d7ef814b02afa08aacbf89da917fed5b071282b7eadc2/fonttools-4.63.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b1cd75a03ad8cb5bc40c90bfde68c0c47de423aa19e5c0f362b43520645eea94", size = 2429441, upload-time = "2026-05-14T12:02:41.162Z" }, + { url = "https://files.pythonhosted.org/packages/90/8f/bdca24a84c81d56fffed052229cdcff368f6e05882e526f4558891481f65/fonttools-4.63.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0425b277a59cff3d80ca42162a8de360f318438a2ac83570842a678d826d579", size = 4946346, upload-time = "2026-05-14T12:02:43.41Z" }, + { url = "https://files.pythonhosted.org/packages/04/59/a639c0e136441ee91a65b56fdf89e5d075927e7a09c559d1b0f5276577db/fonttools-4.63.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d7e5c9973aa04c95650c96e5f5ad865fbf42d62079163ecfab1e01cbc2504c22", size = 4903184, upload-time = "2026-05-14T12:02:45.742Z" }, + { url = "https://files.pythonhosted.org/packages/e6/53/91b7e0cb45b536f3da1b29ba8cbab89f27e8b986809e0b1982303a3f4eca/fonttools-4.63.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cb014d58140a38135f16064c74c652ed57aa0b75cbf8bb59cac821f7edb5334e", size = 4922967, upload-time = "2026-05-14T12:02:48.386Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b7/87439bf44e6b97c5538cd29d0b7e366a5b8ce2cc132a4134fb67fa3f2fa2/fonttools-4.63.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:032038247a96c1690f9f31e377c389383c902531b085aa4e4dabd6f57f870e69", size = 5042799, upload-time = "2026-05-14T12:02:50.424Z" }, + { url = "https://files.pythonhosted.org/packages/ad/7c/8b96c3263b89ef99cded544c0f0636686f85dbd3c211c4dceef0231fca23/fonttools-4.63.0-cp310-cp310-win32.whl", hash = "sha256:a8b33a82979e0a6a34ff435cc81317be1f95ec1ebb7a3a2d1c8a6a54f02ae44e", size = 1519704, upload-time = "2026-05-14T12:02:52.523Z" }, + { url = "https://files.pythonhosted.org/packages/e5/4d/2c2f0069970b6907de8fb5b05c5c0193cc22f717df151d1c7aef1c738f58/fonttools-4.63.0-cp310-cp310-win_amd64.whl", hash = "sha256:0c18358a155d75034911c5ee397a5b44cd19dd325dbb8b35fb60bf421d6a72ac", size = 1568666, upload-time = "2026-05-14T12:02:54.917Z" }, + { url = "https://files.pythonhosted.org/packages/75/2b/a7f1545bdf5da69c4bda0cea2a5781f0ad2a6623e0277267672db43c5fe6/fonttools-4.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b8ae05d9eacf6081414d759c0a352769ac28ce31280d6bb8e77b03f9e3c449f", size = 2881793, upload-time = "2026-05-14T12:02:56.645Z" }, + { url = "https://files.pythonhosted.org/packages/49/50/965308c703f085f225db2886813b27e015b8b3438c350b22dd65b52c2a2c/fonttools-4.63.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79cdc9f567aec74a72918fd060283911406750cbc9fd28c1316023deb6ce31a9", size = 2428130, upload-time = "2026-05-14T12:02:58.891Z" }, + { url = "https://files.pythonhosted.org/packages/d8/38/6937fbd7f2dc3a6b48725851bc2c15ec949b9af14d9bbcb5fe83cdf9bdf9/fonttools-4.63.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c14b4fd138c4bafcca294765c547914e1aa431ae1ca94ab99d8db08c958bd3b", size = 5111952, upload-time = "2026-05-14T12:03:01.263Z" }, + { url = "https://files.pythonhosted.org/packages/0b/43/a81f20050a3115b57d62c8e781446949512eac36690dc384ccea65ff4cc1/fonttools-4.63.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76ac49f929aecaf82d83250b8347e099d7aecba0f4726c1d9b6df3b8bb5fe18", size = 5082308, upload-time = "2026-05-14T12:03:03.211Z" }, + { url = "https://files.pythonhosted.org/packages/67/00/cdd9d4944ca6ae280d01e69cc37bde3bf663630b837a6fc6d2cd65d80e0e/fonttools-4.63.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dcf076a4474fe0d7367e5bbf5b052c7284fa1feca729c04176ce513521afd8a0", size = 5087932, upload-time = "2026-05-14T12:03:05.147Z" }, + { url = "https://files.pythonhosted.org/packages/f5/f1/0aa0dbea778c75adbef223c42019fd47d22262b905974d62d829545d485f/fonttools-4.63.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7dd683fef0663e9f0f45cf541d788d24caa3ec9db50796b588e1757d8b3bc007", size = 5213271, upload-time = "2026-05-14T12:03:07.238Z" }, + { url = "https://files.pythonhosted.org/packages/a8/99/253e4056e1f0e67b9390125a154b73b5eb73ad521bece95c004858fdeec2/fonttools-4.63.0-cp311-cp311-win32.whl", hash = "sha256:afefc1ed0a59785a7fb06ea7e1678e849c193e1e387db783579bc7b3056fcfcb", size = 2304473, upload-time = "2026-05-14T12:03:09.271Z" }, + { url = "https://files.pythonhosted.org/packages/08/60/defa5e69641db890a63be281f41345f4c33b157824eaf0b9fad3e08b0dcb/fonttools-4.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:063e08bd17bd5a90127a14123de0d6a952dbc847695fd98b63c043d58057f90c", size = 2356389, upload-time = "2026-05-14T12:03:11.53Z" }, + { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" }, + { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" }, + { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" }, + { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" }, + { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" }, + { 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 = "gallery" -version = "0.1.2" +version = "0.1.3" source = { editable = "." } dependencies = [ { name = "argcomplete" }, @@ -303,6 +854,9 @@ dependencies = [ { name = "platformdirs", version = "4.3.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, { name = "platformdirs", version = "4.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, { name = "platformdirs", version = "4.9.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pymupdf", version = "1.24.11", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "pymupdf", version = "1.26.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pymupdf", version = "1.28.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, { name = "pytest", version = "8.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, { name = "pytest", version = "9.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, @@ -312,47 +866,108 @@ dependencies = [ { name = "textual", version = "8.2.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, ] -[package.optional-dependencies] +[package.dev-dependencies] dev = [ - { name = "black", version = "24.8.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "black", version = "25.11.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "black", version = "26.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "mypy", version = "1.14.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "mypy", version = "1.19.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "mypy", version = "1.20.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "pylint", version = "3.2.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "pylint", version = "3.3.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "pylint", version = "4.0.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pip-audit", version = "2.7.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "pip-audit", version = "2.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pip-audit", version = "2.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, { name = "pytest", version = "8.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, { name = "pytest", version = "8.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, { name = "pytest", version = "9.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "ruff" }, + { name = "ty" }, ] [package.metadata] requires-dist = [ { name = "argcomplete", specifier = ">=3.0" }, - { name = "black", marker = "extra == 'dev'", specifier = ">=22.0" }, { name = "jinja2", specifier = ">=3.0.0" }, - { name = "mypy", marker = "extra == 'dev'", specifier = ">=0.900" }, { name = "platformdirs", specifier = ">=3.0" }, - { name = "pylint", marker = "extra == 'dev'", specifier = ">=2.0" }, + { name = "pymupdf", specifier = ">=1.23" }, { name = "pytest" }, - { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0" }, { name = "pyyaml", specifier = ">=5.0" }, { name = "textual", specifier = ">=0.50" }, ] -provides-extras = ["dev"] + +[package.metadata.requires-dev] +dev = [ + { name = "pip-audit", specifier = ">=2.7" }, + { name = "pytest", specifier = ">=7.0" }, + { name = "ruff", specifier = ">=0.6" }, + { name = "ty", specifier = ">=0.0.1" }, +] [[package]] -name = "importlib-metadata" -version = "8.7.1" +name = "html5lib" +version = "1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "zipp", marker = "python_full_version == '3.9.*'" }, + { name = "six", marker = "python_full_version < '3.9'" }, + { name = "webencodings", marker = "python_full_version < '3.9'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ac/b6/b55c3f49042f1df3dcd422b7f224f939892ee94f22abcf503a9b7339eaf2/html5lib-1.1.tar.gz", hash = "sha256:b2e5b40261e20f354d198eae92afc10d750afb487ed5e50f9c4eaf07c184146f", size = 272215, upload-time = "2020-06-22T23:32:38.834Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" }, + { url = "https://files.pythonhosted.org/packages/6c/dd/a834df6482147d48e225a49515aabc28974ad5a4ca3215c18a882565b028/html5lib-1.1-py2.py3-none-any.whl", hash = "sha256:0d78f8fde1c230e99fe37986a60526d7049ed4bf8a9fadbad5f00e22e58e041d", size = 112173, upload-time = "2020-06-22T23:32:36.781Z" }, +] + +[[package]] +name = "idna" +version = "3.15" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/82/77/7b3966d0b9d1d31a36ddf1746926a11dface89a83409bf1483f0237aa758/idna-3.15.tar.gz", hash = "sha256:ca962446ea538f7092a95e057da437618e886f4d349216d2b1e294abfdb65fdc", size = 199245, upload-time = "2026-05-12T22:45:57.011Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/23/408243171aa9aaba178d3e2559159c24c1171a641aa83b67bdd3394ead8e/idna-3.15-py3-none-any.whl", hash = "sha256:048adeaf8c2d788c40fee287673ccaa74c24ffd8dcf09ffa555a2fbb59f10ac8", size = 72340, upload-time = "2026-05-12T22:45:55.733Z" }, +] + +[[package]] +name = "idna" +version = "3.18" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" }, +] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +dependencies = [ + { name = "zipp", version = "3.20.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/be/f3e8c6081b684f176b761e6a2fef02a0be939740ed6f54109a2951d806f3/importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065", size = 43372, upload-time = "2024-09-09T17:03:14.677Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/6a/4604f9ae2fa62ef47b9de2fa5ad599589d28c9fd1d335f32759813dfa91e/importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717", size = 36115, upload-time = "2024-09-09T17:03:13.39Z" }, +] + +[[package]] +name = "importlib-resources" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "zipp", version = "3.23.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693, upload-time = "2025-01-03T18:51:56.698Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461, upload-time = "2025-01-03T18:51:54.306Z" }, ] [[package]] @@ -384,49 +999,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, ] -[[package]] -name = "isort" -version = "5.13.2" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.8.1' and python_full_version < '3.9'", - "python_full_version < '3.8.1'", -] -sdist = { url = "https://files.pythonhosted.org/packages/87/f9/c1eb8635a24e87ade2efce21e3ce8cd6b8630bb685ddc9cdaca1349b2eb5/isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109", size = 175303, upload-time = "2023-12-13T20:37:26.124Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/b3/8def84f539e7d2289a02f0524b944b15d7c75dab7628bedf1c4f0992029c/isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6", size = 92310, upload-time = "2023-12-13T20:37:23.244Z" }, -] - -[[package]] -name = "isort" -version = "6.1.0" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version == '3.9.*'", -] -dependencies = [ - { name = "importlib-metadata", marker = "python_full_version == '3.9.*'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1e/82/fa43935523efdfcce6abbae9da7f372b627b27142c3419fcf13bf5b0c397/isort-6.1.0.tar.gz", hash = "sha256:9b8f96a14cfee0677e78e941ff62f03769a06d412aabb9e2a90487b3b7e8d481", size = 824325, upload-time = "2025-10-01T16:26:45.027Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7f/cc/9b681a170efab4868a032631dea1e8446d8ec718a7f657b94d49d1a12643/isort-6.1.0-py3-none-any.whl", hash = "sha256:58d8927ecce74e5087aef019f778d4081a3b6c98f15a80ba35782ca8a2097784", size = 94329, upload-time = "2025-10-01T16:26:43.291Z" }, -] - -[[package]] -name = "isort" -version = "8.0.1" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.15'", - "python_full_version >= '3.12' and python_full_version < '3.15'", - "python_full_version == '3.11.*'", - "python_full_version == '3.10.*'", -] -sdist = { url = "https://files.pythonhosted.org/packages/ef/7c/ec4ab396d31b3b395e2e999c8f46dec78c5e29209fac49d1f4dace04041d/isort-8.0.1.tar.gz", hash = "sha256:171ac4ff559cdc060bcfff550bc8404a486fee0caab245679c2abe7cb253c78d", size = 769592, upload-time = "2026-02-28T10:08:20.685Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3e/95/c7c34aa53c16353c56d0b802fba48d5f5caa2cdee7958acbcb795c830416/isort-8.0.1-py3-none-any.whl", hash = "sha256:28b89bc70f751b559aeca209e6120393d43fbe2490de0559662be7a9787e3d75", size = 89733, upload-time = "2026-02-28T10:08:19.466Z" }, -] - [[package]] name = "jinja2" version = "3.1.6" @@ -441,100 +1013,294 @@ wheels = [ ] [[package]] -name = "librt" -version = "0.10.0" +name = "kiwisolver" +version = "1.4.7" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/39/cb/c1945e506893b5b8577fb45a60c80e3ffe4a82092a04a6f29b0b951d9a24/librt-0.10.0.tar.gz", hash = "sha256:1aba1e8aa4e3307a7be68a74149545fde7451964dc0235a8bec5704a17bdda42", size = 191799, upload-time = "2026-05-05T16:31:23.535Z" } +resolution-markers = [ + "python_full_version == '3.9.*'", + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/85/4d/2255e1c76304cbd60b48cee302b66d1dde4468dc5b1160e4b7cb43778f2a/kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60", size = 97286, upload-time = "2024-09-04T09:39:44.302Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cf/18/827e5c1262a88c2602e86f99aee0f288ffea3280dbd2ff448858ef9dc6e9/librt-0.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7dc99f9642100b86e5f6bb14cdc9970009e31a9ef7d64df6704b7018451524a3", size = 76461, upload-time = "2026-05-05T16:29:00.422Z" }, - { url = "https://files.pythonhosted.org/packages/ee/90/54254e30287f5a5abec6fef22d976987476e966be5fdff51fe8c2d5d73d1/librt-0.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8298cedfcfaff3790000bd057aaaa3df1b0ab54cf7b48eeab16184cbb1bc66b9", size = 79740, upload-time = "2026-05-05T16:29:01.926Z" }, - { url = "https://files.pythonhosted.org/packages/4c/20/e93264b52113669d98d3b63ff94d4ce0c4dd49ae0503f1788440a884e5f0/librt-0.10.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee7dbe312dbf76468255b79a7ba311236fde620f2f7055fc09d421e31340314e", size = 243472, upload-time = "2026-05-05T16:29:03.373Z" }, - { url = "https://files.pythonhosted.org/packages/35/ad/34a5141178e8b18a4cfa45d1a0d523c84397e2abd5d06fea2d846da687e8/librt-0.10.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:56ed90c48c19249012dadfd79a1bc13bd5168ea60a70722d330a3a600c0b1852", size = 232073, upload-time = "2026-05-05T16:29:04.815Z" }, - { url = "https://files.pythonhosted.org/packages/97/1f/67240e910cd9f9ab1498c1470738345fc29dce5dc9719db1e0e09d1e861f/librt-0.10.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d74ca0f4b2b09c117f913d4df01f6b934dff8a271096b35167d5264a31649f0", size = 256956, upload-time = "2026-05-05T16:29:06.516Z" }, - { url = "https://files.pythonhosted.org/packages/22/50/3a2b3482c27d607f6e8216d913c6bc592b9a2141d96990309452340a78e3/librt-0.10.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8eb2daa9375f93c0e55ff5e44a4bbe98f39e5fe52e1abf9c97acb67743b61bf8", size = 250593, upload-time = "2026-05-05T16:29:08.324Z" }, - { url = "https://files.pythonhosted.org/packages/e7/1c/07dba133d79f93322fa17514062f1a2a50d6bdfb7baec4acf78193d7fad1/librt-0.10.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7b09b90e634e6dff57978cd358070046071e2b120501f10787aeb35425f504f6", size = 263582, upload-time = "2026-05-05T16:29:09.866Z" }, - { url = "https://files.pythonhosted.org/packages/aa/ac/033f2c6d6ab0b48f15f02e5bf065521b11a51922806017f8b6274df30d69/librt-0.10.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:2cf22fd379d60c739b800d4295ed34045f8b04aa8df9c12bd2f8f43f7fe672b7", size = 259307, upload-time = "2026-05-05T16:29:11.675Z" }, - { url = "https://files.pythonhosted.org/packages/6e/10/679046cd75d5a52c0104c890d8f69574ef4e619c683e59c15584d03a2457/librt-0.10.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:74c798793fcf29a84d442278ebe0bb1fff79fe58ac4106eeff7019cbba861423", size = 257342, upload-time = "2026-05-05T16:29:13.14Z" }, - { url = "https://files.pythonhosted.org/packages/1e/d5/dbaac9c0884f78a53dda22b9ec92bb788e1400e762ed7623fa96928c8da5/librt-0.10.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:dc4f1573401e8dbe6c26511fe027620b0fb30ae9a7ab814e02e510626b8b5f9c", size = 280141, upload-time = "2026-05-05T16:29:14.922Z" }, - { url = "https://files.pythonhosted.org/packages/cc/81/71f18cf8eb340d9fda011498870910f6a8697aeb50833005d3d8107653fd/librt-0.10.0-cp310-cp310-win32.whl", hash = "sha256:e1428275f5fe3d4db6822e58d8b005a5b28ffca55e8433ebc051247fbe46429f", size = 62257, upload-time = "2026-05-05T16:29:16.226Z" }, - { url = "https://files.pythonhosted.org/packages/df/52/6bcebc2f870c4836bcb372be885fae7f17a1d25037d3a8250ef79fbe0124/librt-0.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:0708e9408f585b0f065081680583a577652099680ccf820c7538904322b679c3", size = 70321, upload-time = "2026-05-05T16:29:17.41Z" }, - { url = "https://files.pythonhosted.org/packages/e2/a3/1472717d2325adacc8d335ba2e4078015c09d75b599f3cf48e967b3d306e/librt-0.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:01b4500ca3a625450c032a9142a8e843923ce263fa8a92ad1b38927cabe2fe72", size = 76045, upload-time = "2026-05-05T16:29:18.731Z" }, - { url = "https://files.pythonhosted.org/packages/a6/31/bfe32355d4b369aef3d7aa442df663bb5558c2ffa2de286cb2956346bc24/librt-0.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6b7e42d1b3e300d20bfc87e72ffd62f0a92a2cb3c35f7bf90df90c9d2a49f74c", size = 79466, upload-time = "2026-05-05T16:29:20.052Z" }, - { url = "https://files.pythonhosted.org/packages/e9/f1/83f8a2c715ba2cac9b7387a5a5cea25f717f7184320cfe48b36bed9c58e9/librt-0.10.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8ef7b8c61ce3a1b597cd3e15348ff1574325165c2e7ce09a718154cde2a7950", size = 242283, upload-time = "2026-05-05T16:29:21.596Z" }, - { url = "https://files.pythonhosted.org/packages/cc/94/c3a4ce94857f0004a542f86662806383611858f522722db58efaec0a1472/librt-0.10.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:e73c84f72d1fa0d6eaa7a1930b436ba8d2c90c58d77bfabb09995a69ad35f6c0", size = 230735, upload-time = "2026-05-05T16:29:23.335Z" }, - { url = "https://files.pythonhosted.org/packages/d1/41/e962bb26c7728eb7b3a69e490d0c800fd9968a6970e390c1f18ddb56093d/librt-0.10.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9728cb98713bd862fb8f4fd6a642d1896c86058a41d77c70f3d5cee75e725275", size = 256606, upload-time = "2026-05-05T16:29:24.91Z" }, - { url = "https://files.pythonhosted.org/packages/66/3a/4e46a707b1ecc993fd691071623b9beab89703a63bd21cc7807e06c28209/librt-0.10.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:648b7e941d20acd72f9652115e0e53facd98156d61f9ebf7a812bdef8bdccea9", size = 249739, upload-time = "2026-05-05T16:29:26.648Z" }, - { url = "https://files.pythonhosted.org/packages/b2/f5/dc5b7eb294656ad23d4ff4cf8514208d54fe1026b909d726a0dc026689c9/librt-0.10.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c3e33747c068e86a9007c20fdb777eb5ba8d3d19136d7812f88e69a713041b6f", size = 261414, upload-time = "2026-05-05T16:29:28.702Z" }, - { url = "https://files.pythonhosted.org/packages/58/e4/990ed8d12c7f114ac8f8ccd47f7d9bd9704ef61acfcb1df4a05047da7710/librt-0.10.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d509c745bf7e77d1107cf05e6abb249dc03fad13eb39f2286a49deedaeb2bcd7", size = 256614, upload-time = "2026-05-05T16:29:30.357Z" }, - { url = "https://files.pythonhosted.org/packages/60/eb/52d2726c7fb22818507dc3cc166c8f36dd4a4b68a7be67f12006ac8777c1/librt-0.10.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:786ad5a15e99d0e0e74f3adbeecc198a5ac58f340be07e984723d1e0074838de", size = 255144, upload-time = "2026-05-05T16:29:32.106Z" }, - { url = "https://files.pythonhosted.org/packages/bc/df/bd5591a78f7531fce4b6eb9962aadc6adc9560a01570442a884b6e554abe/librt-0.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:075582d877a97ee3d8e77bda3689dbe617b14f6469224a2d80b4b6c38e3951aa", size = 279121, upload-time = "2026-05-05T16:29:33.688Z" }, - { url = "https://files.pythonhosted.org/packages/fd/df/7c2b838dfc89a1762dd156d8b0c39848a7a2845d725a50be5a6e021fb8ba/librt-0.10.0-cp311-cp311-win32.whl", hash = "sha256:75ecdc3f5a90065aa2af2e574706c5495adc392520762dcf10b1aa716f0b8090", size = 62593, upload-time = "2026-05-05T16:29:35.152Z" }, - { url = "https://files.pythonhosted.org/packages/91/19/22ff572981049a9d436a083dbea1572d0f5dc068b7353637d2dd9977c8f1/librt-0.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:b6f6084884131d8a52cb9d7095ff2aa52c1e786d9fdaefab1fb4515415e9e083", size = 70914, upload-time = "2026-05-05T16:29:36.407Z" }, - { url = "https://files.pythonhosted.org/packages/12/22/1697cc64f4a5c7e9bce55e99c6d234a346beaedaefcd1e2ca90dd285f98c/librt-0.10.0-cp311-cp311-win_arm64.whl", hash = "sha256:0140bd62151160047e89b2730cb6f8506cdac5127baa1afb9231e4dd3fe7f681", size = 61176, upload-time = "2026-05-05T16:29:37.62Z" }, - { url = "https://files.pythonhosted.org/packages/12/8e/cbb5b6f6e45e65c10a42449a69eaccc44d73e6a081ea752fbc5221c6dc1c/librt-0.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b4b58a44b407e91f633dafee008de9ddea6aa2a555ed94929c099260910bd0ba", size = 77327, upload-time = "2026-05-05T16:29:38.919Z" }, - { url = "https://files.pythonhosted.org/packages/e9/3d/8233cbee8e99e6a8992f02bfc2dec8d787509566a511d1fde2574ee7473f/librt-0.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:950b79b11762531bdf45a9df909d2f9a2a8445c70c88665c01d14c8511a27dc5", size = 79971, upload-time = "2026-05-05T16:29:40.96Z" }, - { url = "https://files.pythonhosted.org/packages/87/6f/5264b298cef2b72fc97d2dde56c66181eda35204bf5dcd1ed0c3d0a0a782/librt-0.10.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4538453f51be197633b425912c150e25b0667252d3741c53e8368176d98d9d37", size = 246559, upload-time = "2026-05-05T16:29:42.701Z" }, - { url = "https://files.pythonhosted.org/packages/07/7b/19b1b859cc60d5f99276cc2b3144d91556c6d1b1e4ebb50359696bebf7a8/librt-0.10.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:70b955f091beac93e994a0b7ec616934f63b3ea5c3d6d7af847562f935aceca7", size = 235216, upload-time = "2026-05-05T16:29:44.193Z" }, - { url = "https://files.pythonhosted.org/packages/6e/56/a2f40717142a8af46289f57874ef914353d8faccd5e4f8e594ab1e16e8c7/librt-0.10.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:483e685e06b6163728ba6c85d74315176be7190f432ec2a41226e5e14355d5f0", size = 263108, upload-time = "2026-05-05T16:29:46.365Z" }, - { url = "https://files.pythonhosted.org/packages/67/ca/15c625c3bdc0167c01e04ef8878317e9713f3bfa788438342f7a94c7b22c/librt-0.10.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ac53d946a009d1a38c44a60812708c9458fb2a239a5f630d8e625571386650f", size = 255280, upload-time = "2026-05-05T16:29:48.087Z" }, - { url = "https://files.pythonhosted.org/packages/ed/c5/ba301d571d9e05844e2435b73aba30bee77bb75ce155c9affcfd2173dd03/librt-0.10.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bc8771c9fcf0ea894ca41fdc2abd83572c2fbda221f232d86e718614e57ff513", size = 268829, upload-time = "2026-05-05T16:29:49.628Z" }, - { url = "https://files.pythonhosted.org/packages/8b/60/af70e135bc1f1fe15dd3894b1e4bbefc7ecdf911749a925a39eb86ceb2a1/librt-0.10.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:70805dbc5257892ac572f86290a61e3c8d90224ecce1a8b2d1f7ed51965417f4", size = 262051, upload-time = "2026-05-05T16:29:51.244Z" }, - { url = "https://files.pythonhosted.org/packages/83/c2/c8236eb8b421bac5a172ba208f965abaa89805da2a3fa112bdf1764caf8f/librt-0.10.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d3b4f300f7bcba6e2ff73fb8bef1898479e9772bfa2682998c636391633ec826", size = 264347, upload-time = "2026-05-05T16:29:53.013Z" }, - { url = "https://files.pythonhosted.org/packages/d6/f5/15b6d32bc25dacd4a60886a683d8128d6219910c122202b995a40dd4f8d2/librt-0.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:943bc943f92f4fb3408fae62485c6a3ad68ce4f2ee205643a39641525c19a276", size = 286482, upload-time = "2026-05-05T16:29:54.675Z" }, - { url = "https://files.pythonhosted.org/packages/fb/8e/b1b959bacd323eb4360579db992513e1406d1c6ef7edb57b5511fd0666fd/librt-0.10.0-cp312-cp312-win32.whl", hash = "sha256:6065c1a758fba1010b41401013903d3d5d2750eab425ddedd584abac31d0630e", size = 62955, upload-time = "2026-05-05T16:29:56.39Z" }, - { url = "https://files.pythonhosted.org/packages/9e/4c/d4cd6e4b9fc24098e63cc85537d1b6689682aee96809c38f08072067cc2b/librt-0.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:d788ecbe208ab352dab0e105cc06057bf9a2fc7e58cabb0d751ad9e30062b9e2", size = 71191, upload-time = "2026-05-05T16:29:57.682Z" }, - { url = "https://files.pythonhosted.org/packages/2b/19/8641da1f63d24b92354a492f893c022d6b3a0df44e70c8eff49364613983/librt-0.10.0-cp312-cp312-win_arm64.whl", hash = "sha256:6003d1f295bdba02656dc81308208fc060d0a51d8c0d0a6db70f7f3c57b9ba0a", size = 61432, upload-time = "2026-05-05T16:29:58.971Z" }, - { url = "https://files.pythonhosted.org/packages/e5/29/681a75c82f4cc90d29e4b257a3299b79fe13fe927a04c57b8109d70b6957/librt-0.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f0ede79d682e73f91c1b599a76d78b7464b9b5d213754cedb13372d9df36e596", size = 77299, upload-time = "2026-05-05T16:30:00.209Z" }, - { url = "https://files.pythonhosted.org/packages/62/24/0c7ca445a55d04be79cac19819437fd094782347fa116f6681844fa6143e/librt-0.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e0ba0b131fdb336c8b9c948e397f4a7e649d0f783b529f07b647bf4961df392e", size = 79930, upload-time = "2026-05-05T16:30:01.555Z" }, - { url = "https://files.pythonhosted.org/packages/fe/1f/1e2b8f6443ef9e9a81e89486ca70e22f3684f93db003ce6eaefc3d0839b9/librt-0.10.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2728117da2afb96fb957768725ee43dc9a2d73b031e02da424b818a3cdd3a275", size = 246195, upload-time = "2026-05-05T16:30:03.261Z" }, - { url = "https://files.pythonhosted.org/packages/74/61/9dc9e03de0439ad84c1c240aac8b747f12c90cb797ea6042f7bdb8d3410f/librt-0.10.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:723ba80594c49cdf0584196fc430752262605dc9449902fc9bd3d9b79976cb77", size = 234951, upload-time = "2026-05-05T16:30:04.881Z" }, - { url = "https://files.pythonhosted.org/packages/55/f4/635223117d7590875bca441275065a3bf491203ad4208bd1cc3ffd90c5a1/librt-0.10.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7292edaaca294a61a978c53a3c7d6130d099b0dfbc8f0a65916cdc6b891b9852", size = 262768, upload-time = "2026-05-05T16:30:06.638Z" }, - { url = "https://files.pythonhosted.org/packages/e5/66/b04152d0cd8b6ca2b428a8bd3230343230c35ed304a932f35b5375f2f828/librt-0.10.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:89fe9d539f2c10a1666633eeeac507ce95dd06d9ecc58de3c6390dba156a3d3a", size = 255075, upload-time = "2026-05-05T16:30:08.216Z" }, - { url = "https://files.pythonhosted.org/packages/35/1e/25bac4c7f2ca36f0e612cade186970683cf79153d96beccc3a11a9e19b97/librt-0.10.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4efa7b9587503fa5b67f40593302b9c8836d211d222ff9f7cafe67be5f8f0b10", size = 268559, upload-time = "2026-05-05T16:30:10.1Z" }, - { url = "https://files.pythonhosted.org/packages/18/54/4601faab35b6632a13200faa146ca62bfd111ffbe2568be430d65c89493a/librt-0.10.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:22dc982ef59df0136df36092ccbdbb570ced8aafb33e49585739b2f1de1c13b6", size = 261753, upload-time = "2026-05-05T16:30:11.912Z" }, - { url = "https://files.pythonhosted.org/packages/1b/cf/39f4023509e94fade8b074666fa3292db9cb6b34ea5dcbe7af53df9fca1d/librt-0.10.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6f2e5f3606253a84cea719c94a3bb1c54487b5d617d0254d46e0920d8a06be3f", size = 264055, upload-time = "2026-05-05T16:30:13.465Z" }, - { url = "https://files.pythonhosted.org/packages/8e/00/40247209fc46a8e308a91412d5206aedf8efb667ee89eb625820106a5c2f/librt-0.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:40884bfaa1e29f6b6a9be255007d8f359bfc9e61d68bdef8ed3158bfcbc95df9", size = 286190, upload-time = "2026-05-05T16:30:15.073Z" }, - { url = "https://files.pythonhosted.org/packages/d8/6e/5566beb94431a985abe1787af5ef86e087750172ff9d0bbf20f93e88132d/librt-0.10.0-cp313-cp313-win32.whl", hash = "sha256:3cd34cd8254eba756660bff6c2da91278248184301054fe3e4feb073bdd49b14", size = 62949, upload-time = "2026-05-05T16:30:16.503Z" }, - { url = "https://files.pythonhosted.org/packages/d0/c2/3ea3301d6c8dff51d39dbe8ed75db3dc92896947d4afb5eeadf821c1e67f/librt-0.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:7baac5313e2d8dce1386f97777a8d03ab28f5fe1e780b3b9ac2ee7544551fedc", size = 71152, upload-time = "2026-05-05T16:30:17.766Z" }, - { url = "https://files.pythonhosted.org/packages/3c/de/5d49cb92cadcbc77d3abc27b93fd6030ed8437487dde2eae38cab5e6704d/librt-0.10.0-cp313-cp313-win_arm64.whl", hash = "sha256:afc5b4406c8e2515698d922a5c7823a009312835ea58196671fff40e35cb8166", size = 61336, upload-time = "2026-05-05T16:30:19.021Z" }, - { url = "https://files.pythonhosted.org/packages/6a/64/7165e08108cc185a13a9c069f0685e6ef92e70e07fddf7edf5e7348c6316/librt-0.10.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f09588a30e6a22ec624090d72a3ab1a6d4d5485c3ed739603e76aa3c16efa688", size = 76794, upload-time = "2026-05-05T16:30:20.392Z" }, - { url = "https://files.pythonhosted.org/packages/ae/ef/bf8613febf651b90c5222ee79dea5ae58d4cc2b544df69d3033424448934/librt-0.10.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:131ade118d12bd7a0adc4e655474a553f1b76cf78385868885944d21d51e45e0", size = 79662, upload-time = "2026-05-05T16:30:22.025Z" }, - { url = "https://files.pythonhosted.org/packages/b6/67/9eddd165c1d8397bdf99b38bf12b5a55b3def5035b49eedb49f2775d1430/librt-0.10.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8b9ab28e40d011c373a189eae900c916e66d6fbecf7983e9e4883089ee085ef", size = 242390, upload-time = "2026-05-05T16:30:23.51Z" }, - { url = "https://files.pythonhosted.org/packages/10/d1/d95da80334501866cd37004ab5d7483220d05862fab4b5405394f0264f0d/librt-0.10.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:67c39bb30da73bae1f293d1ed8bc2f8f6642649dd0928d3600aeff3041ac23d6", size = 232603, upload-time = "2026-05-05T16:30:25.198Z" }, - { url = "https://files.pythonhosted.org/packages/0c/fa/e6d64d28718bc1be4e1736fcb037ca1c4dfca927e7167df75a7d5215665e/librt-0.10.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8c3273c6b774614f093c8927c2bf1b077d0fefde988fe98f46a333734e5597ab", size = 259187, upload-time = "2026-05-05T16:30:26.772Z" }, - { url = "https://files.pythonhosted.org/packages/72/3f/3fdb77e7f937dad59cfd76b720be7e7643400ec76b2da35befab8d66ba30/librt-0.10.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9dd7c1b86a4baa583ab5db977484b93a2c474e69e96ef3e9538387ea54229cb9", size = 251846, upload-time = "2026-05-05T16:30:28.56Z" }, - { url = "https://files.pythonhosted.org/packages/18/ca/f4d49133dd86a6f55d79eca30bf412fa722f511a9abe67f62f57aa64e66a/librt-0.10.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a77385c5a202e831149f7ad03be9e67cf80e957e52c614e83dcb822c95222eb8", size = 264936, upload-time = "2026-05-05T16:30:30.491Z" }, - { url = "https://files.pythonhosted.org/packages/de/66/a8df2fbadc1f6c1827a096d11c40175bd526133480bd3bc88ec64a03d257/librt-0.10.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:c6a5eafa74b5655bad59886138ed68426f098a6beb8cb95a71f2cc3cd8bb33fe", size = 258699, upload-time = "2026-05-05T16:30:32.002Z" }, - { url = "https://files.pythonhosted.org/packages/bb/73/1e3c83613fe05451bb969e27b68a573d177f08d5f63533cc29fec0989658/librt-0.10.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1fc93d0439204c50ab4d1512611ce2c206f1b369b419f69c7c27c761561e3291", size = 259825, upload-time = "2026-05-05T16:30:35.077Z" }, - { url = "https://files.pythonhosted.org/packages/09/24/5e2f926ee9d3ef348d9339526d7062abb5c44d8419e3179528c01d78c102/librt-0.10.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:79e713c178bc7a744adfbee6b4619a288eecc0c914da2a9313a20255abe2f0cf", size = 282548, upload-time = "2026-05-05T16:30:36.639Z" }, - { url = "https://files.pythonhosted.org/packages/fc/7d/3e89ed6ad0162561fa8bef9df3195e24263104c955713cd0237d3711fad2/librt-0.10.0-cp314-cp314-win32.whl", hash = "sha256:2eba9d955a68c41d9f326be3da42f163ec3518b7ab20f1c826224e7bed71e0bf", size = 58970, upload-time = "2026-05-05T16:30:38.183Z" }, - { url = "https://files.pythonhosted.org/packages/76/25/579e731c94a7086a268bfa3e7a4945cd47836bebd3cbf3faeafd2e7eaef9/librt-0.10.0-cp314-cp314-win_amd64.whl", hash = "sha256:cbfaf7f5145e9917f5d18bffa298eff6a19d74e7b8b11dabdca95785befe8dbf", size = 67260, upload-time = "2026-05-05T16:30:39.804Z" }, - { url = "https://files.pythonhosted.org/packages/6e/f8/235822b7ae0b2334f12ee18bcf2476d07924077a5efeea57dbe927704be2/librt-0.10.0-cp314-cp314-win_arm64.whl", hash = "sha256:8d6d385d1969849a6b1397114df22714b6ded917bada98668e3e974dc663477e", size = 57156, upload-time = "2026-05-05T16:30:41.412Z" }, - { url = "https://files.pythonhosted.org/packages/9f/e3/9b919cbf1e8eb770bf91bb7df28125e0f1daf4587169afefd95402636e9a/librt-0.10.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:6c3a82d3bd32631ef5c79922dfc028520c9ad840255979ab4d908271818039ee", size = 79150, upload-time = "2026-05-05T16:30:42.761Z" }, - { url = "https://files.pythonhosted.org/packages/6a/f5/72a944aa3bc3498169a168087eff58ca48b58bf1b704e59d091fd30739f3/librt-0.10.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d64cc66005dc324c9bb1fa3fc2841f529002f6eb15966d55e46d430f56955a6a", size = 82304, upload-time = "2026-05-05T16:30:44.082Z" }, - { url = "https://files.pythonhosted.org/packages/9c/e3/fcc290a33e295019759472dfa794d204e43504b276ac65eab7fd9da20ea3/librt-0.10.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9bb562cd28c88cd2c6a9a6c78f99dc39348d6b16c94adc25de0e574acf1176e9", size = 272556, upload-time = "2026-05-05T16:30:45.497Z" }, - { url = "https://files.pythonhosted.org/packages/fd/54/546975e4c997573885e7f040a05012f8838e06fb12b0c3c1fbb76254e9d7/librt-0.10.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:b809aa2854d019c28773b03605df22adc675ee4f3f4402d673581313e8906119", size = 256941, upload-time = "2026-05-05T16:30:47.059Z" }, - { url = "https://files.pythonhosted.org/packages/70/8c/f1d03401571b331653acddbd4e8cd955c06d945241dd08b25192fac0d04b/librt-0.10.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc15acabdd519bd4176fdadc2119e5e3093485d86f89138daf47e5b4cedb983a", size = 285855, upload-time = "2026-05-05T16:30:48.86Z" }, - { url = "https://files.pythonhosted.org/packages/0c/08/62cf80ff046c339faf56718b3a940244d4beb70f1c6407289b5830ec11e9/librt-0.10.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b1b2d835307d08ddadd94568e2369648ec9173bd3eea6d7f52a1abe717c81f98", size = 275321, upload-time = "2026-05-05T16:30:50.63Z" }, - { url = "https://files.pythonhosted.org/packages/d9/ea/da5918d4070362e9a4d2ee9cd34f9dc84902daad8fd4275f8504a727ff4e/librt-0.10.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d261c6a2f93335a5167887fb0223e8b98ffce20ee3fde242e8e58a37ece6d0e5", size = 293993, upload-time = "2026-05-05T16:30:52.577Z" }, - { url = "https://files.pythonhosted.org/packages/c9/8d/68b6086bed1fcdc314c640ea04e31e52d18052e08059fa595409d66a51a9/librt-0.10.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e2ffd44963f8e7f68995504d90f9881d64e94dc1d8e310039b9526108fc0c0f7", size = 284254, upload-time = "2026-05-05T16:30:55.086Z" }, - { url = "https://files.pythonhosted.org/packages/06/c8/b810f1d84ec34a5a7ed93d7b510ab04164d75fbdf23088d5c3fbe6b08357/librt-0.10.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5f285f6455ed495791c4d8630e5af732960adea93cac4c893d15619f2eae53e8", size = 284925, upload-time = "2026-05-05T16:30:56.728Z" }, - { url = "https://files.pythonhosted.org/packages/5a/00/3c82d4158c5a2c62528b8fccce65a8c9ad700e480e86f9389387435089a5/librt-0.10.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f6034ff52e663d34c7b82ef2aa2f94ad7c1d939e2368e63b06844bc4d127d2e1", size = 307830, upload-time = "2026-05-05T16:30:58.377Z" }, - { url = "https://files.pythonhosted.org/packages/99/3a/9c635ac3e8a00383ff689161d3eac8a30b3b2ddc711b40471e6b8983ea29/librt-0.10.0-cp314-cp314t-win32.whl", hash = "sha256:657860fd877fba6a241ea088ef99f63ca819945d3c715265da670bad56c37ebe", size = 60147, upload-time = "2026-05-05T16:31:00.293Z" }, - { url = "https://files.pythonhosted.org/packages/dc/e8/6f65f3e565d4ac212cddddd552eacc8035ffdf941ca0ad6fe945a211d41f/librt-0.10.0-cp314-cp314t-win_amd64.whl", hash = "sha256:56ded2d66010203a0cb5af063b609e3f079531a0e5e576d618dece859fd2e1af", size = 68649, upload-time = "2026-05-05T16:31:01.778Z" }, - { url = "https://files.pythonhosted.org/packages/51/78/a0705a67cacd81e5fa01a5035b3adbdfbb43a7b8d4bd27e2b282ae61baf2/librt-0.10.0-cp314-cp314t-win_arm64.whl", hash = "sha256:1ee63f30abf18ed4830fdbaf87b2b6f4bba1e198d46085c314edde4045e56715", size = 58247, upload-time = "2026-05-05T16:31:03.191Z" }, - { url = "https://files.pythonhosted.org/packages/5e/86/ba668426245b9531ae3f922f98e7f721149fb71aa81d5f0c5aea7ca49645/librt-0.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:83628c28545a5f4d860b48fae7f62367c006ab7405898573f34af8b7dcb178a2", size = 77056, upload-time = "2026-05-05T16:31:04.798Z" }, - { url = "https://files.pythonhosted.org/packages/ab/28/818421ff2432527fdd39fcce8a5909a916d03d3f32b4eb5f3285e3faa998/librt-0.10.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4bcf57b4de07e2d4bd093636ee59dc1b64298f304148dd9c4f001f7c7897650d", size = 80372, upload-time = "2026-05-05T16:31:06.404Z" }, - { url = "https://files.pythonhosted.org/packages/19/b9/a9d6bb3e7524d285c729d6f6fa840841cadeddcf7de11073608821fd9fdb/librt-0.10.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2236c16bdb7c527eb671e4b599eec2c4229fddf80573de2bde529924f46db971", size = 243806, upload-time = "2026-05-05T16:31:07.805Z" }, - { url = "https://files.pythonhosted.org/packages/0a/1f/9ecf1003461f9004f16073975981dd1496c496823a56f3a476aff86d8825/librt-0.10.0-cp39-cp39-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:c1efa2f494811b245427095225a4d0251aee33ba4cf6ba2b7a6a9a619bc1a2ff", size = 232029, upload-time = "2026-05-05T16:31:09.338Z" }, - { url = "https://files.pythonhosted.org/packages/87/48/ed64ab6e460b853e4263c3dbcce0e016bad1ffd569f54774323604cb822e/librt-0.10.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d14626d350af79eed4b4f8886530052e3f78a62e9e53d2699f726f99c3d1d122", size = 257203, upload-time = "2026-05-05T16:31:10.9Z" }, - { url = "https://files.pythonhosted.org/packages/41/10/f632735eadc006120416a873e4a230dbfca86e7e9ed56b5d546203b0b89b/librt-0.10.0-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b609f3461beae5608ca5219131ae5cdfea2e369818030abfc6ba7086830cde42", size = 250735, upload-time = "2026-05-05T16:31:12.494Z" }, - { url = "https://files.pythonhosted.org/packages/92/cf/d9f64349396e777c1861dbe35bffed2e9b7fff88064ea5ba7e73dd6f14e3/librt-0.10.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:0e2338b67c8e72755ccd1ab77b027e3701b375a1e12b4576fdefdf9c46448274", size = 264026, upload-time = "2026-05-05T16:31:14.25Z" }, - { url = "https://files.pythonhosted.org/packages/4a/2d/56f578d74464f3912690c3532666a9b338c853c62a36fb7acdc4b0479dad/librt-0.10.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:17cadff57139ff49beea0b17e50b28dfc3f9687126399696de4d2d8ae86ba7ff", size = 259755, upload-time = "2026-05-05T16:31:15.783Z" }, - { url = "https://files.pythonhosted.org/packages/b0/10/4c544e7622034a2692aa9c492ea9a705bae5fc35435edd001336a2c09460/librt-0.10.0-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:5496102c8ed065c128d0f0fd10dcb3f9f3fd9b346954462d62af623f1b1ec7cd", size = 257624, upload-time = "2026-05-05T16:31:17.73Z" }, - { url = "https://files.pythonhosted.org/packages/2e/a9/7972d0146152adf1330b027746c6e4be9030e7a5a38b78addcfdb628bdca/librt-0.10.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:537e1bfa459c1c92a263768a8a0c6fd0558049fa6c1b866d791eea711ae64114", size = 280487, upload-time = "2026-05-05T16:31:19.591Z" }, - { url = "https://files.pythonhosted.org/packages/1b/4d/926856839d875659dfc23adb6ff295fdfca53a5b5f915319f23cb5611b73/librt-0.10.0-cp39-cp39-win32.whl", hash = "sha256:85aca5a7ddc5f2d4cba24eba35667d83893ff2980dbd5884be16f538a24351e4", size = 62623, upload-time = "2026-05-05T16:31:20.924Z" }, - { url = "https://files.pythonhosted.org/packages/7c/f3/c017fe4337e263bac6a38d2768d687c06e82886d6c131c99179063006323/librt-0.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:e45e46ff5fdfc690e77bb8557d5ba56974c4006b744ddbd70cce99fec6bfbeb8", size = 70725, upload-time = "2026-05-05T16:31:22.182Z" }, + { url = "https://files.pythonhosted.org/packages/97/14/fc943dd65268a96347472b4fbe5dcc2f6f55034516f80576cd0dd3a8930f/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6", size = 122440, upload-time = "2024-09-04T09:03:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/1e/46/e68fed66236b69dd02fcdb506218c05ac0e39745d696d22709498896875d/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17", size = 65758, upload-time = "2024-09-04T09:03:46.582Z" }, + { url = "https://files.pythonhosted.org/packages/ef/fa/65de49c85838681fc9cb05de2a68067a683717321e01ddafb5b8024286f0/kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9", size = 64311, upload-time = "2024-09-04T09:03:47.973Z" }, + { url = "https://files.pythonhosted.org/packages/42/9c/cc8d90f6ef550f65443bad5872ffa68f3dee36de4974768628bea7c14979/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9", size = 1637109, upload-time = "2024-09-04T09:03:49.281Z" }, + { url = "https://files.pythonhosted.org/packages/55/91/0a57ce324caf2ff5403edab71c508dd8f648094b18cfbb4c8cc0fde4a6ac/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c", size = 1617814, upload-time = "2024-09-04T09:03:51.444Z" }, + { url = "https://files.pythonhosted.org/packages/12/5d/c36140313f2510e20207708adf36ae4919416d697ee0236b0ddfb6fd1050/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599", size = 1400881, upload-time = "2024-09-04T09:03:53.357Z" }, + { url = "https://files.pythonhosted.org/packages/56/d0/786e524f9ed648324a466ca8df86298780ef2b29c25313d9a4f16992d3cf/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05", size = 1512972, upload-time = "2024-09-04T09:03:55.082Z" }, + { url = "https://files.pythonhosted.org/packages/67/5a/77851f2f201e6141d63c10a0708e996a1363efaf9e1609ad0441b343763b/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407", size = 1444787, upload-time = "2024-09-04T09:03:56.588Z" }, + { url = "https://files.pythonhosted.org/packages/06/5f/1f5eaab84355885e224a6fc8d73089e8713dc7e91c121f00b9a1c58a2195/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278", size = 2199212, upload-time = "2024-09-04T09:03:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/b5/28/9152a3bfe976a0ae21d445415defc9d1cd8614b2910b7614b30b27a47270/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5", size = 2346399, upload-time = "2024-09-04T09:04:00.178Z" }, + { url = "https://files.pythonhosted.org/packages/26/f6/453d1904c52ac3b400f4d5e240ac5fec25263716723e44be65f4d7149d13/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad", size = 2308688, upload-time = "2024-09-04T09:04:02.216Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9a/d4968499441b9ae187e81745e3277a8b4d7c60840a52dc9d535a7909fac3/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895", size = 2445493, upload-time = "2024-09-04T09:04:04.571Z" }, + { url = "https://files.pythonhosted.org/packages/07/c9/032267192e7828520dacb64dfdb1d74f292765f179e467c1cba97687f17d/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3", size = 2262191, upload-time = "2024-09-04T09:04:05.969Z" }, + { url = "https://files.pythonhosted.org/packages/6c/ad/db0aedb638a58b2951da46ddaeecf204be8b4f5454df020d850c7fa8dca8/kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc", size = 46644, upload-time = "2024-09-04T09:04:07.408Z" }, + { url = "https://files.pythonhosted.org/packages/12/ca/d0f7b7ffbb0be1e7c2258b53554efec1fd652921f10d7d85045aff93ab61/kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c", size = 55877, upload-time = "2024-09-04T09:04:08.869Z" }, + { url = "https://files.pythonhosted.org/packages/97/6c/cfcc128672f47a3e3c0d918ecb67830600078b025bfc32d858f2e2d5c6a4/kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a", size = 48347, upload-time = "2024-09-04T09:04:10.106Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/77429fa0a58f941d6e1c58da9efe08597d2e86bf2b2cce6626834f49d07b/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54", size = 122442, upload-time = "2024-09-04T09:04:11.432Z" }, + { url = "https://files.pythonhosted.org/packages/e5/20/8c75caed8f2462d63c7fd65e16c832b8f76cda331ac9e615e914ee80bac9/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95", size = 65762, upload-time = "2024-09-04T09:04:12.468Z" }, + { url = "https://files.pythonhosted.org/packages/f4/98/fe010f15dc7230f45bc4cf367b012d651367fd203caaa992fd1f5963560e/kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935", size = 64319, upload-time = "2024-09-04T09:04:13.635Z" }, + { url = "https://files.pythonhosted.org/packages/8b/1b/b5d618f4e58c0675654c1e5051bcf42c776703edb21c02b8c74135541f60/kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb", size = 1334260, upload-time = "2024-09-04T09:04:14.878Z" }, + { url = "https://files.pythonhosted.org/packages/b8/01/946852b13057a162a8c32c4c8d2e9ed79f0bb5d86569a40c0b5fb103e373/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02", size = 1426589, upload-time = "2024-09-04T09:04:16.514Z" }, + { url = "https://files.pythonhosted.org/packages/70/d1/c9f96df26b459e15cf8a965304e6e6f4eb291e0f7a9460b4ad97b047561e/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51", size = 1541080, upload-time = "2024-09-04T09:04:18.322Z" }, + { url = "https://files.pythonhosted.org/packages/d3/73/2686990eb8b02d05f3de759d6a23a4ee7d491e659007dd4c075fede4b5d0/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052", size = 1470049, upload-time = "2024-09-04T09:04:20.266Z" }, + { url = "https://files.pythonhosted.org/packages/a7/4b/2db7af3ed3af7c35f388d5f53c28e155cd402a55432d800c543dc6deb731/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18", size = 1426376, upload-time = "2024-09-04T09:04:22.419Z" }, + { url = "https://files.pythonhosted.org/packages/05/83/2857317d04ea46dc5d115f0df7e676997bbd968ced8e2bd6f7f19cfc8d7f/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545", size = 2222231, upload-time = "2024-09-04T09:04:24.526Z" }, + { url = "https://files.pythonhosted.org/packages/0d/b5/866f86f5897cd4ab6d25d22e403404766a123f138bd6a02ecb2cdde52c18/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b", size = 2368634, upload-time = "2024-09-04T09:04:25.899Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ee/73de8385403faba55f782a41260210528fe3273d0cddcf6d51648202d6d0/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36", size = 2329024, upload-time = "2024-09-04T09:04:28.523Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/cd101d8cd2cdfaa42dc06c433df17c8303d31129c9fdd16c0ea37672af91/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3", size = 2468484, upload-time = "2024-09-04T09:04:30.547Z" }, + { url = "https://files.pythonhosted.org/packages/e1/72/84f09d45a10bc57a40bb58b81b99d8f22b58b2040c912b7eb97ebf625bf2/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523", size = 2284078, upload-time = "2024-09-04T09:04:33.218Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d4/71828f32b956612dc36efd7be1788980cb1e66bfb3706e6dec9acad9b4f9/kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d", size = 46645, upload-time = "2024-09-04T09:04:34.371Z" }, + { url = "https://files.pythonhosted.org/packages/a1/65/d43e9a20aabcf2e798ad1aff6c143ae3a42cf506754bcb6a7ed8259c8425/kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b", size = 56022, upload-time = "2024-09-04T09:04:35.786Z" }, + { url = "https://files.pythonhosted.org/packages/35/b3/9f75a2e06f1b4ca00b2b192bc2b739334127d27f1d0625627ff8479302ba/kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376", size = 48536, upload-time = "2024-09-04T09:04:37.525Z" }, + { url = "https://files.pythonhosted.org/packages/97/9c/0a11c714cf8b6ef91001c8212c4ef207f772dd84540104952c45c1f0a249/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2", size = 121808, upload-time = "2024-09-04T09:04:38.637Z" }, + { url = "https://files.pythonhosted.org/packages/f2/d8/0fe8c5f5d35878ddd135f44f2af0e4e1d379e1c7b0716f97cdcb88d4fd27/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a", size = 65531, upload-time = "2024-09-04T09:04:39.694Z" }, + { url = "https://files.pythonhosted.org/packages/80/c5/57fa58276dfdfa612241d640a64ca2f76adc6ffcebdbd135b4ef60095098/kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee", size = 63894, upload-time = "2024-09-04T09:04:41.6Z" }, + { url = "https://files.pythonhosted.org/packages/8b/e9/26d3edd4c4ad1c5b891d8747a4f81b1b0aba9fb9721de6600a4adc09773b/kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640", size = 1369296, upload-time = "2024-09-04T09:04:42.886Z" }, + { url = "https://files.pythonhosted.org/packages/b6/67/3f4850b5e6cffb75ec40577ddf54f7b82b15269cc5097ff2e968ee32ea7d/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f", size = 1461450, upload-time = "2024-09-04T09:04:46.284Z" }, + { url = "https://files.pythonhosted.org/packages/52/be/86cbb9c9a315e98a8dc6b1d23c43cffd91d97d49318854f9c37b0e41cd68/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483", size = 1579168, upload-time = "2024-09-04T09:04:47.91Z" }, + { url = "https://files.pythonhosted.org/packages/0f/00/65061acf64bd5fd34c1f4ae53f20b43b0a017a541f242a60b135b9d1e301/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258", size = 1507308, upload-time = "2024-09-04T09:04:49.465Z" }, + { url = "https://files.pythonhosted.org/packages/21/e4/c0b6746fd2eb62fe702118b3ca0cb384ce95e1261cfada58ff693aeec08a/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e", size = 1464186, upload-time = "2024-09-04T09:04:50.949Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0f/529d0a9fffb4d514f2782c829b0b4b371f7f441d61aa55f1de1c614c4ef3/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107", size = 2247877, upload-time = "2024-09-04T09:04:52.388Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e1/66603ad779258843036d45adcbe1af0d1a889a07af4635f8b4ec7dccda35/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948", size = 2404204, upload-time = "2024-09-04T09:04:54.385Z" }, + { url = "https://files.pythonhosted.org/packages/8d/61/de5fb1ca7ad1f9ab7970e340a5b833d735df24689047de6ae71ab9d8d0e7/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038", size = 2352461, upload-time = "2024-09-04T09:04:56.307Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d2/0edc00a852e369827f7e05fd008275f550353f1f9bcd55db9363d779fc63/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383", size = 2501358, upload-time = "2024-09-04T09:04:57.922Z" }, + { url = "https://files.pythonhosted.org/packages/84/15/adc15a483506aec6986c01fb7f237c3aec4d9ed4ac10b756e98a76835933/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520", size = 2314119, upload-time = "2024-09-04T09:04:59.332Z" }, + { url = "https://files.pythonhosted.org/packages/36/08/3a5bb2c53c89660863a5aa1ee236912269f2af8762af04a2e11df851d7b2/kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b", size = 46367, upload-time = "2024-09-04T09:05:00.804Z" }, + { url = "https://files.pythonhosted.org/packages/19/93/c05f0a6d825c643779fc3c70876bff1ac221f0e31e6f701f0e9578690d70/kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb", size = 55884, upload-time = "2024-09-04T09:05:01.924Z" }, + { url = "https://files.pythonhosted.org/packages/d2/f9/3828d8f21b6de4279f0667fb50a9f5215e6fe57d5ec0d61905914f5b6099/kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a", size = 48528, upload-time = "2024-09-04T09:05:02.983Z" }, + { url = "https://files.pythonhosted.org/packages/c4/06/7da99b04259b0f18b557a4effd1b9c901a747f7fdd84cf834ccf520cb0b2/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e", size = 121913, upload-time = "2024-09-04T09:05:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/97/f5/b8a370d1aa593c17882af0a6f6755aaecd643640c0ed72dcfd2eafc388b9/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6", size = 65627, upload-time = "2024-09-04T09:05:05.119Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fc/6c0374f7503522539e2d4d1b497f5ebad3f8ed07ab51aed2af988dd0fb65/kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750", size = 63888, upload-time = "2024-09-04T09:05:06.191Z" }, + { url = "https://files.pythonhosted.org/packages/bf/3e/0b7172793d0f41cae5c923492da89a2ffcd1adf764c16159ca047463ebd3/kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d", size = 1369145, upload-time = "2024-09-04T09:05:07.919Z" }, + { url = "https://files.pythonhosted.org/packages/77/92/47d050d6f6aced2d634258123f2688fbfef8ded3c5baf2c79d94d91f1f58/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379", size = 1461448, upload-time = "2024-09-04T09:05:10.01Z" }, + { url = "https://files.pythonhosted.org/packages/9c/1b/8f80b18e20b3b294546a1adb41701e79ae21915f4175f311a90d042301cf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c", size = 1578750, upload-time = "2024-09-04T09:05:11.598Z" }, + { url = "https://files.pythonhosted.org/packages/a4/fe/fe8e72f3be0a844f257cadd72689c0848c6d5c51bc1d60429e2d14ad776e/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34", size = 1507175, upload-time = "2024-09-04T09:05:13.22Z" }, + { url = "https://files.pythonhosted.org/packages/39/fa/cdc0b6105d90eadc3bee525fecc9179e2b41e1ce0293caaf49cb631a6aaf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1", size = 1463963, upload-time = "2024-09-04T09:05:15.925Z" }, + { url = "https://files.pythonhosted.org/packages/6e/5c/0c03c4e542720c6177d4f408e56d1c8315899db72d46261a4e15b8b33a41/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f", size = 2248220, upload-time = "2024-09-04T09:05:17.434Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ee/55ef86d5a574f4e767df7da3a3a7ff4954c996e12d4fbe9c408170cd7dcc/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b", size = 2404463, upload-time = "2024-09-04T09:05:18.997Z" }, + { url = "https://files.pythonhosted.org/packages/0f/6d/73ad36170b4bff4825dc588acf4f3e6319cb97cd1fb3eb04d9faa6b6f212/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27", size = 2352842, upload-time = "2024-09-04T09:05:21.299Z" }, + { url = "https://files.pythonhosted.org/packages/0b/16/fa531ff9199d3b6473bb4d0f47416cdb08d556c03b8bc1cccf04e756b56d/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a", size = 2501635, upload-time = "2024-09-04T09:05:23.588Z" }, + { url = "https://files.pythonhosted.org/packages/78/7e/aa9422e78419db0cbe75fb86d8e72b433818f2e62e2e394992d23d23a583/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee", size = 2314556, upload-time = "2024-09-04T09:05:25.907Z" }, + { url = "https://files.pythonhosted.org/packages/a8/b2/15f7f556df0a6e5b3772a1e076a9d9f6c538ce5f05bd590eca8106508e06/kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07", size = 46364, upload-time = "2024-09-04T09:05:27.184Z" }, + { url = "https://files.pythonhosted.org/packages/0b/db/32e897e43a330eee8e4770bfd2737a9584b23e33587a0812b8e20aac38f7/kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76", size = 55887, upload-time = "2024-09-04T09:05:28.372Z" }, + { url = "https://files.pythonhosted.org/packages/c8/a4/df2bdca5270ca85fd25253049eb6708d4127be2ed0e5c2650217450b59e9/kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650", size = 48530, upload-time = "2024-09-04T09:05:30.225Z" }, + { url = "https://files.pythonhosted.org/packages/57/d6/620247574d9e26fe24384087879e8399e309f0051782f95238090afa6ccc/kiwisolver-1.4.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5d5abf8f8ec1f4e22882273c423e16cae834c36856cac348cfbfa68e01c40f3a", size = 122325, upload-time = "2024-09-04T09:05:31.648Z" }, + { url = "https://files.pythonhosted.org/packages/bd/c6/572ad7d73dbd898cffa9050ffd7ff7e78a055a1d9b7accd6b4d1f50ec858/kiwisolver-1.4.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:aeb3531b196ef6f11776c21674dba836aeea9d5bd1cf630f869e3d90b16cfade", size = 65679, upload-time = "2024-09-04T09:05:32.934Z" }, + { url = "https://files.pythonhosted.org/packages/14/a7/bb8ab10e12cc8764f4da0245d72dee4731cc720bdec0f085d5e9c6005b98/kiwisolver-1.4.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7d755065e4e866a8086c9bdada157133ff466476a2ad7861828e17b6026e22c", size = 64267, upload-time = "2024-09-04T09:05:34.11Z" }, + { url = "https://files.pythonhosted.org/packages/54/a4/3b5a2542429e182a4df0528214e76803f79d016110f5e67c414a0357cd7d/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08471d4d86cbaec61f86b217dd938a83d85e03785f51121e791a6e6689a3be95", size = 1387236, upload-time = "2024-09-04T09:05:35.97Z" }, + { url = "https://files.pythonhosted.org/packages/a6/d7/bc3005e906c1673953a3e31ee4f828157d5e07a62778d835dd937d624ea0/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bbfcb7165ce3d54a3dfbe731e470f65739c4c1f85bb1018ee912bae139e263b", size = 1500555, upload-time = "2024-09-04T09:05:37.552Z" }, + { url = "https://files.pythonhosted.org/packages/09/a7/87cb30741f13b7af08446795dca6003491755805edc9c321fe996c1320b8/kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d34eb8494bea691a1a450141ebb5385e4b69d38bb8403b5146ad279f4b30fa3", size = 1431684, upload-time = "2024-09-04T09:05:39.75Z" }, + { url = "https://files.pythonhosted.org/packages/37/a4/1e4e2d8cdaa42c73d523413498445247e615334e39401ae49dae74885429/kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9242795d174daa40105c1d86aba618e8eab7bf96ba8c3ee614da8302a9f95503", size = 1125811, upload-time = "2024-09-04T09:05:41.31Z" }, + { url = "https://files.pythonhosted.org/packages/76/36/ae40d7a3171e06f55ac77fe5536079e7be1d8be2a8210e08975c7f9b4d54/kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0f64a48bb81af7450e641e3fe0b0394d7381e342805479178b3d335d60ca7cf", size = 1179987, upload-time = "2024-09-04T09:05:42.893Z" }, + { url = "https://files.pythonhosted.org/packages/d8/5d/6e4894b9fdf836d8bd095729dff123bbbe6ad0346289287b45c800fae656/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:8e045731a5416357638d1700927529e2b8ab304811671f665b225f8bf8d8f933", size = 2186817, upload-time = "2024-09-04T09:05:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2d/603079b2c2fd62890be0b0ebfc8bb6dda8a5253ca0758885596565b0dfc1/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4322872d5772cae7369f8351da1edf255a604ea7087fe295411397d0cfd9655e", size = 2332538, upload-time = "2024-09-04T09:05:46.206Z" }, + { url = "https://files.pythonhosted.org/packages/bb/2a/9a28279c865c38a27960db38b07179143aafc94877945c209bfc553d9dd3/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:e1631290ee9271dffe3062d2634c3ecac02c83890ada077d225e081aca8aab89", size = 2293890, upload-time = "2024-09-04T09:05:47.819Z" }, + { url = "https://files.pythonhosted.org/packages/1a/4d/4da8967f3bf13c764984b8fbae330683ee5fbd555b4a5624ad2b9decc0ab/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:edcfc407e4eb17e037bca59be0e85a2031a2ac87e4fed26d3e9df88b4165f92d", size = 2434677, upload-time = "2024-09-04T09:05:49.459Z" }, + { url = "https://files.pythonhosted.org/packages/08/e9/a97a2b6b74dd850fa5974309367e025c06093a143befe9b962d0baebb4f0/kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:4d05d81ecb47d11e7f8932bd8b61b720bf0b41199358f3f5e36d38e28f0532c5", size = 2250339, upload-time = "2024-09-04T09:05:51.165Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e7/55507a387ba1766e69f5e13a79e1aefabdafe0532bee5d1972dfc42b3d16/kiwisolver-1.4.7-cp38-cp38-win32.whl", hash = "sha256:b38ac83d5f04b15e515fd86f312479d950d05ce2368d5413d46c088dda7de90a", size = 46932, upload-time = "2024-09-04T09:05:52.49Z" }, + { url = "https://files.pythonhosted.org/packages/52/77/7e04cca2ff1dc6ee6b7654cebe233de72b7a3ec5616501b6f3144fb70740/kiwisolver-1.4.7-cp38-cp38-win_amd64.whl", hash = "sha256:d83db7cde68459fc803052a55ace60bea2bae361fc3b7a6d5da07e11954e4b09", size = 55836, upload-time = "2024-09-04T09:05:54.078Z" }, + { url = "https://files.pythonhosted.org/packages/11/88/37ea0ea64512997b13d69772db8dcdc3bfca5442cda3a5e4bb943652ee3e/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd", size = 122449, upload-time = "2024-09-04T09:05:55.311Z" }, + { url = "https://files.pythonhosted.org/packages/4e/45/5a5c46078362cb3882dcacad687c503089263c017ca1241e0483857791eb/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583", size = 65757, upload-time = "2024-09-04T09:05:56.906Z" }, + { url = "https://files.pythonhosted.org/packages/8a/be/a6ae58978772f685d48dd2e84460937761c53c4bbd84e42b0336473d9775/kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417", size = 64312, upload-time = "2024-09-04T09:05:58.384Z" }, + { url = "https://files.pythonhosted.org/packages/f4/04/18ef6f452d311e1e1eb180c9bf5589187fa1f042db877e6fe443ef10099c/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904", size = 1626966, upload-time = "2024-09-04T09:05:59.855Z" }, + { url = "https://files.pythonhosted.org/packages/21/b1/40655f6c3fa11ce740e8a964fa8e4c0479c87d6a7944b95af799c7a55dfe/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a", size = 1607044, upload-time = "2024-09-04T09:06:02.16Z" }, + { url = "https://files.pythonhosted.org/packages/fd/93/af67dbcfb9b3323bbd2c2db1385a7139d8f77630e4a37bb945b57188eb2d/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8", size = 1391879, upload-time = "2024-09-04T09:06:03.908Z" }, + { url = "https://files.pythonhosted.org/packages/40/6f/d60770ef98e77b365d96061d090c0cd9e23418121c55fff188fa4bdf0b54/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2", size = 1504751, upload-time = "2024-09-04T09:06:05.58Z" }, + { url = "https://files.pythonhosted.org/packages/fa/3a/5f38667d313e983c432f3fcd86932177519ed8790c724e07d77d1de0188a/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88", size = 1436990, upload-time = "2024-09-04T09:06:08.126Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/1520301a47326e6a6043b502647e42892be33b3f051e9791cc8bb43f1a32/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde", size = 2191122, upload-time = "2024-09-04T09:06:10.345Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c4/eb52da300c166239a2233f1f9c4a1b767dfab98fae27681bfb7ea4873cb6/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c", size = 2338126, upload-time = "2024-09-04T09:06:12.321Z" }, + { url = "https://files.pythonhosted.org/packages/1a/cb/42b92fd5eadd708dd9107c089e817945500685f3437ce1fd387efebc6d6e/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2", size = 2298313, upload-time = "2024-09-04T09:06:14.562Z" }, + { url = "https://files.pythonhosted.org/packages/4f/eb/be25aa791fe5fc75a8b1e0c965e00f942496bc04635c9aae8035f6b76dcd/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb", size = 2437784, upload-time = "2024-09-04T09:06:16.767Z" }, + { url = "https://files.pythonhosted.org/packages/c5/22/30a66be7f3368d76ff95689e1c2e28d382383952964ab15330a15d8bfd03/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327", size = 2253988, upload-time = "2024-09-04T09:06:18.705Z" }, + { url = "https://files.pythonhosted.org/packages/35/d3/5f2ecb94b5211c8a04f218a76133cc8d6d153b0f9cd0b45fad79907f0689/kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644", size = 46980, upload-time = "2024-09-04T09:06:20.106Z" }, + { url = "https://files.pythonhosted.org/packages/ef/17/cd10d020578764ea91740204edc6b3236ed8106228a46f568d716b11feb2/kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4", size = 55847, upload-time = "2024-09-04T09:06:21.407Z" }, + { url = "https://files.pythonhosted.org/packages/91/84/32232502020bd78d1d12be7afde15811c64a95ed1f606c10456db4e4c3ac/kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f", size = 48494, upload-time = "2024-09-04T09:06:22.648Z" }, + { url = "https://files.pythonhosted.org/packages/ac/59/741b79775d67ab67ced9bb38552da688c0305c16e7ee24bba7a2be253fb7/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643", size = 59491, upload-time = "2024-09-04T09:06:24.188Z" }, + { url = "https://files.pythonhosted.org/packages/58/cc/fb239294c29a5656e99e3527f7369b174dd9cc7c3ef2dea7cb3c54a8737b/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706", size = 57648, upload-time = "2024-09-04T09:06:25.559Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2f009ac1f7aab9f81efb2d837301d255279d618d27b6015780115ac64bdd/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6", size = 84257, upload-time = "2024-09-04T09:06:27.038Z" }, + { url = "https://files.pythonhosted.org/packages/81/e1/c64f50987f85b68b1c52b464bb5bf73e71570c0f7782d626d1eb283ad620/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2", size = 80906, upload-time = "2024-09-04T09:06:28.48Z" }, + { url = "https://files.pythonhosted.org/packages/fd/71/1687c5c0a0be2cee39a5c9c389e546f9c6e215e46b691d00d9f646892083/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4", size = 79951, upload-time = "2024-09-04T09:06:29.966Z" }, + { url = "https://files.pythonhosted.org/packages/ea/8b/d7497df4a1cae9367adf21665dd1f896c2a7aeb8769ad77b662c5e2bcce7/kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a", size = 55715, upload-time = "2024-09-04T09:06:31.489Z" }, + { url = "https://files.pythonhosted.org/packages/64/f3/2403d90821fffe496df16f6996cb328b90b0d80c06d2938a930a7732b4f1/kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bfa1acfa0c54932d5607e19a2c24646fb4c1ae2694437789129cf099789a3b00", size = 59662, upload-time = "2024-09-04T09:06:33.551Z" }, + { url = "https://files.pythonhosted.org/packages/fa/7d/8f409736a4a6ac04354fa530ebf46682ddb1539b0bae15f4731ff2c575bc/kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:eee3ea935c3d227d49b4eb85660ff631556841f6e567f0f7bda972df6c2c9935", size = 57753, upload-time = "2024-09-04T09:06:35.095Z" }, + { url = "https://files.pythonhosted.org/packages/4c/a5/3937c9abe8eedb1356071739ad437a0b486cbad27d54f4ec4733d24882ac/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f3160309af4396e0ed04db259c3ccbfdc3621b5559b5453075e5de555e1f3a1b", size = 103564, upload-time = "2024-09-04T09:06:36.756Z" }, + { url = "https://files.pythonhosted.org/packages/b2/18/a5ae23888f010b90d5eb8d196fed30e268056b2ded54d25b38a193bb70e9/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a17f6a29cf8935e587cc8a4dbfc8368c55edc645283db0ce9801016f83526c2d", size = 95264, upload-time = "2024-09-04T09:06:38.786Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d0/c4240ae86306d4395e9701f1d7e6ddcc6d60c28cb0127139176cfcfc9ebe/kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10849fb2c1ecbfae45a693c070e0320a91b35dd4bcf58172c023b994283a124d", size = 78197, upload-time = "2024-09-04T09:06:40.453Z" }, + { url = "https://files.pythonhosted.org/packages/62/db/62423f0ab66813376a35c1e7da488ebdb4e808fcb54b7cec33959717bda1/kiwisolver-1.4.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ac542bf38a8a4be2dc6b15248d36315ccc65f0743f7b1a76688ffb6b5129a5c2", size = 56080, upload-time = "2024-09-04T09:06:42.061Z" }, + { url = "https://files.pythonhosted.org/packages/d5/df/ce37d9b26f07ab90880923c94d12a6ff4d27447096b4c849bfc4339ccfdf/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39", size = 58666, upload-time = "2024-09-04T09:06:43.756Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d3/e4b04f43bc629ac8e186b77b2b1a251cdfa5b7610fa189dc0db622672ce6/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e", size = 57088, upload-time = "2024-09-04T09:06:45.406Z" }, + { url = "https://files.pythonhosted.org/packages/30/1c/752df58e2d339e670a535514d2db4fe8c842ce459776b8080fbe08ebb98e/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608", size = 84321, upload-time = "2024-09-04T09:06:47.557Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f8/fe6484e847bc6e238ec9f9828089fb2c0bb53f2f5f3a79351fde5b565e4f/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674", size = 80776, upload-time = "2024-09-04T09:06:49.235Z" }, + { url = "https://files.pythonhosted.org/packages/9b/57/d7163c0379f250ef763aba85330a19feefb5ce6cb541ade853aaba881524/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225", size = 79984, upload-time = "2024-09-04T09:06:51.336Z" }, + { url = "https://files.pythonhosted.org/packages/8c/95/4a103776c265d13b3d2cd24fb0494d4e04ea435a8ef97e1b2c026d43250b/kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0", size = 55811, upload-time = "2024-09-04T09:06:53.078Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +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/ac/f8/06549565caa026e540b7e7bab5c5a90eb7ca986015f4c48dace243cd24d9/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:32cc0a5365239a6ea0c6ed461e8838d053b57e397443c0ca894dcc8e388d4374", size = 122802, upload-time = "2026-03-09T13:12:37.515Z" }, + { url = "https://files.pythonhosted.org/packages/84/eb/8476a0818850c563ff343ea7c9c05dcdcbd689a38e01aa31657df01f91fa/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cc0b66c1eec9021353a4b4483afb12dfd50e3669ffbb9152d6842eb34c7e29fd", size = 66216, upload-time = "2026-03-09T13:12:38.812Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c4/f9c8a6b4c21aed4198566e45923512986d6cef530e7263b3a5f823546561/kiwisolver-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:86e0287879f75621ae85197b0877ed2f8b7aa57b511c7331dce2eb6f4de7d476", size = 63917, upload-time = "2026-03-09T13:12:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/f1/0e/ba4ae25d03722f64de8b2c13e80d82ab537a06b30fc7065183c6439357e3/kiwisolver-1.5.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:62f59da443c4f4849f73a51a193b1d9d258dcad0c41bc4d1b8fb2bcc04bfeb22", size = 1628776, upload-time = "2026-03-09T13:12:41.976Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e4/3f43a011bc8a0860d1c96f84d32fa87439d3feedf66e672fef03bf5e8bac/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9190426b7aa26c5229501fa297b8d0653cfd3f5a36f7990c264e157cbf886b3b", size = 1228164, upload-time = "2026-03-09T13:12:44.002Z" }, + { url = "https://files.pythonhosted.org/packages/4b/34/3a901559a1e0c218404f9a61a93be82d45cb8f44453ba43088644980f033/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c8277104ded0a51e699c8c3aff63ce2c56d4ed5519a5f73e0fd7057f959a2b9e", size = 1246656, upload-time = "2026-03-09T13:12:45.557Z" }, + { url = "https://files.pythonhosted.org/packages/87/9e/f78c466ea20527822b95ad38f141f2de1dcd7f23fb8716b002b0d91bbe59/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8f9baf6f0a6e7571c45c8863010b45e837c3ee1c2c77fcd6ef423be91b21fedb", size = 1295562, upload-time = "2026-03-09T13:12:47.562Z" }, + { url = "https://files.pythonhosted.org/packages/0a/66/fd0e4a612e3a286c24e6d6f3a5428d11258ed1909bc530ba3b59807fd980/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cff8e5383db4989311f99e814feeb90c4723eb4edca425b9d5d9c3fefcdd9537", size = 2178473, upload-time = "2026-03-09T13:12:50.254Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8e/6cac929e0049539e5ee25c1ee937556f379ba5204840d03008363ced662d/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ebae99ed6764f2b5771c522477b311be313e8841d2e0376db2b10922daebbba4", size = 2274035, upload-time = "2026-03-09T13:12:51.785Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d3/9d0c18f1b52ea8074b792452cf17f1f5a56bd0302a85191f405cfbf9da16/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:d5cd5189fc2b6a538b75ae45433140c4823463918f7b1617c31e68b085c0022c", size = 2443217, upload-time = "2026-03-09T13:12:53.329Z" }, + { url = "https://files.pythonhosted.org/packages/45/2a/6e19368803a038b2a90857bf4ee9e3c7b667216d045866bf22d3439fd75e/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f42c23db5d1521218a3276bb08666dcb662896a0be7347cba864eca45ff64ede", size = 2249196, upload-time = "2026-03-09T13:12:55.057Z" }, + { url = "https://files.pythonhosted.org/packages/75/2b/3f641dfcbe72e222175d626bacf2f72c3b34312afec949dd1c50afa400f5/kiwisolver-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:94eff26096eb5395136634622515b234ecb6c9979824c1f5004c6e3c3c85ccd2", size = 73389, upload-time = "2026-03-09T13:12:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/da/88/299b137b9e0025d8982e03d2d52c123b0a2b159e84b0ef1501ef446339cf/kiwisolver-1.5.0-cp310-cp310-win_arm64.whl", hash = "sha256:dd952e03bfbb096cfe2dd35cd9e00f269969b67536cb4370994afc20ff2d0875", size = 64782, upload-time = "2026-03-09T13:12:57.609Z" }, + { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, + { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, + { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { 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" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, + { url = "https://files.pythonhosted.org/packages/17/6f/6fd4f690a40c2582fa34b97d2678f718acf3706b91d270c65ecb455d0a06/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:295d9ffe712caa9f8a3081de8d32fc60191b4b51c76f02f951fd8407253528f4", size = 59606, upload-time = "2026-03-09T13:15:40.81Z" }, + { url = "https://files.pythonhosted.org/packages/82/a0/2355d5e3b338f13ce63f361abb181e3b6ea5fffdb73f739b3e80efa76159/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:51e8c4084897de9f05898c2c2a39af6318044ae969d46ff7a34ed3f96274adca", size = 57537, upload-time = "2026-03-09T13:15:42.071Z" }, + { url = "https://files.pythonhosted.org/packages/c8/b9/1d50e610ecadebe205b71d6728fd224ce0e0ca6aba7b9cbe1da049203ac5/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b83af57bdddef03c01a9138034c6ff03181a3028d9a1003b301eb1a55e161a3f", size = 79888, upload-time = "2026-03-09T13:15:43.317Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ee/b85ffcd75afed0357d74f0e6fc02a4507da441165de1ca4760b9f496390d/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf4679a3d71012a7c2bf360e5cd878fbd5e4fcac0896b56393dec239d81529ed", size = 77584, upload-time = "2026-03-09T13:15:44.605Z" }, + { url = "https://files.pythonhosted.org/packages/6b/dd/644d0dde6010a8583b4cd66dd41c5f83f5325464d15c4f490b3340ab73b4/kiwisolver-1.5.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:41024ed50e44ab1a60d3fe0a9d15a4ccc9f5f2b1d814ff283c8d01134d5b81bc", size = 73390, upload-time = "2026-03-09T13:15:45.832Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, + { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, +] + +[[package]] +name = "license-expression" +version = "30.3.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +dependencies = [ + { name = "boolean-py", marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/57/8b/dbe230196eee2de208ba87dcfae69c46db9d7ed70e2f30f143bf994ee075/license_expression-30.3.1.tar.gz", hash = "sha256:60d5bec1f3364c256a92b9a08583d7ea933c7aa272c8d36d04144a89a3858c01", size = 174601, upload-time = "2024-08-13T05:29:16.449Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/84/a7cf5dfa141501a20cb63595f02edfe38e0db2e3cc34e4f3cd273cc285df/license_expression-30.3.1-py3-none-any.whl", hash = "sha256:97904b9185c7bbb1e98799606fa7424191c375e70ba63a524b6f7100e42ddc46", size = 109008, upload-time = "2024-08-13T05:29:14.682Z" }, +] + +[[package]] +name = "license-expression" +version = "30.4.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "boolean-py", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/71/d89bb0e71b1415453980fd32315f2a037aad9f7f70f695c7cec7035feb13/license_expression-30.4.4.tar.gz", hash = "sha256:73448f0aacd8d0808895bdc4b2c8e01a8d67646e4188f887375398c761f340fd", size = 186402, upload-time = "2025-07-22T11:13:32.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/40/791891d4c0c4dab4c5e187c17261cedc26285fd41541577f900470a45a4d/license_expression-30.4.4-py3-none-any.whl", hash = "sha256:421788fdcadb41f049d2dc934ce666626265aeccefddd25e162a26f23bcbf8a4", size = 120615, upload-time = "2025-07-22T11:13:31.217Z" }, ] [[package]] @@ -786,12 +1552,282 @@ wheels = [ ] [[package]] -name = "mccabe" -version = "0.7.0" +name = "matplotlib" +version = "3.7.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e7/ff/0ffefdcac38932a54d2b5eed4e0ba8a408f215002cd178ad1df0f2806ff8/mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325", size = 9658, upload-time = "2022-01-24T01:14:51.113Z" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +dependencies = [ + { name = "contourpy", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "cycler", marker = "python_full_version < '3.9'" }, + { name = "fonttools", version = "4.57.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "importlib-resources", version = "6.4.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "kiwisolver", version = "1.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "numpy", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "packaging", marker = "python_full_version < '3.9'" }, + { name = "pillow", version = "10.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "pyparsing", version = "3.1.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "python-dateutil", marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b6/f0/3836719cc3982fbba3b840d18a59db1d0ee9ac7986f24e8c0a092851b67b/matplotlib-3.7.5.tar.gz", hash = "sha256:1e5c971558ebc811aa07f54c7b7c677d78aa518ef4c390e14673a09e0860184a", size = 38098611, upload-time = "2024-02-16T10:50:56.19Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/27/1a/1f68f9ba0c207934b35b86a8ca3aad8395a3d6dd7921c0686e23853ff5a9/mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e", size = 7350, upload-time = "2022-01-24T01:14:49.62Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b0/3808e86c41e5d97822d77e89d7f3cb0890725845c050d87ec53732a8b150/matplotlib-3.7.5-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:4a87b69cb1cb20943010f63feb0b2901c17a3b435f75349fd9865713bfa63925", size = 8322924, upload-time = "2024-02-16T10:48:06.184Z" }, + { url = "https://files.pythonhosted.org/packages/5b/05/726623be56391ba1740331ad9f1cd30e1adec61c179ddac134957a6dc2e7/matplotlib-3.7.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d3ce45010fefb028359accebb852ca0c21bd77ec0f281952831d235228f15810", size = 7438436, upload-time = "2024-02-16T10:48:10.294Z" }, + { url = "https://files.pythonhosted.org/packages/15/83/89cdef49ef1e320060ec951ba33c132df211561d866c3ed144c81fd110b2/matplotlib-3.7.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fbea1e762b28400393d71be1a02144aa16692a3c4c676ba0178ce83fc2928fdd", size = 7341849, upload-time = "2024-02-16T10:48:13.249Z" }, + { url = "https://files.pythonhosted.org/packages/94/29/39fc4acdc296dd86e09cecb65c14966e1cf18e0f091b9cbd9bd3f0c19ee4/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec0e1adc0ad70ba8227e957551e25a9d2995e319c29f94a97575bb90fa1d4469", size = 11354141, upload-time = "2024-02-16T10:48:16.963Z" }, + { url = "https://files.pythonhosted.org/packages/54/36/44c5eeb0d83ae1e3ed34d264d7adee947c4fd56c4a9464ce822de094995a/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6738c89a635ced486c8a20e20111d33f6398a9cbebce1ced59c211e12cd61455", size = 11457668, upload-time = "2024-02-16T10:48:21.339Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e2/f68aeaedf0ef57cbb793637ee82e62e64ea26cee908db0fe4f8e24d502c0/matplotlib-3.7.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1210b7919b4ed94b5573870f316bca26de3e3b07ffdb563e79327dc0e6bba515", size = 11580088, upload-time = "2024-02-16T10:48:25.415Z" }, + { url = "https://files.pythonhosted.org/packages/d9/f7/7c88d34afc38943aa5e4e04d27fc9da5289a48c264c0d794f60c9cda0949/matplotlib-3.7.5-cp310-cp310-win32.whl", hash = "sha256:068ebcc59c072781d9dcdb82f0d3f1458271c2de7ca9c78f5bd672141091e9e1", size = 7339332, upload-time = "2024-02-16T10:48:29.319Z" }, + { url = "https://files.pythonhosted.org/packages/91/99/e5f6f7c9438279581c4a2308d264fe24dc98bb80e3b2719f797227e54ddc/matplotlib-3.7.5-cp310-cp310-win_amd64.whl", hash = "sha256:f098ffbaab9df1e3ef04e5a5586a1e6b1791380698e84938d8640961c79b1fc0", size = 7506405, upload-time = "2024-02-16T10:48:32.499Z" }, + { url = "https://files.pythonhosted.org/packages/5e/c6/45d0485e59d70b7a6a81eade5d0aed548b42cc65658c0ce0f813b9249165/matplotlib-3.7.5-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:f65342c147572673f02a4abec2d5a23ad9c3898167df9b47c149f32ce61ca078", size = 8325506, upload-time = "2024-02-16T10:48:36.192Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0a/83bd8589f3597745f624fbcc7da1140088b2f4160ca51c71553c561d0df5/matplotlib-3.7.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4ddf7fc0e0dc553891a117aa083039088d8a07686d4c93fb8a810adca68810af", size = 7439905, upload-time = "2024-02-16T10:48:38.951Z" }, + { url = "https://files.pythonhosted.org/packages/84/c1/a7705b24f8f9b4d7ceea0002c13bae50cf9423f299f56d8c47a5cd2627d2/matplotlib-3.7.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0ccb830fc29442360d91be48527809f23a5dcaee8da5f4d9b2d5b867c1b087b8", size = 7342895, upload-time = "2024-02-16T10:48:41.61Z" }, + { url = "https://files.pythonhosted.org/packages/94/6e/55d7d8310c96a7459c883aa4be3f5a9338a108278484cbd5c95d480d1cef/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efc6bb28178e844d1f408dd4d6341ee8a2e906fc9e0fa3dae497da4e0cab775d", size = 11358830, upload-time = "2024-02-16T10:48:44.984Z" }, + { url = "https://files.pythonhosted.org/packages/55/57/3b36afe104216db1cf2f3889c394b403ea87eda77c4815227c9524462ba8/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b15c4c2d374f249f324f46e883340d494c01768dd5287f8bc00b65b625ab56c", size = 11462575, upload-time = "2024-02-16T10:48:48.437Z" }, + { url = "https://files.pythonhosted.org/packages/f3/0b/fabcf5f66b12fab5c4110d06a6c0fed875c7e63bc446403f58f9dadc9999/matplotlib-3.7.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d028555421912307845e59e3de328260b26d055c5dac9b182cc9783854e98fb", size = 11584280, upload-time = "2024-02-16T10:48:53.022Z" }, + { url = "https://files.pythonhosted.org/packages/47/a9/1ad7df27a9da70b62109584632f83fe6ef45774701199c44d5777107c240/matplotlib-3.7.5-cp311-cp311-win32.whl", hash = "sha256:fe184b4625b4052fa88ef350b815559dd90cc6cc8e97b62f966e1ca84074aafa", size = 7340429, upload-time = "2024-02-16T10:48:56.505Z" }, + { url = "https://files.pythonhosted.org/packages/e3/b1/1b6c34b89173d6c206dc5a4028e8518b4dfee3569c13bdc0c88d0486cae7/matplotlib-3.7.5-cp311-cp311-win_amd64.whl", hash = "sha256:084f1f0f2f1010868c6f1f50b4e1c6f2fb201c58475494f1e5b66fed66093647", size = 7507112, upload-time = "2024-02-16T10:48:59.659Z" }, + { url = "https://files.pythonhosted.org/packages/75/dc/4e341a3ef36f3e7321aec0741317f12c7a23264be708a97972bf018c34af/matplotlib-3.7.5-cp312-cp312-macosx_10_12_universal2.whl", hash = "sha256:34bceb9d8ddb142055ff27cd7135f539f2f01be2ce0bafbace4117abe58f8fe4", size = 8323797, upload-time = "2024-02-16T10:49:02.872Z" }, + { url = "https://files.pythonhosted.org/packages/af/83/bbb482d678362ceb68cc59ec4fc705dde636025969361dac77be868541ef/matplotlib-3.7.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c5a2134162273eb8cdfd320ae907bf84d171de948e62180fa372a3ca7cf0f433", size = 7439549, upload-time = "2024-02-16T10:49:05.743Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ee/e49a92d9e369b2b9e4373894171cb4e641771cd7f81bde1d8b6fb8c60842/matplotlib-3.7.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:039ad54683a814002ff37bf7981aa1faa40b91f4ff84149beb53d1eb64617980", size = 7341788, upload-time = "2024-02-16T10:49:09.143Z" }, + { url = "https://files.pythonhosted.org/packages/48/79/89cb2fc5ddcfc3d440a739df04dbe6e4e72b1153d1ebd32b45d42eb71d27/matplotlib-3.7.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d742ccd1b09e863b4ca58291728db645b51dab343eebb08d5d4b31b308296ce", size = 11356329, upload-time = "2024-02-16T10:49:12.156Z" }, + { url = "https://files.pythonhosted.org/packages/ff/25/84f181cdae5c9eba6fd1c2c35642aec47233425fe3b0d6fccdb323fb36e0/matplotlib-3.7.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:743b1c488ca6a2bc7f56079d282e44d236bf375968bfd1b7ba701fd4d0fa32d6", size = 11577813, upload-time = "2024-02-16T10:49:15.986Z" }, + { url = "https://files.pythonhosted.org/packages/9f/24/b2db065d40e58033b3350222fb8bbb0ffcb834029df9c1f9349dd9c7dd45/matplotlib-3.7.5-cp312-cp312-win_amd64.whl", hash = "sha256:fbf730fca3e1f23713bc1fae0a57db386e39dc81ea57dc305c67f628c1d7a342", size = 7507667, upload-time = "2024-02-16T10:49:19.6Z" }, + { url = "https://files.pythonhosted.org/packages/e3/72/50a38c8fd5dc845b06f8e71c9da802db44b81baabf4af8be78bb8a5622ea/matplotlib-3.7.5-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:cfff9b838531698ee40e40ea1a8a9dc2c01edb400b27d38de6ba44c1f9a8e3d2", size = 8322659, upload-time = "2024-02-16T10:49:23.206Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ea/129163dcd21db6da5d559a8160c4a74c1dc5f96ac246a3d4248b43c7648d/matplotlib-3.7.5-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:1dbcca4508bca7847fe2d64a05b237a3dcaec1f959aedb756d5b1c67b770c5ee", size = 7438408, upload-time = "2024-02-16T10:49:27.462Z" }, + { url = "https://files.pythonhosted.org/packages/aa/59/4d13e5b6298b1ca5525eea8c68d3806ae93ab6d0bb17ca9846aa3156b92b/matplotlib-3.7.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4cdf4ef46c2a1609a50411b66940b31778db1e4b73d4ecc2eaa40bd588979b13", size = 7341782, upload-time = "2024-02-16T10:49:32.173Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c4/f562df04b08487731743511ff274ae5d31dce2ff3e5621f8b070d20ab54a/matplotlib-3.7.5-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:167200ccfefd1674b60e957186dfd9baf58b324562ad1a28e5d0a6b3bea77905", size = 9196487, upload-time = "2024-02-16T10:49:37.971Z" }, + { url = "https://files.pythonhosted.org/packages/30/33/cc27211d2ffeee4fd7402dca137b6e8a83f6dcae3d4be8d0ad5068555561/matplotlib-3.7.5-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:53e64522934df6e1818b25fd48cf3b645b11740d78e6ef765fbb5fa5ce080d02", size = 9213051, upload-time = "2024-02-16T10:49:43.916Z" }, + { url = "https://files.pythonhosted.org/packages/9b/9d/8bd37c86b79312c9dbcfa379dec32303f9b38e8456e0829d7e666a0e0a05/matplotlib-3.7.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3e3bc79b2d7d615067bd010caff9243ead1fc95cf735c16e4b2583173f717eb", size = 11370807, upload-time = "2024-02-16T10:49:47.701Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1e/b24a07a849c8d458f1b3724f49029f0dedf748bdedb4d5f69491314838b6/matplotlib-3.7.5-cp38-cp38-win32.whl", hash = "sha256:6b641b48c6819726ed47c55835cdd330e53747d4efff574109fd79b2d8a13748", size = 7340461, upload-time = "2024-02-16T10:49:51.597Z" }, + { url = "https://files.pythonhosted.org/packages/16/51/58b0b9de42fe1e665736d9286f88b5f1556a0e22bed8a71f468231761083/matplotlib-3.7.5-cp38-cp38-win_amd64.whl", hash = "sha256:f0b60993ed3488b4532ec6b697059897891927cbfc2b8d458a891b60ec03d9d7", size = 7507471, upload-time = "2024-02-16T10:49:54.353Z" }, + { url = "https://files.pythonhosted.org/packages/0d/00/17487e9e8949ca623af87f6c8767408efe7530b7e1f4d6897fa7fa940834/matplotlib-3.7.5-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:090964d0afaff9c90e4d8de7836757e72ecfb252fb02884016d809239f715651", size = 8323175, upload-time = "2024-02-16T10:49:57.743Z" }, + { url = "https://files.pythonhosted.org/packages/6a/84/be0acd521fa9d6697657cf35878153f8009a42b4b75237aebc302559a8a9/matplotlib-3.7.5-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:9fc6fcfbc55cd719bc0bfa60bde248eb68cf43876d4c22864603bdd23962ba25", size = 7438737, upload-time = "2024-02-16T10:50:00.683Z" }, + { url = "https://files.pythonhosted.org/packages/17/39/175f36a6d68d0cf47a4fecbae9728048355df23c9feca8688f1476b198e6/matplotlib-3.7.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5e7cc3078b019bb863752b8b60e8b269423000f1603cb2299608231996bd9d54", size = 7341916, upload-time = "2024-02-16T10:50:05.04Z" }, + { url = "https://files.pythonhosted.org/packages/36/c0/9a1c2a79f85c15d41b60877cbc333694ed80605e5c97a33880c4ecfd5bf1/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e4e9a868e8163abaaa8259842d85f949a919e1ead17644fb77a60427c90473c", size = 11352264, upload-time = "2024-02-16T10:50:08.955Z" }, + { url = "https://files.pythonhosted.org/packages/a6/39/b0204e0e7a899b0676733366a55ccafa723799b719bc7f2e85e5ecde26a0/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fa7ebc995a7d747dacf0a717d0eb3aa0f0c6a0e9ea88b0194d3a3cd241a1500f", size = 11454722, upload-time = "2024-02-16T10:50:13.231Z" }, + { url = "https://files.pythonhosted.org/packages/d8/39/64dd1d36c79e72e614977db338d180cf204cf658927c05a8ef2d47feb4c0/matplotlib-3.7.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3785bfd83b05fc0e0c2ae4c4a90034fe693ef96c679634756c50fe6efcc09856", size = 11576343, upload-time = "2024-02-16T10:50:17.626Z" }, + { url = "https://files.pythonhosted.org/packages/31/b4/e77bc11394d858bdf15e356980fceb4ac9604b0fa8212ef3ca4f1dc166b8/matplotlib-3.7.5-cp39-cp39-win32.whl", hash = "sha256:29b058738c104d0ca8806395f1c9089dfe4d4f0f78ea765c6c704469f3fffc81", size = 7340455, upload-time = "2024-02-16T10:50:21.448Z" }, + { url = "https://files.pythonhosted.org/packages/4a/84/081820c596b9555ecffc6819ee71f847f2fbb0d7c70a42c1eeaa54edf3e0/matplotlib-3.7.5-cp39-cp39-win_amd64.whl", hash = "sha256:fd4028d570fa4b31b7b165d4a685942ae9cdc669f33741e388c01857d9723eab", size = 7507711, upload-time = "2024-02-16T10:50:24.387Z" }, + { url = "https://files.pythonhosted.org/packages/27/6c/1bb10f3d6f337b9faa2e96a251bd87ba5fed85a608df95eb4d69acc109f0/matplotlib-3.7.5-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2a9a3f4d6a7f88a62a6a18c7e6a84aedcaf4faf0708b4ca46d87b19f1b526f88", size = 7397285, upload-time = "2024-02-16T10:50:27.375Z" }, + { url = "https://files.pythonhosted.org/packages/b2/36/66cfea213e9ba91cda9e257542c249ed235d49021af71c2e8007107d7d4c/matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9b3fd853d4a7f008a938df909b96db0b454225f935d3917520305b90680579c", size = 7552612, upload-time = "2024-02-16T10:50:30.65Z" }, + { url = "https://files.pythonhosted.org/packages/77/df/16655199bf984c37c6a816b854bc032b56aef521aadc04f27928422f3c91/matplotlib-3.7.5-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0ad550da9f160737d7890217c5eeed4337d07e83ca1b2ca6535078f354e7675", size = 7515564, upload-time = "2024-02-16T10:50:33.589Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c8/3534c3705a677b71abb6be33609ba129fdeae2ea4e76b2fd3ab62c86fab3/matplotlib-3.7.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:20da7924a08306a861b3f2d1da0d1aa9a6678e480cf8eacffe18b565af2813e7", size = 7521336, upload-time = "2024-02-16T10:50:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/20/a0/c5c0d410798b387ed3a177a5a7eba21055dd9c41d4b15bd0861241a5a60e/matplotlib-3.7.5-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b45c9798ea6bb920cb77eb7306409756a7fab9db9b463e462618e0559aecb30e", size = 7397931, upload-time = "2024-02-16T10:50:39.477Z" }, + { url = "https://files.pythonhosted.org/packages/c3/2f/9e9509727d4c7d1b8e2c88e9330a97d54a1dd20bd316a0c8d2f8b38c4513/matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a99866267da1e561c7776fe12bf4442174b79aac1a47bd7e627c7e4d077ebd83", size = 7553224, upload-time = "2024-02-16T10:50:42.82Z" }, + { url = "https://files.pythonhosted.org/packages/89/0c/5f3e403dcf5c23799c92b0139dd00e41caf23983e9281f5bfeba3065e7d2/matplotlib-3.7.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b6aa62adb6c268fc87d80f963aca39c64615c31830b02697743c95590ce3fbb", size = 7513250, upload-time = "2024-02-16T10:50:46.504Z" }, + { url = "https://files.pythonhosted.org/packages/87/e0/03eba0a8c3775ef910dbb3a287114a64c47abbcaeab2543c59957f155a86/matplotlib-3.7.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e530ab6a0afd082d2e9c17eb1eb064a63c5b09bb607b2b74fa41adbe3e162286", size = 7521729, upload-time = "2024-02-16T10:50:50.063Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.9.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "contourpy", version = "1.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "cycler", marker = "python_full_version == '3.9.*'" }, + { name = "fonttools", version = "4.60.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "importlib-resources", version = "6.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "kiwisolver", version = "1.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "packaging", marker = "python_full_version == '3.9.*'" }, + { name = "pillow", version = "11.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pyparsing", version = "3.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "python-dateutil", marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/17/1747b4154034befd0ed33b52538f5eb7752d05bb51c5e2a31470c3bc7d52/matplotlib-3.9.4.tar.gz", hash = "sha256:1e00e8be7393cbdc6fedfa8a6fba02cf3e83814b285db1c60b906a023ba41bc3", size = 36106529, upload-time = "2024-12-13T05:56:34.184Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/94/27d2e2c30d54b56c7b764acc1874a909e34d1965a427fc7092bb6a588b63/matplotlib-3.9.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fdd7abfb706dfa8d307af64a87f1a862879ec3cd8d0ec8637458f0885b9c50", size = 7885089, upload-time = "2024-12-13T05:54:24.224Z" }, + { url = "https://files.pythonhosted.org/packages/c6/25/828273307e40a68eb8e9df832b6b2aaad075864fdc1de4b1b81e40b09e48/matplotlib-3.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d89bc4e85e40a71d1477780366c27fb7c6494d293e1617788986f74e2a03d7ff", size = 7770600, upload-time = "2024-12-13T05:54:27.214Z" }, + { url = "https://files.pythonhosted.org/packages/f2/65/f841a422ec994da5123368d76b126acf4fc02ea7459b6e37c4891b555b83/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ddf9f3c26aae695c5daafbf6b94e4c1a30d6cd617ba594bbbded3b33a1fcfa26", size = 8200138, upload-time = "2024-12-13T05:54:29.497Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/272aca07a38804d93b6050813de41ca7ab0e29ba7a9dd098e12037c919a9/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18ebcf248030173b59a868fda1fe42397253f6698995b55e81e1f57431d85e50", size = 8312711, upload-time = "2024-12-13T05:54:34.396Z" }, + { url = "https://files.pythonhosted.org/packages/98/37/f13e23b233c526b7e27ad61be0a771894a079e0f7494a10d8d81557e0e9a/matplotlib-3.9.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974896ec43c672ec23f3f8c648981e8bc880ee163146e0312a9b8def2fac66f5", size = 9090622, upload-time = "2024-12-13T05:54:36.808Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8c/b1f5bd2bd70e60f93b1b54c4d5ba7a992312021d0ddddf572f9a1a6d9348/matplotlib-3.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:4598c394ae9711cec135639374e70871fa36b56afae17bdf032a345be552a88d", size = 7828211, upload-time = "2024-12-13T05:54:40.596Z" }, + { url = "https://files.pythonhosted.org/packages/74/4b/65be7959a8fa118a3929b49a842de5b78bb55475236fcf64f3e308ff74a0/matplotlib-3.9.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d4dd29641d9fb8bc4492420c5480398dd40a09afd73aebe4eb9d0071a05fbe0c", size = 7894430, upload-time = "2024-12-13T05:54:44.049Z" }, + { url = "https://files.pythonhosted.org/packages/e9/18/80f70d91896e0a517b4a051c3fd540daa131630fd75e02e250365353b253/matplotlib-3.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30e5b22e8bcfb95442bf7d48b0d7f3bdf4a450cbf68986ea45fca3d11ae9d099", size = 7780045, upload-time = "2024-12-13T05:54:46.414Z" }, + { url = "https://files.pythonhosted.org/packages/a2/73/ccb381026e3238c5c25c3609ba4157b2d1a617ec98d65a8b4ee4e1e74d02/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bb0030d1d447fd56dcc23b4c64a26e44e898f0416276cac1ebc25522e0ac249", size = 8209906, upload-time = "2024-12-13T05:54:49.459Z" }, + { url = "https://files.pythonhosted.org/packages/ab/33/1648da77b74741c89f5ea95cbf42a291b4b364f2660b316318811404ed97/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aca90ed222ac3565d2752b83dbb27627480d27662671e4d39da72e97f657a423", size = 8322873, upload-time = "2024-12-13T05:54:53.066Z" }, + { url = "https://files.pythonhosted.org/packages/57/d3/8447ba78bc6593c9044c372d1609f8ea10fb1e071e7a9e0747bea74fc16c/matplotlib-3.9.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a181b2aa2906c608fcae72f977a4a2d76e385578939891b91c2550c39ecf361e", size = 9099566, upload-time = "2024-12-13T05:54:55.522Z" }, + { url = "https://files.pythonhosted.org/packages/23/e1/4f0e237bf349c02ff9d1b6e7109f1a17f745263809b9714a8576dc17752b/matplotlib-3.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:1f6882828231eca17f501c4dcd98a05abb3f03d157fbc0769c6911fe08b6cfd3", size = 7838065, upload-time = "2024-12-13T05:54:58.337Z" }, + { url = "https://files.pythonhosted.org/packages/1a/2b/c918bf6c19d6445d1cefe3d2e42cb740fb997e14ab19d4daeb6a7ab8a157/matplotlib-3.9.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:dfc48d67e6661378a21c2983200a654b72b5c5cdbd5d2cf6e5e1ece860f0cc70", size = 7891131, upload-time = "2024-12-13T05:55:02.837Z" }, + { url = "https://files.pythonhosted.org/packages/c1/e5/b4e8fc601ca302afeeabf45f30e706a445c7979a180e3a978b78b2b681a4/matplotlib-3.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:47aef0fab8332d02d68e786eba8113ffd6f862182ea2999379dec9e237b7e483", size = 7776365, upload-time = "2024-12-13T05:55:05.158Z" }, + { url = "https://files.pythonhosted.org/packages/99/06/b991886c506506476e5d83625c5970c656a491b9f80161458fed94597808/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fba1f52c6b7dc764097f52fd9ab627b90db452c9feb653a59945de16752e965f", size = 8200707, upload-time = "2024-12-13T05:55:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/c3/e2/556b627498cb27e61026f2d1ba86a78ad1b836fef0996bef5440e8bc9559/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:173ac3748acaac21afcc3fa1633924609ba1b87749006bc25051c52c422a5d00", size = 8313761, upload-time = "2024-12-13T05:55:12.95Z" }, + { url = "https://files.pythonhosted.org/packages/58/ff/165af33ec766ff818306ea88e91f9f60d2a6ed543be1eb122a98acbf3b0d/matplotlib-3.9.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320edea0cadc07007765e33f878b13b3738ffa9745c5f707705692df70ffe0e0", size = 9095284, upload-time = "2024-12-13T05:55:16.199Z" }, + { url = "https://files.pythonhosted.org/packages/9f/8b/3d0c7a002db3b1ed702731c2a9a06d78d035f1f2fb0fb936a8e43cc1e9f4/matplotlib-3.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a4a4cfc82330b27042a7169533da7991e8789d180dd5b3daeaee57d75cd5a03b", size = 7841160, upload-time = "2024-12-13T05:55:19.991Z" }, + { url = "https://files.pythonhosted.org/packages/49/b1/999f89a7556d101b23a2f0b54f1b6e140d73f56804da1398f2f0bc0924bc/matplotlib-3.9.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37eeffeeca3c940985b80f5b9a7b95ea35671e0e7405001f249848d2b62351b6", size = 7891499, upload-time = "2024-12-13T05:55:22.142Z" }, + { url = "https://files.pythonhosted.org/packages/87/7b/06a32b13a684977653396a1bfcd34d4e7539c5d55c8cbfaa8ae04d47e4a9/matplotlib-3.9.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3e7465ac859ee4abcb0d836137cd8414e7bb7ad330d905abced457217d4f0f45", size = 7776802, upload-time = "2024-12-13T05:55:25.947Z" }, + { url = "https://files.pythonhosted.org/packages/65/87/ac498451aff739e515891bbb92e566f3c7ef31891aaa878402a71f9b0910/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4c12302c34afa0cf061bea23b331e747e5e554b0fa595c96e01c7b75bc3b858", size = 8200802, upload-time = "2024-12-13T05:55:28.461Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6b/9eb761c00e1cb838f6c92e5f25dcda3f56a87a52f6cb8fdfa561e6cf6a13/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b8c97917f21b75e72108b97707ba3d48f171541a74aa2a56df7a40626bafc64", size = 8313880, upload-time = "2024-12-13T05:55:30.965Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a2/c8eaa600e2085eec7e38cbbcc58a30fc78f8224939d31d3152bdafc01fd1/matplotlib-3.9.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0229803bd7e19271b03cb09f27db76c918c467aa4ce2ae168171bc67c3f508df", size = 9094637, upload-time = "2024-12-13T05:55:33.701Z" }, + { url = "https://files.pythonhosted.org/packages/71/1f/c6e1daea55b7bfeb3d84c6cb1abc449f6a02b181e7e2a5e4db34c3afb793/matplotlib-3.9.4-cp313-cp313-win_amd64.whl", hash = "sha256:7c0d8ef442ebf56ff5e206f8083d08252ee738e04f3dc88ea882853a05488799", size = 7841311, upload-time = "2024-12-13T05:55:36.737Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3a/2757d3f7d388b14dd48f5a83bea65b6d69f000e86b8f28f74d86e0d375bd/matplotlib-3.9.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a04c3b00066a688834356d196136349cb32f5e1003c55ac419e91585168b88fb", size = 7919989, upload-time = "2024-12-13T05:55:39.024Z" }, + { url = "https://files.pythonhosted.org/packages/24/28/f5077c79a4f521589a37fe1062d6a6ea3534e068213f7357e7cfffc2e17a/matplotlib-3.9.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:04c519587f6c210626741a1e9a68eefc05966ede24205db8982841826af5871a", size = 7809417, upload-time = "2024-12-13T05:55:42.412Z" }, + { url = "https://files.pythonhosted.org/packages/36/c8/c523fd2963156692916a8eb7d4069084cf729359f7955cf09075deddfeaf/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:308afbf1a228b8b525fcd5cec17f246bbbb63b175a3ef6eb7b4d33287ca0cf0c", size = 8226258, upload-time = "2024-12-13T05:55:47.259Z" }, + { url = "https://files.pythonhosted.org/packages/f6/88/499bf4b8fa9349b6f5c0cf4cead0ebe5da9d67769129f1b5651e5ac51fbc/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddb3b02246ddcffd3ce98e88fed5b238bc5faff10dbbaa42090ea13241d15764", size = 8335849, upload-time = "2024-12-13T05:55:49.763Z" }, + { url = "https://files.pythonhosted.org/packages/b8/9f/20a4156b9726188646a030774ee337d5ff695a965be45ce4dbcb9312c170/matplotlib-3.9.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8a75287e9cb9eee48cb79ec1d806f75b29c0fde978cb7223a1f4c5848d696041", size = 9102152, upload-time = "2024-12-13T05:55:51.997Z" }, + { url = "https://files.pythonhosted.org/packages/10/11/237f9c3a4e8d810b1759b67ff2da7c32c04f9c80aa475e7beb36ed43a8fb/matplotlib-3.9.4-cp313-cp313t-win_amd64.whl", hash = "sha256:488deb7af140f0ba86da003e66e10d55ff915e152c78b4b66d231638400b1965", size = 7896987, upload-time = "2024-12-13T05:55:55.941Z" }, + { url = "https://files.pythonhosted.org/packages/56/eb/501b465c9fef28f158e414ea3a417913dc2ac748564c7ed41535f23445b4/matplotlib-3.9.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:3c3724d89a387ddf78ff88d2a30ca78ac2b4c89cf37f2db4bd453c34799e933c", size = 7885919, upload-time = "2024-12-13T05:55:59.66Z" }, + { url = "https://files.pythonhosted.org/packages/da/36/236fbd868b6c91309a5206bd90c3f881f4f44b2d997cd1d6239ef652f878/matplotlib-3.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d5f0a8430ffe23d7e32cfd86445864ccad141797f7d25b7c41759a5b5d17cfd7", size = 7771486, upload-time = "2024-12-13T05:56:04.264Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4b/105caf2d54d5ed11d9f4335398f5103001a03515f2126c936a752ccf1461/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bb0141a21aef3b64b633dc4d16cbd5fc538b727e4958be82a0e1c92a234160e", size = 8201838, upload-time = "2024-12-13T05:56:06.792Z" }, + { url = "https://files.pythonhosted.org/packages/5d/a7/bb01188fb4013d34d274caf44a2f8091255b0497438e8b6c0a7c1710c692/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:57aa235109e9eed52e2c2949db17da185383fa71083c00c6c143a60e07e0888c", size = 8314492, upload-time = "2024-12-13T05:56:09.964Z" }, + { url = "https://files.pythonhosted.org/packages/33/19/02e1a37f7141fc605b193e927d0a9cdf9dc124a20b9e68793f4ffea19695/matplotlib-3.9.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b18c600061477ccfdd1e6fd050c33d8be82431700f3452b297a56d9ed7037abb", size = 9092500, upload-time = "2024-12-13T05:56:13.55Z" }, + { url = "https://files.pythonhosted.org/packages/57/68/c2feb4667adbf882ffa4b3e0ac9967f848980d9f8b5bebd86644aa67ce6a/matplotlib-3.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:ef5f2d1b67d2d2145ff75e10f8c008bfbf71d45137c4b648c87193e7dd053eac", size = 7822962, upload-time = "2024-12-13T05:56:16.358Z" }, + { url = "https://files.pythonhosted.org/packages/0c/22/2ef6a364cd3f565442b0b055e0599744f1e4314ec7326cdaaa48a4d864d7/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:44e0ed786d769d85bc787b0606a53f2d8d2d1d3c8a2608237365e9121c1a338c", size = 7877995, upload-time = "2024-12-13T05:56:18.805Z" }, + { url = "https://files.pythonhosted.org/packages/87/b8/2737456e566e9f4d94ae76b8aa0d953d9acb847714f9a7ad80184474f5be/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:09debb9ce941eb23ecdbe7eab972b1c3e0276dcf01688073faff7b0f61d6c6ca", size = 7769300, upload-time = "2024-12-13T05:56:21.315Z" }, + { url = "https://files.pythonhosted.org/packages/b2/1f/e709c6ec7b5321e6568769baa288c7178e60a93a9da9e682b39450da0e29/matplotlib-3.9.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcc53cf157a657bfd03afab14774d54ba73aa84d42cfe2480c91bd94873952db", size = 8313423, upload-time = "2024-12-13T05:56:26.719Z" }, + { url = "https://files.pythonhosted.org/packages/5e/b6/5a1f868782cd13f053a679984e222007ecff654a9bfbac6b27a65f4eeb05/matplotlib-3.9.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ad45da51be7ad02387801fd154ef74d942f49fe3fcd26a64c94842ba7ec0d865", size = 7854624, upload-time = "2024-12-13T05:56:29.359Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.9" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "cycler", marker = "python_full_version == '3.10.*'" }, + { name = "fonttools", version = "4.63.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "kiwisolver", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "packaging", marker = "python_full_version == '3.10.*'" }, + { name = "pillow", version = "12.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "pyparsing", version = "3.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "python-dateutil", marker = "python_full_version == '3.10.*'" }, +] +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/18/6f/340b04986e67aac6f66c5145ce68bf72c64bed30f92c8913499a6e6b8f99/matplotlib-3.10.9-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77210dce9cb8153dffc967efaae990543392563d5a376d4dd8539bebcb0ed217", size = 8296625, upload-time = "2026-04-24T00:11:43.376Z" }, + { url = "https://files.pythonhosted.org/packages/bb/2f/127081eb83162053ebb9678ceac64220b93a663e0167432566e9c7c82aab/matplotlib-3.10.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1e7698ac9868428e84d2c967424803b2472ff7167d9d6590d4204ed775343c3b", size = 8188790, upload-time = "2026-04-24T00:11:46.556Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b7/d8bcec2626c35f96972bff656299fef4578113ea6193c8fdad324710410c/matplotlib-3.10.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1aa972116abb4c9d201bf245620b433726cb6856f3bef6a78f776a00f5c92d37", size = 8769389, upload-time = "2026-04-24T00:11:48.959Z" }, + { url = "https://files.pythonhosted.org/packages/12/49/b78e214a527ea732033b7f4d37f7afb504d74ba9d134bd47938230dfb8b1/matplotlib-3.10.9-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae2f11957b27ce53497dd4d7b235c4d4f1faf383dfb39d0c5beb833bff883294", size = 9589657, upload-time = "2026-04-24T00:11:51.915Z" }, + { url = "https://files.pythonhosted.org/packages/5f/15/5246f7b43beae19c74dfee651d58d6cc8112e06f77adb4e88cc04f2e3a23/matplotlib-3.10.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b049278ddce116aaa1c1377ebf58adea909132dfce0281cf7e3a1ea9fc2e2c65", size = 9651983, upload-time = "2026-04-24T00:11:54.766Z" }, + { url = "https://files.pythonhosted.org/packages/75/77/5acecfe672ba0fa1b8c0454f69ce155d1e6fc5852fa7206bf9afaf767121/matplotlib-3.10.9-cp310-cp310-win_amd64.whl", hash = "sha256:82834c3c292d24d3a8aae77cd2d20019de69d692a34a970e4fdb8d33e2ea3dda", size = 8199701, upload-time = "2026-04-24T00:11:58.389Z" }, + { url = "https://files.pythonhosted.org/packages/4c/8c/290f021104741fea63769c31494f5324c0cd249bf536a65a4350767b1f22/matplotlib-3.10.9-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:68cfdcede415f7c8f5577b03303dd94526cdb6d11036cecdc205e08733b2d2bb", size = 8306860, upload-time = "2026-04-24T00:12:01.207Z" }, + { url = "https://files.pythonhosted.org/packages/51/18/325cd32ece1120d1da51cc4e4294c6580190699490183fc2fe8cb6d61ec5/matplotlib-3.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfca0129678bd56379db26c52b5d77ed7de314c047492fbdc763aa7501710cfb", size = 8199254, upload-time = "2026-04-24T00:12:04.239Z" }, + { url = "https://files.pythonhosted.org/packages/79/db/e28c1b83e3680740aa78925f5fb2ae4d16207207419ad75ea9fe604f8676/matplotlib-3.10.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e436d155fa8a3399dc62683f8f5d0e2e50d25d0144a73edd73f82eec8f4abfb", size = 8777092, upload-time = "2026-04-24T00:12:06.793Z" }, + { url = "https://files.pythonhosted.org/packages/55/fa/3ce7adfe9ba101748f465211660d9c6374c876b671bdb8c2bb6d347e8b94/matplotlib-3.10.9-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56fc0bd271b00025c6edfdc7c2dcd247372c8e1544971d62e1dc7c17367e8bf9", size = 9595691, upload-time = "2026-04-24T00:12:09.706Z" }, + { url = "https://files.pythonhosted.org/packages/36/c4/6960a76686ed668f2c60f84e9799ba4c0d56abdb36b1577b60c1d061d1ec/matplotlib-3.10.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5a6104ed666402ba5106d7f36e0e0cdca4e8d7fa4d39708ca88019e2835a2eb", size = 9659771, upload-time = "2026-04-24T00:12:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0d/271aace3342157c64700c9ff4c59c7b392f3dbab393692e8db6fbe7ab96c/matplotlib-3.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:d730e984eddf56974c3e72b6129c7ca462ac38dc624338f4b0b23eb23ecba00f", size = 8205112, upload-time = "2026-04-24T00:12:15.773Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ee/cb57ad4754f3e7b9174ce6ce66d9205fb827067e48a9f58ac09d7e7d6b77/matplotlib-3.10.9-cp311-cp311-win_arm64.whl", hash = "sha256:51bf0ddbdc598e060d46c16b5590708f81a1624cefbaaf62f6a81bf9285b8c80", size = 8132310, upload-time = "2026-04-24T00:12:18.645Z" }, + { url = "https://files.pythonhosted.org/packages/35/c6/5581e26c72233ebb2a2a6fed2d24fb7c66b4700120b813f51b0555acf0b6/matplotlib-3.10.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0c3c28d9fbcc1fe7a03be236d73430cf6409c41fb2383a7ac52fe932b072cb1", size = 8319908, upload-time = "2026-04-24T00:12:21.323Z" }, + { url = "https://files.pythonhosted.org/packages/b7/18/4880dd762e40cd360c1bf06e890c5a97b997e91cb324602b1a19950ad5ce/matplotlib-3.10.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cb28c2bd769aa3e98322c6ab09854cbcc52ab69d2759d681bba3e327b2b320", size = 8216016, upload-time = "2026-04-24T00:12:23.4Z" }, + { url = "https://files.pythonhosted.org/packages/32/91/d024616abdba99e83120e07a20658976f6a343646710760c4a51df126029/matplotlib-3.10.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae20801130378b82d647ff5047c07316295b68dc054ca6b3c13519d0ea624285", size = 8789336, upload-time = "2026-04-24T00:12:26.096Z" }, + { url = "https://files.pythonhosted.org/packages/5c/04/030a2f61ef2158f5e4c259487a92ac877732499fb33d871585d89e03c42d/matplotlib-3.10.9-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c63ebcd8b4b169eb2f5c200552ae6b8be8999a005b6b507ed76fb8d7d674fe2", size = 9604602, upload-time = "2026-04-24T00:12:29.052Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c2/541e4d09d87bb6b5830fc28b4c887a9a8cf4e1c6cee698a8c05552ae2003/matplotlib-3.10.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d75d11c949914165976c621b2324f9ef162af7ebf4b057ddf95dd1dba7e5edcf", size = 9670966, upload-time = "2026-04-24T00:12:32.131Z" }, + { url = "https://files.pythonhosted.org/packages/04/a1/4571fc46e7702de8d0c2dc54ad1b2f8e29328dea3ee90831181f7353d93c/matplotlib-3.10.9-cp312-cp312-win_amd64.whl", hash = "sha256:d091f9d758b34aaaaa6331d13574bf01891d903b3dec59bfff458ef7551de5d6", size = 8217462, upload-time = "2026-04-24T00:12:35.226Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d0/2269edb12aa30c13c8bcc9382892e39943ce1d28aab4ec296e0381798e81/matplotlib-3.10.9-cp312-cp312-win_arm64.whl", hash = "sha256:10cc5ce06d10231c36f40e875f3c7e8050362a4ee8f0ee5d29a6b3277d57bb42", size = 8136688, upload-time = "2026-04-24T00:12:37.442Z" }, + { 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" }, + { url = "https://files.pythonhosted.org/packages/2c/2b/0e92ad0ac446633f928a1563db4aa8add407e1924faf0ded5b95b35afb27/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1872fb212a05b729e649754a72d5da61d03e0554d76e80303b6f83d1d2c0552b", size = 8293058, upload-time = "2026-04-24T00:13:56.339Z" }, + { url = "https://files.pythonhosted.org/packages/4b/23/74682fd369f5299ceda438fea2a0662e6383b85c9383fb9cdfcf04713e07/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:985f2238880e2e69093f588f5fe2e46771747febf0649f3cf7f7b7480875317f", size = 8186627, upload-time = "2026-04-24T00:13:58.623Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e8/368aab88f3c4cd8992800f31abfe0670c3e47540ba20a97e9fdbcde594b3/matplotlib-3.10.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6640f75af2c6148293caa0a2b39dd806a492dd66c8a8b04035813e33d0fd2585", size = 8764117, upload-time = "2026-04-24T00:14:01.684Z" }, + { url = "https://files.pythonhosted.org/packages/63/e2/9f66ca6a651a52abfe0d4964ce01439ed34f3f1e119de10ff3a07f403043/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:42fb814efabe95c06c1994d8ab5a8385f43a249e23badd3ba931d4308e5bca20", size = 8304420, upload-time = "2026-04-24T00:14:04.57Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e8/467c03568218792906aa87b5e7bb379b605e056ed0c74fe00c051786d925/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f76e640a5268850bfda54b5131b1b1941cc685e42c5fa98ed9f2d64038308cba", size = 8197981, upload-time = "2026-04-24T00:14:07.233Z" }, + { url = "https://files.pythonhosted.org/packages/6f/87/afead29192170917537934c6aff4b008c805fff7b1ccea0c79120d96beda/matplotlib-3.10.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3fc0364dfbe1d07f6d15c5ebd0c5bf89e126916e5a8667dd4a7a6e84c36653d4", size = 8774002, upload-time = "2026-04-24T00:14:09.816Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.11.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "cycler", marker = "python_full_version >= '3.11'" }, + { name = "fonttools", version = "4.63.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "kiwisolver", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging", marker = "python_full_version >= '3.11'" }, + { name = "pillow", version = "12.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "pyparsing", version = "3.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/64/f9a391af28f518b11ad45a8a712353c94a0aefce09d3703200e5c54b610a/matplotlib-3.11.1.tar.gz", hash = "sha256:69647db5746941c793d6e445a4cd349323ffb87d9cc958c2ad84a659b4832d30", size = 32612045, upload-time = "2026-07-18T03:39:46.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6e/d0/791aa183dd88491555cf7d4be0b52b0bcf6c3c2a2c22c815a2e819bf53e2/matplotlib-3.11.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b7cf158e7add54a8d51ac9b5a84abd6d4e13ed4951b4f25f1c5139f41c2addb2", size = 9440302, upload-time = "2026-07-18T03:38:03.844Z" }, + { url = "https://files.pythonhosted.org/packages/35/74/82bbdf683a301f4478384c8aaba6903631a2ca18294b2d7655c9a542bffb/matplotlib-3.11.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d2ace7273b9a5061a3b420918a16fae1f2dc5dfee1abcc13aba71b5d94b1820c", size = 9268549, upload-time = "2026-07-18T03:38:06.144Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f0/9b4298911303f74e6d83e64a81d996c0616405ec95046fac7f17e4258b9e/matplotlib-3.11.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee55e9041211bf84302ab55ec3965df18dd90ae19f8b58332a7feaf208bfe83", size = 10024922, upload-time = "2026-07-18T03:38:08.236Z" }, + { url = "https://files.pythonhosted.org/packages/84/6f/0bc3c3d05b021db44c14bc379a7c0df7d57302aa15380c16fd4e63fd6a9b/matplotlib-3.11.1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f4bdeea33a8d15a071dbfe6d119451b1d719c733ac666d65357082901a9099", size = 10832170, upload-time = "2026-07-18T03:38:10.276Z" }, + { url = "https://files.pythonhosted.org/packages/db/4d/e375f39acdb2af5a9342730618608e39790ec842e6f1b392863028781459/matplotlib-3.11.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b4c78ceb2f11bcac7389d305cda17aeb1f4586a857854ab5780bd3dd8dbfc407", size = 10916701, upload-time = "2026-07-18T03:38:12.512Z" }, + { url = "https://files.pythonhosted.org/packages/bc/be/fa26ed085b41298f64a8f9b7592c671bbf1acc8b0df124c1c5de96b859f8/matplotlib-3.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:7f33a781e12b1e53b278deb2f5373c2e55ec4f10727be3440c0cfb5cda9f944f", size = 9315331, upload-time = "2026-07-18T03:38:14.949Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f3/eb5bdf3b6e191b200db298b08bbc1638b7f3c82cdc8680f9d88bf72559ae/matplotlib-3.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:67e4c3cd578c65ebd81bdc09a1b6592ceafee6dfafe116dc85dfcb647b5bbb18", size = 9003475, upload-time = "2026-07-18T03:38:17.205Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6c/7ef7ebcb2bd9739b2b66b18b076e077f44bb46fdbe28ca0506edb3c62c79/matplotlib-3.11.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e15ef41507f3d525f46154ac9e3ae785dacde9f20e593a25de8986267892ef74", size = 9453849, upload-time = "2026-07-18T03:38:19.593Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f8/6d0c312c8d9738e7d9677f09fe5c986b3239e651a7b73a2deb38b65e4a71/matplotlib-3.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:21a67b961a6d597bca54fae826cd20695ba4a6e4d05424a08da6e13e3176fd6b", size = 9283113, upload-time = "2026-07-18T03:38:21.95Z" }, + { url = "https://files.pythonhosted.org/packages/c9/cf/b4ad2cc81b6672ea29ea04e64e350a9f9b493b0908ccd884c67eeff8f7b2/matplotlib-3.11.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba8f811b8ddfac493734d6af0b2dff96919d0c28ca0d641858dab4262777c6ea", size = 10035615, upload-time = "2026-07-18T03:38:24.315Z" }, + { url = "https://files.pythonhosted.org/packages/88/90/4e10e033d9b66589d8ed98b84c95cdbb57033d57c1f41339d7393dbd2f2e/matplotlib-3.11.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c52f7ad20ef476806ed212380b1d54d20310c8b86bdc2c9a68b51f0024a44472", size = 10842559, upload-time = "2026-07-18T03:38:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/88/eb/799612d0f8cd3e816a10fec59329fca52cd2353264df80378dfc541ae855/matplotlib-3.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8b14eb22961fe865efb0e4ff167e333e428908b00115a8d800ccb65ee108e481", size = 10927532, upload-time = "2026-07-18T03:38:28.532Z" }, + { url = "https://files.pythonhosted.org/packages/88/89/56649bbaa2fd12e20f3be03dbcc135b0c8676d88bac17977599e3eb442a0/matplotlib-3.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:88a2a27dd9691ae448dfae4b26f59036be90c3c28757edd3553a29559d00859f", size = 9333886, upload-time = "2026-07-18T03:38:30.477Z" }, + { url = "https://files.pythonhosted.org/packages/c1/11/4d124efbbad677b7b7552f6f85a3bd432d4232f95400cea98fcd2ae36ef3/matplotlib-3.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:480194afceca4df2f137c2721227d3cba67121fbf4397b69cee7f83714b0a58a", size = 9007545, upload-time = "2026-07-18T03:38:32.833Z" }, + { url = "https://files.pythonhosted.org/packages/04/6c/4798363b7fb5644e309fe1fac30216e9146c9f70859d80d588c18caf5317/matplotlib-3.11.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6771b0cd7838c6a857a7209814158c0ad09bfef878db3033dd82d70ad101f191", size = 9454341, upload-time = "2026-07-18T03:38:35.001Z" }, + { url = "https://files.pythonhosted.org/packages/59/98/6acadbe7f98df19d274bc107ac58bb439fa75df82c33dc110d71a4a8501f/matplotlib-3.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2abdee5ffa2fe11b2d19f7a5c63b785fb7c28cc46c7bc1814156341d9d1a33e1", size = 9283627, upload-time = "2026-07-18T03:38:37.061Z" }, + { url = "https://files.pythonhosted.org/packages/24/ea/65cec46fe241390ccea1b1754207ee28eb71c5ab866bd5f22fe47e538fa4/matplotlib-3.11.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0a19dcf73406d3746d25a5ed42d713604c9a3e024d129b102852b0d941cb9f3", size = 10035860, upload-time = "2026-07-18T03:38:39.663Z" }, + { url = "https://files.pythonhosted.org/packages/c7/10/63fdccccbabe002fb0960876baabc5e3f24d9c1bb4cfb25651457f74b3a0/matplotlib-3.11.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7389b77ed2ab0552f46d9a90b81b7b8e6dfcdc42adc36c37a0865799843e0e3e", size = 10843594, upload-time = "2026-07-18T03:38:42.144Z" }, + { url = "https://files.pythonhosted.org/packages/98/51/a1155945bff7b91381875022ac1522c5dfdac0d006be8e7df389b3134eae/matplotlib-3.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c90be0b73568da4f662afac580956a76e308437e641b4a45aa08925eeb67d95f", size = 10927962, upload-time = "2026-07-18T03:38:44.302Z" }, + { url = "https://files.pythonhosted.org/packages/0d/3a/3d5e1f42dc761bf53401a62a83ff93389b37de9d2c093b2a3aa49ac34f1b/matplotlib-3.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:68408341f2312836fbbdf6b3c78047f65b2d8752f5fd221c3e72d348f5b34f8b", size = 9334074, upload-time = "2026-07-18T03:38:46.616Z" }, + { url = "https://files.pythonhosted.org/packages/e2/db/3f5ea5a5b64060ef5e1ff60a19170423e41ce21b8497a6fe15a36e0b43e3/matplotlib-3.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c1f44890d435c1b4ef52f701ad5828cb450ea97bcc83918fda6be74965d6cd2", size = 9007662, upload-time = "2026-07-18T03:38:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/98/6e/c7ae5e0531425b69c0826b00ebbc264c85cab853f1cd6e096c9983c2cdc1/matplotlib-3.11.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:5e510088c27a89d53580a752f959146893563e63c330e161d159b0fee652af6f", size = 9503790, upload-time = "2026-07-18T03:38:51.527Z" }, + { url = "https://files.pythonhosted.org/packages/92/79/15be162e0a2ed546939674e2e97d0e33ec2447d86d4d4e611fa295bb178c/matplotlib-3.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:1524e2bdd48a93557aa47ddcfe9c225dfdd57d5a01a5c49128c20f0632980ee1", size = 9336148, upload-time = "2026-07-18T03:38:53.564Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7f/36ffe144fc4aacfe0e3ed2318f72b6755d1e73b041d619b4d393e60f5a66/matplotlib-3.11.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:11664c551345553db92e61cae6cf1376f138f8c47cafdf13b64b18f3e3e9e464", size = 10049244, upload-time = "2026-07-18T03:38:55.911Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/55812d68c0a840d3a463638f48c00ab1fe338518ec49a640cb6473b444af/matplotlib-3.11.1-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e1f8922ba31959cf6a9dfb51be64b7f7bc582801a3957dc0c2f3afcd3537adf", size = 10860798, upload-time = "2026-07-18T03:38:58.282Z" }, + { url = "https://files.pythonhosted.org/packages/7a/64/cca444b4eb5e6c768c44fc5e1f0b5211f20ca2b282778051996e996a2bdf/matplotlib-3.11.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83235693abde86e5e0129998f80ee39fc7f58e6d56a88fafb28a9278833e9d5f", size = 10943282, upload-time = "2026-07-18T03:39:00.465Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0f/a49c329d394f2e9ef38506982107e8b04ecf94dd41a9d8423ff82cc737c7/matplotlib-3.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:9a076f4fc5cdc43fdf510f5981418d25c2db4973418d9f22d8bb3dc8045ada78", size = 9383532, upload-time = "2026-07-18T03:39:02.468Z" }, + { url = "https://files.pythonhosted.org/packages/e4/50/103e86afb806d8f64d04ede14e4cfc09dbfc25f512421ff85fdd6ebd59cf/matplotlib-3.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:216fbb93a74add02ddb4cb38ef5348f59ac00b3e84567eaf16598772d40e150a", size = 9059665, upload-time = "2026-07-18T03:39:04.607Z" }, + { url = "https://files.pythonhosted.org/packages/35/04/3079499fa8cb661ea66d13d6439d5a3ae6710a7afd5c7f72e08914f275f8/matplotlib-3.11.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:30c492d4ba9448595b6fd8708c6725963f8148e25c0d8842948da5b05f0ee8d3", size = 9456022, upload-time = "2026-07-18T03:39:07.041Z" }, + { url = "https://files.pythonhosted.org/packages/53/a2/69acfe84ec1f32930e801a5782a07fc5c79c8c6599a507b806d859d5da8e/matplotlib-3.11.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ac104be2768ffdd8655db9e71b768cbb45f2b9aa7b450cf1595e8f65d3822319", size = 9285475, upload-time = "2026-07-18T03:39:09.562Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b3/31b15a2ca56d4ddd6aaa1c884c2f51cf9a61cfaf5ca6f6fbd6343d38e6df/matplotlib-3.11.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6be943cb68bc6660ead58c55b3aa6366cba2ef7feb06460fbcce32360376f19f", size = 10847102, upload-time = "2026-07-18T03:39:11.532Z" }, + { url = "https://files.pythonhosted.org/packages/64/0d/a17e966e620545c1548125af0b29ac812dd17b197a18a7462ac12fa859ee/matplotlib-3.11.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5af0dcda57d471440a7b5b623e70e0a61003518443d9098f211a96ecfbbc25be", size = 11131087, upload-time = "2026-07-18T03:39:13.764Z" }, + { url = "https://files.pythonhosted.org/packages/97/c5/5e100efdd67abb7de20befaa333612ef9bfc63417fb71398f904f25d083c/matplotlib-3.11.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3d3fd84082b1afbd9398466c81309e20045be20d48fe0fb18c43504d164cbbb2", size = 10929036, upload-time = "2026-07-18T03:39:16.888Z" }, + { url = "https://files.pythonhosted.org/packages/ce/04/d719a0a36930ecc8dfc801ff340f9dcfc4223f8ca5d39d06b4020032fff8/matplotlib-3.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:9601a1e90be21e4884c53b4f3dc3ee0544654946f9975258d691f1c2e2f119c6", size = 9489571, upload-time = "2026-07-18T03:39:19.449Z" }, + { url = "https://files.pythonhosted.org/packages/48/65/facabdc2f1f6caba7e856db64dfedddca25f7608df07d96a1c8fd114fd3b/matplotlib-3.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:ae30c6109848ac0f9fa36c5d6270938487614c47ba31860bd5361266dabc5685", size = 9164486, upload-time = "2026-07-18T03:39:21.424Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/18da6cd01cf96354534f98c468a25380c68ce582a2c9dd0cae12b04af4f2/matplotlib-3.11.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:dadfe80797174e2984aae3be0b77594a3c72d2c0a40fbd4a0de48d2728caf3ae", size = 9504876, upload-time = "2026-07-18T03:39:23.633Z" }, + { url = "https://files.pythonhosted.org/packages/79/b0/f0b63555a18b79d038c81fd6126f35fc4dfce0eaff48d96103348c7cf935/matplotlib-3.11.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:89b193b255f4f6f7948dbcee3691f4f341ab05d9a8874a67b45ddb4182922eda", size = 9336120, upload-time = "2026-07-18T03:39:25.797Z" }, + { url = "https://files.pythonhosted.org/packages/c6/dd/f210ec7c4a6f198d5567237048a93d0811fb5a1f1691f13320e592f95b41/matplotlib-3.11.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191163532cdefcb1571ca38a6d7e6474baccde64495783e6ba47aa07ec4b9bbb", size = 10858033, upload-time = "2026-07-18T03:39:27.999Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d2/d6d5324507c5fbb316db48e258c09c2807f3de03d9af47017e120070926f/matplotlib-3.11.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9fdf1c818ab05d0e74002091ddaf414478a3a449ec9d51c8976d45be7e3a01e2", size = 11141827, upload-time = "2026-07-18T03:39:30.092Z" }, + { url = "https://files.pythonhosted.org/packages/0f/68/3c22e9320bdce2c4d2f1320643ef706db7a24cb7420eea28b97a2d67f5a8/matplotlib-3.11.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b937b9dba5f5f6c1e31c47abe2186c865c0914fd18f2ce0dfc39c9adcef5951d", size = 10943061, upload-time = "2026-07-18T03:39:32.356Z" }, + { url = "https://files.pythonhosted.org/packages/f6/4a/907ed190ee81a9df581e0ed5456134fc0f7cb55ffcfda2f9e54ca900761c/matplotlib-3.11.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f2912f647f3fbe1ccf085f91e213936f9101bead81a5e670565b1f1b3712f4fb", size = 9540074, upload-time = "2026-07-18T03:39:34.789Z" }, + { url = "https://files.pythonhosted.org/packages/23/d4/97c19b77e0a6e3b48581185bb65088f431cd20186076cc0f650a1757ea46/matplotlib-3.11.1-cp314-cp314t-win_arm64.whl", hash = "sha256:54d47b8ae8b579633a3902ca5b4ad6c1e132a5626d64447b2e22a66394e79987", size = 9213472, upload-time = "2026-07-18T03:39:37.141Z" }, + { url = "https://files.pythonhosted.org/packages/ee/38/ceb1d637c4db6d06141f3739e93af3321e7caaabe69b57ae48ffe3ee95b1/matplotlib-3.11.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:427258425f9a3fc4ed79a91f9e9b9aaf5a82cb6571e85dc14063cc6fbb993741", size = 9438045, upload-time = "2026-07-18T03:39:39.491Z" }, + { url = "https://files.pythonhosted.org/packages/89/25/72ad8b58602d3a6ef1dfc4b65ecd01634ab65a2bdf494c9fe0e966dbf081/matplotlib-3.11.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:1ac697e591c11b6ad04679a73c2d2f9980fe9d9f0311fb414a2e329706343dfb", size = 9266127, upload-time = "2026-07-18T03:39:41.597Z" }, + { url = "https://files.pythonhosted.org/packages/8a/6d/69552382fcc8e93d1f2763ef2665980a900a48b7f3a4c57ed290726d1cbc/matplotlib-3.11.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e4b9ac2f1f607ecda2af90a5232beee2af7582fce1cc30c4b6a1b012dc21ee99", size = 10019439, upload-time = "2026-07-18T03:39:43.78Z" }, ] [[package]] @@ -839,117 +1875,150 @@ wheels = [ ] [[package]] -name = "mypy" -version = "1.14.1" +name = "msgpack" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.8.1' and python_full_version < '3.9'", "python_full_version < '3.8.1'", ] -dependencies = [ - { name = "mypy-extensions", marker = "python_full_version < '3.9'" }, - { name = "tomli", marker = "python_full_version < '3.9'" }, - { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b9/eb/2c92d8ea1e684440f54fa49ac5d9a5f19967b7b472a281f419e69a8d228e/mypy-1.14.1.tar.gz", hash = "sha256:7ec88144fe9b510e8475ec2f5f251992690fcf89ccb4500b214b4226abcd32d6", size = 3216051, upload-time = "2024-12-30T16:39:07.335Z" } +sdist = { url = "https://files.pythonhosted.org/packages/45/b1/ea4f68038a18c77c9467400d166d74c4ffa536f34761f7983a104357e614/msgpack-1.1.1.tar.gz", hash = "sha256:77b79ce34a2bdab2594f490c8e80dd62a02d650b91a75159a63ec413b8d104cd", size = 173555, upload-time = "2025-06-13T06:52:51.324Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9b/7a/87ae2adb31d68402da6da1e5f30c07ea6063e9f09b5e7cfc9dfa44075e74/mypy-1.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52686e37cf13d559f668aa398dd7ddf1f92c5d613e4f8cb262be2fb4fedb0fcb", size = 11211002, upload-time = "2024-12-30T16:37:22.435Z" }, - { url = "https://files.pythonhosted.org/packages/e1/23/eada4c38608b444618a132be0d199b280049ded278b24cbb9d3fc59658e4/mypy-1.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fb545ca340537d4b45d3eecdb3def05e913299ca72c290326be19b3804b39c0", size = 10358400, upload-time = "2024-12-30T16:37:53.526Z" }, - { url = "https://files.pythonhosted.org/packages/43/c9/d6785c6f66241c62fd2992b05057f404237deaad1566545e9f144ced07f5/mypy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90716d8b2d1f4cd503309788e51366f07c56635a3309b0f6a32547eaaa36a64d", size = 12095172, upload-time = "2024-12-30T16:37:50.332Z" }, - { url = "https://files.pythonhosted.org/packages/c3/62/daa7e787770c83c52ce2aaf1a111eae5893de9e004743f51bfcad9e487ec/mypy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae753f5c9fef278bcf12e1a564351764f2a6da579d4a81347e1d5a15819997b", size = 12828732, upload-time = "2024-12-30T16:37:29.96Z" }, - { url = "https://files.pythonhosted.org/packages/1b/a2/5fb18318a3637f29f16f4e41340b795da14f4751ef4f51c99ff39ab62e52/mypy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e0fe0f5feaafcb04505bcf439e991c6d8f1bf8b15f12b05feeed96e9e7bf1427", size = 13012197, upload-time = "2024-12-30T16:38:05.037Z" }, - { url = "https://files.pythonhosted.org/packages/28/99/e153ce39105d164b5f02c06c35c7ba958aaff50a2babba7d080988b03fe7/mypy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:7d54bd85b925e501c555a3227f3ec0cfc54ee8b6930bd6141ec872d1c572f81f", size = 9780836, upload-time = "2024-12-30T16:37:19.726Z" }, - { url = "https://files.pythonhosted.org/packages/da/11/a9422850fd506edbcdc7f6090682ecceaf1f87b9dd847f9df79942da8506/mypy-1.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f995e511de847791c3b11ed90084a7a0aafdc074ab88c5a9711622fe4751138c", size = 11120432, upload-time = "2024-12-30T16:37:11.533Z" }, - { url = "https://files.pythonhosted.org/packages/b6/9e/47e450fd39078d9c02d620545b2cb37993a8a8bdf7db3652ace2f80521ca/mypy-1.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d64169ec3b8461311f8ce2fd2eb5d33e2d0f2c7b49116259c51d0d96edee48d1", size = 10279515, upload-time = "2024-12-30T16:37:40.724Z" }, - { url = "https://files.pythonhosted.org/packages/01/b5/6c8d33bd0f851a7692a8bfe4ee75eb82b6983a3cf39e5e32a5d2a723f0c1/mypy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba24549de7b89b6381b91fbc068d798192b1b5201987070319889e93038967a8", size = 12025791, upload-time = "2024-12-30T16:36:58.73Z" }, - { url = "https://files.pythonhosted.org/packages/f0/4c/e10e2c46ea37cab5c471d0ddaaa9a434dc1d28650078ac1b56c2d7b9b2e4/mypy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:183cf0a45457d28ff9d758730cd0210419ac27d4d3f285beda038c9083363b1f", size = 12749203, upload-time = "2024-12-30T16:37:03.741Z" }, - { url = "https://files.pythonhosted.org/packages/88/55/beacb0c69beab2153a0f57671ec07861d27d735a0faff135a494cd4f5020/mypy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f2a0ecc86378f45347f586e4163d1769dd81c5a223d577fe351f26b179e148b1", size = 12885900, upload-time = "2024-12-30T16:37:57.948Z" }, - { url = "https://files.pythonhosted.org/packages/a2/75/8c93ff7f315c4d086a2dfcde02f713004357d70a163eddb6c56a6a5eff40/mypy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:ad3301ebebec9e8ee7135d8e3109ca76c23752bac1e717bc84cd3836b4bf3eae", size = 9777869, upload-time = "2024-12-30T16:37:33.428Z" }, - { url = "https://files.pythonhosted.org/packages/43/1b/b38c079609bb4627905b74fc6a49849835acf68547ac33d8ceb707de5f52/mypy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30ff5ef8519bbc2e18b3b54521ec319513a26f1bba19a7582e7b1f58a6e69f14", size = 11266668, upload-time = "2024-12-30T16:38:02.211Z" }, - { url = "https://files.pythonhosted.org/packages/6b/75/2ed0d2964c1ffc9971c729f7a544e9cd34b2cdabbe2d11afd148d7838aa2/mypy-1.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb9f255c18052343c70234907e2e532bc7e55a62565d64536dbc7706a20b78b9", size = 10254060, upload-time = "2024-12-30T16:37:46.131Z" }, - { url = "https://files.pythonhosted.org/packages/a1/5f/7b8051552d4da3c51bbe8fcafffd76a6823779101a2b198d80886cd8f08e/mypy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b4e3413e0bddea671012b063e27591b953d653209e7a4fa5e48759cda77ca11", size = 11933167, upload-time = "2024-12-30T16:37:43.534Z" }, - { url = "https://files.pythonhosted.org/packages/04/90/f53971d3ac39d8b68bbaab9a4c6c58c8caa4d5fd3d587d16f5927eeeabe1/mypy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:553c293b1fbdebb6c3c4030589dab9fafb6dfa768995a453d8a5d3b23784af2e", size = 12864341, upload-time = "2024-12-30T16:37:36.249Z" }, - { url = "https://files.pythonhosted.org/packages/03/d2/8bc0aeaaf2e88c977db41583559319f1821c069e943ada2701e86d0430b7/mypy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fad79bfe3b65fe6a1efaed97b445c3d37f7be9fdc348bdb2d7cac75579607c89", size = 12972991, upload-time = "2024-12-30T16:37:06.743Z" }, - { url = "https://files.pythonhosted.org/packages/6f/17/07815114b903b49b0f2cf7499f1c130e5aa459411596668267535fe9243c/mypy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8fa2220e54d2946e94ab6dbb3ba0a992795bd68b16dc852db33028df2b00191b", size = 9879016, upload-time = "2024-12-30T16:37:15.02Z" }, - { url = "https://files.pythonhosted.org/packages/9e/15/bb6a686901f59222275ab228453de741185f9d54fecbaacec041679496c6/mypy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:92c3ed5afb06c3a8e188cb5da4984cab9ec9a77ba956ee419c68a388b4595255", size = 11252097, upload-time = "2024-12-30T16:37:25.144Z" }, - { url = "https://files.pythonhosted.org/packages/f8/b3/8b0f74dfd072c802b7fa368829defdf3ee1566ba74c32a2cb2403f68024c/mypy-1.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbec574648b3e25f43d23577309b16534431db4ddc09fda50841f1e34e64ed34", size = 10239728, upload-time = "2024-12-30T16:38:08.634Z" }, - { url = "https://files.pythonhosted.org/packages/c5/9b/4fd95ab20c52bb5b8c03cc49169be5905d931de17edfe4d9d2986800b52e/mypy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c6d94b16d62eb3e947281aa7347d78236688e21081f11de976376cf010eb31a", size = 11924965, upload-time = "2024-12-30T16:38:12.132Z" }, - { url = "https://files.pythonhosted.org/packages/56/9d/4a236b9c57f5d8f08ed346914b3f091a62dd7e19336b2b2a0d85485f82ff/mypy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4b19b03fdf54f3c5b2fa474c56b4c13c9dbfb9a2db4370ede7ec11a2c5927d9", size = 12867660, upload-time = "2024-12-30T16:38:17.342Z" }, - { url = "https://files.pythonhosted.org/packages/40/88/a61a5497e2f68d9027de2bb139c7bb9abaeb1be1584649fa9d807f80a338/mypy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c911fde686394753fff899c409fd4e16e9b294c24bfd5e1ea4675deae1ac6fd", size = 12969198, upload-time = "2024-12-30T16:38:32.839Z" }, - { url = "https://files.pythonhosted.org/packages/54/da/3d6fc5d92d324701b0c23fb413c853892bfe0e1dbe06c9138037d459756b/mypy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8b21525cb51671219f5307be85f7e646a153e5acc656e5cebf64bfa076c50107", size = 9885276, upload-time = "2024-12-30T16:38:20.828Z" }, - { url = "https://files.pythonhosted.org/packages/39/02/1817328c1372be57c16148ce7d2bfcfa4a796bedaed897381b1aad9b267c/mypy-1.14.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7084fb8f1128c76cd9cf68fe5971b37072598e7c31b2f9f95586b65c741a9d31", size = 11143050, upload-time = "2024-12-30T16:38:29.743Z" }, - { url = "https://files.pythonhosted.org/packages/b9/07/99db9a95ece5e58eee1dd87ca456a7e7b5ced6798fd78182c59c35a7587b/mypy-1.14.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8f845a00b4f420f693f870eaee5f3e2692fa84cc8514496114649cfa8fd5e2c6", size = 10321087, upload-time = "2024-12-30T16:38:14.739Z" }, - { url = "https://files.pythonhosted.org/packages/9a/eb/85ea6086227b84bce79b3baf7f465b4732e0785830726ce4a51528173b71/mypy-1.14.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:44bf464499f0e3a2d14d58b54674dee25c031703b2ffc35064bd0df2e0fac319", size = 12066766, upload-time = "2024-12-30T16:38:47.038Z" }, - { url = "https://files.pythonhosted.org/packages/4b/bb/f01bebf76811475d66359c259eabe40766d2f8ac8b8250d4e224bb6df379/mypy-1.14.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c99f27732c0b7dc847adb21c9d47ce57eb48fa33a17bc6d7d5c5e9f9e7ae5bac", size = 12787111, upload-time = "2024-12-30T16:39:02.444Z" }, - { url = "https://files.pythonhosted.org/packages/2f/c9/84837ff891edcb6dcc3c27d85ea52aab0c4a34740ff5f0ccc0eb87c56139/mypy-1.14.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:bce23c7377b43602baa0bd22ea3265c49b9ff0b76eb315d6c34721af4cdf1d9b", size = 12974331, upload-time = "2024-12-30T16:38:23.849Z" }, - { url = "https://files.pythonhosted.org/packages/84/5f/901e18464e6a13f8949b4909535be3fa7f823291b8ab4e4b36cfe57d6769/mypy-1.14.1-cp38-cp38-win_amd64.whl", hash = "sha256:8edc07eeade7ebc771ff9cf6b211b9a7d93687ff892150cb5692e4f4272b0837", size = 9763210, upload-time = "2024-12-30T16:38:36.299Z" }, - { url = "https://files.pythonhosted.org/packages/ca/1f/186d133ae2514633f8558e78cd658070ba686c0e9275c5a5c24a1e1f0d67/mypy-1.14.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3888a1816d69f7ab92092f785a462944b3ca16d7c470d564165fe703b0970c35", size = 11200493, upload-time = "2024-12-30T16:38:26.935Z" }, - { url = "https://files.pythonhosted.org/packages/af/fc/4842485d034e38a4646cccd1369f6b1ccd7bc86989c52770d75d719a9941/mypy-1.14.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46c756a444117c43ee984bd055db99e498bc613a70bbbc120272bd13ca579fbc", size = 10357702, upload-time = "2024-12-30T16:38:50.623Z" }, - { url = "https://files.pythonhosted.org/packages/b4/e6/457b83f2d701e23869cfec013a48a12638f75b9d37612a9ddf99072c1051/mypy-1.14.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27fc248022907e72abfd8e22ab1f10e903915ff69961174784a3900a8cba9ad9", size = 12091104, upload-time = "2024-12-30T16:38:53.735Z" }, - { url = "https://files.pythonhosted.org/packages/f1/bf/76a569158db678fee59f4fd30b8e7a0d75bcbaeef49edd882a0d63af6d66/mypy-1.14.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:499d6a72fb7e5de92218db961f1a66d5f11783f9ae549d214617edab5d4dbdbb", size = 12830167, upload-time = "2024-12-30T16:38:56.437Z" }, - { url = "https://files.pythonhosted.org/packages/43/bc/0bc6b694b3103de9fed61867f1c8bd33336b913d16831431e7cb48ef1c92/mypy-1.14.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:57961db9795eb566dc1d1b4e9139ebc4c6b0cb6e7254ecde69d1552bf7613f60", size = 13013834, upload-time = "2024-12-30T16:38:59.204Z" }, - { url = "https://files.pythonhosted.org/packages/b0/79/5f5ec47849b6df1e6943d5fd8e6632fbfc04b4fd4acfa5a5a9535d11b4e2/mypy-1.14.1-cp39-cp39-win_amd64.whl", hash = "sha256:07ba89fdcc9451f2ebb02853deb6aaaa3d2239a236669a63ab3801bbf923ef5c", size = 9781231, upload-time = "2024-12-30T16:39:05.124Z" }, - { url = "https://files.pythonhosted.org/packages/a0/b5/32dd67b69a16d088e533962e5044e51004176a9952419de0370cdaead0f8/mypy-1.14.1-py3-none-any.whl", hash = "sha256:b66a60cc4073aeb8ae00057f9c1f64d49e90f918fbcef9a977eb121da8b8f1d1", size = 2752905, upload-time = "2024-12-30T16:38:42.021Z" }, + { url = "https://files.pythonhosted.org/packages/33/52/f30da112c1dc92cf64f57d08a273ac771e7b29dea10b4b30369b2d7e8546/msgpack-1.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:353b6fc0c36fde68b661a12949d7d49f8f51ff5fa019c1e47c87c4ff34b080ed", size = 81799, upload-time = "2025-06-13T06:51:37.228Z" }, + { url = "https://files.pythonhosted.org/packages/e4/35/7bfc0def2f04ab4145f7f108e3563f9b4abae4ab0ed78a61f350518cc4d2/msgpack-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:79c408fcf76a958491b4e3b103d1c417044544b68e96d06432a189b43d1215c8", size = 78278, upload-time = "2025-06-13T06:51:38.534Z" }, + { url = "https://files.pythonhosted.org/packages/e8/c5/df5d6c1c39856bc55f800bf82778fd4c11370667f9b9e9d51b2f5da88f20/msgpack-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78426096939c2c7482bf31ef15ca219a9e24460289c00dd0b94411040bb73ad2", size = 402805, upload-time = "2025-06-13T06:51:39.538Z" }, + { url = "https://files.pythonhosted.org/packages/20/8e/0bb8c977efecfe6ea7116e2ed73a78a8d32a947f94d272586cf02a9757db/msgpack-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b17ba27727a36cb73aabacaa44b13090feb88a01d012c0f4be70c00f75048b4", size = 408642, upload-time = "2025-06-13T06:51:41.092Z" }, + { url = "https://files.pythonhosted.org/packages/59/a1/731d52c1aeec52006be6d1f8027c49fdc2cfc3ab7cbe7c28335b2910d7b6/msgpack-1.1.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7a17ac1ea6ec3c7687d70201cfda3b1e8061466f28f686c24f627cae4ea8efd0", size = 395143, upload-time = "2025-06-13T06:51:42.575Z" }, + { url = "https://files.pythonhosted.org/packages/2b/92/b42911c52cda2ba67a6418ffa7d08969edf2e760b09015593c8a8a27a97d/msgpack-1.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:88d1e966c9235c1d4e2afac21ca83933ba59537e2e2727a999bf3f515ca2af26", size = 395986, upload-time = "2025-06-13T06:51:43.807Z" }, + { url = "https://files.pythonhosted.org/packages/61/dc/8ae165337e70118d4dab651b8b562dd5066dd1e6dd57b038f32ebc3e2f07/msgpack-1.1.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f6d58656842e1b2ddbe07f43f56b10a60f2ba5826164910968f5933e5178af75", size = 402682, upload-time = "2025-06-13T06:51:45.534Z" }, + { url = "https://files.pythonhosted.org/packages/58/27/555851cb98dcbd6ce041df1eacb25ac30646575e9cd125681aa2f4b1b6f1/msgpack-1.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:96decdfc4adcbc087f5ea7ebdcfd3dee9a13358cae6e81d54be962efc38f6338", size = 406368, upload-time = "2025-06-13T06:51:46.97Z" }, + { url = "https://files.pythonhosted.org/packages/d4/64/39a26add4ce16f24e99eabb9005e44c663db00e3fce17d4ae1ae9d61df99/msgpack-1.1.1-cp310-cp310-win32.whl", hash = "sha256:6640fd979ca9a212e4bcdf6eb74051ade2c690b862b679bfcb60ae46e6dc4bfd", size = 65004, upload-time = "2025-06-13T06:51:48.582Z" }, + { url = "https://files.pythonhosted.org/packages/7d/18/73dfa3e9d5d7450d39debde5b0d848139f7de23bd637a4506e36c9800fd6/msgpack-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:8b65b53204fe1bd037c40c4148d00ef918eb2108d24c9aaa20bc31f9810ce0a8", size = 71548, upload-time = "2025-06-13T06:51:49.558Z" }, + { url = "https://files.pythonhosted.org/packages/7f/83/97f24bf9848af23fe2ba04380388216defc49a8af6da0c28cc636d722502/msgpack-1.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:71ef05c1726884e44f8b1d1773604ab5d4d17729d8491403a705e649116c9558", size = 82728, upload-time = "2025-06-13T06:51:50.68Z" }, + { url = "https://files.pythonhosted.org/packages/aa/7f/2eaa388267a78401f6e182662b08a588ef4f3de6f0eab1ec09736a7aaa2b/msgpack-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:36043272c6aede309d29d56851f8841ba907a1a3d04435e43e8a19928e243c1d", size = 79279, upload-time = "2025-06-13T06:51:51.72Z" }, + { url = "https://files.pythonhosted.org/packages/f8/46/31eb60f4452c96161e4dfd26dbca562b4ec68c72e4ad07d9566d7ea35e8a/msgpack-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a32747b1b39c3ac27d0670122b57e6e57f28eefb725e0b625618d1b59bf9d1e0", size = 423859, upload-time = "2025-06-13T06:51:52.749Z" }, + { url = "https://files.pythonhosted.org/packages/45/16/a20fa8c32825cc7ae8457fab45670c7a8996d7746ce80ce41cc51e3b2bd7/msgpack-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a8b10fdb84a43e50d38057b06901ec9da52baac6983d3f709d8507f3889d43f", size = 429975, upload-time = "2025-06-13T06:51:53.97Z" }, + { url = "https://files.pythonhosted.org/packages/86/ea/6c958e07692367feeb1a1594d35e22b62f7f476f3c568b002a5ea09d443d/msgpack-1.1.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba0c325c3f485dc54ec298d8b024e134acf07c10d494ffa24373bea729acf704", size = 413528, upload-time = "2025-06-13T06:51:55.507Z" }, + { url = "https://files.pythonhosted.org/packages/75/05/ac84063c5dae79722bda9f68b878dc31fc3059adb8633c79f1e82c2cd946/msgpack-1.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:88daaf7d146e48ec71212ce21109b66e06a98e5e44dca47d853cbfe171d6c8d2", size = 413338, upload-time = "2025-06-13T06:51:57.023Z" }, + { url = "https://files.pythonhosted.org/packages/69/e8/fe86b082c781d3e1c09ca0f4dacd457ede60a13119b6ce939efe2ea77b76/msgpack-1.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d8b55ea20dc59b181d3f47103f113e6f28a5e1c89fd5b67b9140edb442ab67f2", size = 422658, upload-time = "2025-06-13T06:51:58.419Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2b/bafc9924df52d8f3bb7c00d24e57be477f4d0f967c0a31ef5e2225e035c7/msgpack-1.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4a28e8072ae9779f20427af07f53bbb8b4aa81151054e882aee333b158da8752", size = 427124, upload-time = "2025-06-13T06:51:59.969Z" }, + { url = "https://files.pythonhosted.org/packages/a2/3b/1f717e17e53e0ed0b68fa59e9188f3f610c79d7151f0e52ff3cd8eb6b2dc/msgpack-1.1.1-cp311-cp311-win32.whl", hash = "sha256:7da8831f9a0fdb526621ba09a281fadc58ea12701bc709e7b8cbc362feabc295", size = 65016, upload-time = "2025-06-13T06:52:01.294Z" }, + { url = "https://files.pythonhosted.org/packages/48/45/9d1780768d3b249accecc5a38c725eb1e203d44a191f7b7ff1941f7df60c/msgpack-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:5fd1b58e1431008a57247d6e7cc4faa41c3607e8e7d4aaf81f7c29ea013cb458", size = 72267, upload-time = "2025-06-13T06:52:02.568Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/389b9c593eda2b8551b2e7126ad3a06af6f9b44274eb3a4f054d48ff7e47/msgpack-1.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ae497b11f4c21558d95de9f64fff7053544f4d1a17731c866143ed6bb4591238", size = 82359, upload-time = "2025-06-13T06:52:03.909Z" }, + { url = "https://files.pythonhosted.org/packages/ab/65/7d1de38c8a22cf8b1551469159d4b6cf49be2126adc2482de50976084d78/msgpack-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:33be9ab121df9b6b461ff91baac6f2731f83d9b27ed948c5b9d1978ae28bf157", size = 79172, upload-time = "2025-06-13T06:52:05.246Z" }, + { url = "https://files.pythonhosted.org/packages/0f/bd/cacf208b64d9577a62c74b677e1ada005caa9b69a05a599889d6fc2ab20a/msgpack-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f64ae8fe7ffba251fecb8408540c34ee9df1c26674c50c4544d72dbf792e5ce", size = 425013, upload-time = "2025-06-13T06:52:06.341Z" }, + { url = "https://files.pythonhosted.org/packages/4d/ec/fd869e2567cc9c01278a736cfd1697941ba0d4b81a43e0aa2e8d71dab208/msgpack-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a494554874691720ba5891c9b0b39474ba43ffb1aaf32a5dac874effb1619e1a", size = 426905, upload-time = "2025-06-13T06:52:07.501Z" }, + { url = "https://files.pythonhosted.org/packages/55/2a/35860f33229075bce803a5593d046d8b489d7ba2fc85701e714fc1aaf898/msgpack-1.1.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cb643284ab0ed26f6957d969fe0dd8bb17beb567beb8998140b5e38a90974f6c", size = 407336, upload-time = "2025-06-13T06:52:09.047Z" }, + { url = "https://files.pythonhosted.org/packages/8c/16/69ed8f3ada150bf92745fb4921bd621fd2cdf5a42e25eb50bcc57a5328f0/msgpack-1.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d275a9e3c81b1093c060c3837e580c37f47c51eca031f7b5fb76f7b8470f5f9b", size = 409485, upload-time = "2025-06-13T06:52:10.382Z" }, + { url = "https://files.pythonhosted.org/packages/c6/b6/0c398039e4c6d0b2e37c61d7e0e9d13439f91f780686deb8ee64ecf1ae71/msgpack-1.1.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4fd6b577e4541676e0cc9ddc1709d25014d3ad9a66caa19962c4f5de30fc09ef", size = 412182, upload-time = "2025-06-13T06:52:11.644Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d0/0cf4a6ecb9bc960d624c93effaeaae75cbf00b3bc4a54f35c8507273cda1/msgpack-1.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb29aaa613c0a1c40d1af111abf025f1732cab333f96f285d6a93b934738a68a", size = 419883, upload-time = "2025-06-13T06:52:12.806Z" }, + { url = "https://files.pythonhosted.org/packages/62/83/9697c211720fa71a2dfb632cad6196a8af3abea56eece220fde4674dc44b/msgpack-1.1.1-cp312-cp312-win32.whl", hash = "sha256:870b9a626280c86cff9c576ec0d9cbcc54a1e5ebda9cd26dab12baf41fee218c", size = 65406, upload-time = "2025-06-13T06:52:14.271Z" }, + { url = "https://files.pythonhosted.org/packages/c0/23/0abb886e80eab08f5e8c485d6f13924028602829f63b8f5fa25a06636628/msgpack-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:5692095123007180dca3e788bb4c399cc26626da51629a31d40207cb262e67f4", size = 72558, upload-time = "2025-06-13T06:52:15.252Z" }, + { url = "https://files.pythonhosted.org/packages/a1/38/561f01cf3577430b59b340b51329803d3a5bf6a45864a55f4ef308ac11e3/msgpack-1.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3765afa6bd4832fc11c3749be4ba4b69a0e8d7b728f78e68120a157a4c5d41f0", size = 81677, upload-time = "2025-06-13T06:52:16.64Z" }, + { url = "https://files.pythonhosted.org/packages/09/48/54a89579ea36b6ae0ee001cba8c61f776451fad3c9306cd80f5b5c55be87/msgpack-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8ddb2bcfd1a8b9e431c8d6f4f7db0773084e107730ecf3472f1dfe9ad583f3d9", size = 78603, upload-time = "2025-06-13T06:52:17.843Z" }, + { url = "https://files.pythonhosted.org/packages/a0/60/daba2699b308e95ae792cdc2ef092a38eb5ee422f9d2fbd4101526d8a210/msgpack-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:196a736f0526a03653d829d7d4c5500a97eea3648aebfd4b6743875f28aa2af8", size = 420504, upload-time = "2025-06-13T06:52:18.982Z" }, + { url = "https://files.pythonhosted.org/packages/20/22/2ebae7ae43cd8f2debc35c631172ddf14e2a87ffcc04cf43ff9df9fff0d3/msgpack-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d592d06e3cc2f537ceeeb23d38799c6ad83255289bb84c2e5792e5a8dea268a", size = 423749, upload-time = "2025-06-13T06:52:20.211Z" }, + { url = "https://files.pythonhosted.org/packages/40/1b/54c08dd5452427e1179a40b4b607e37e2664bca1c790c60c442c8e972e47/msgpack-1.1.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4df2311b0ce24f06ba253fda361f938dfecd7b961576f9be3f3fbd60e87130ac", size = 404458, upload-time = "2025-06-13T06:52:21.429Z" }, + { url = "https://files.pythonhosted.org/packages/2e/60/6bb17e9ffb080616a51f09928fdd5cac1353c9becc6c4a8abd4e57269a16/msgpack-1.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e4141c5a32b5e37905b5940aacbc59739f036930367d7acce7a64e4dec1f5e0b", size = 405976, upload-time = "2025-06-13T06:52:22.995Z" }, + { url = "https://files.pythonhosted.org/packages/ee/97/88983e266572e8707c1f4b99c8fd04f9eb97b43f2db40e3172d87d8642db/msgpack-1.1.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b1ce7f41670c5a69e1389420436f41385b1aa2504c3b0c30620764b15dded2e7", size = 408607, upload-time = "2025-06-13T06:52:24.152Z" }, + { url = "https://files.pythonhosted.org/packages/bc/66/36c78af2efaffcc15a5a61ae0df53a1d025f2680122e2a9eb8442fed3ae4/msgpack-1.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4147151acabb9caed4e474c3344181e91ff7a388b888f1e19ea04f7e73dc7ad5", size = 424172, upload-time = "2025-06-13T06:52:25.704Z" }, + { url = "https://files.pythonhosted.org/packages/8c/87/a75eb622b555708fe0427fab96056d39d4c9892b0c784b3a721088c7ee37/msgpack-1.1.1-cp313-cp313-win32.whl", hash = "sha256:500e85823a27d6d9bba1d057c871b4210c1dd6fb01fbb764e37e4e8847376323", size = 65347, upload-time = "2025-06-13T06:52:26.846Z" }, + { url = "https://files.pythonhosted.org/packages/ca/91/7dc28d5e2a11a5ad804cf2b7f7a5fcb1eb5a4966d66a5d2b41aee6376543/msgpack-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:6d489fba546295983abd142812bda76b57e33d0b9f5d5b71c09a583285506f69", size = 72341, upload-time = "2025-06-13T06:52:27.835Z" }, + { url = "https://files.pythonhosted.org/packages/bd/74/b0fcaec0cea3f104c61c646f49571864f12321de7b8705e98a32d29ba2ad/msgpack-1.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bba1be28247e68994355e028dcd668316db30c1f758d3241a7b903ac78dcd285", size = 409181, upload-time = "2025-06-13T06:52:28.835Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a4/257806f574f8b4bfb76d428b2406cf4585d9f9b582887a0f466278bf0e2a/msgpack-1.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8f93dcddb243159c9e4109c9750ba5b335ab8d48d9522c5308cd05d7e3ce600", size = 413772, upload-time = "2025-06-13T06:52:29.997Z" }, + { url = "https://files.pythonhosted.org/packages/96/17/46438f4848e86e2f481d46bd3f8b0b0405243b4125bac28ce86dc01e3aeb/msgpack-1.1.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2fbbc0b906a24038c9958a1ba7ae0918ad35b06cb449d398b76a7d08470b0ed9", size = 402772, upload-time = "2025-06-13T06:52:31.195Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/0ba95da893ddffb09975b4e81fd7b7e612aace0a42ce0d9bdd1a7d802cfe/msgpack-1.1.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:61e35a55a546a1690d9d09effaa436c25ae6130573b6ee9829c37ef0f18d5e78", size = 404650, upload-time = "2025-06-13T06:52:32.638Z" }, + { url = "https://files.pythonhosted.org/packages/85/d2/c849832b0c0bfb241efc830ccbe7fb880274bbdbc4780798b835f2cd7b3b/msgpack-1.1.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:1abfc6e949b352dadf4bce0eb78023212ec5ac42f6abfd469ce91d783c149c2a", size = 413595, upload-time = "2025-06-13T06:52:33.882Z" }, + { url = "https://files.pythonhosted.org/packages/03/79/ea7cda493ec78afb9bd4c88e3c8bf5bffabca78d1917d8b24cddd0b9f5ee/msgpack-1.1.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:996f2609ddf0142daba4cefd767d6db26958aac8439ee41db9cc0db9f4c4c3a6", size = 412830, upload-time = "2025-06-13T06:52:35.431Z" }, + { url = "https://files.pythonhosted.org/packages/e3/80/644311ca3064cfc9a9ecf64074e905e5359da730faefc88c6cfbbaf110ee/msgpack-1.1.1-cp38-cp38-win32.whl", hash = "sha256:4d3237b224b930d58e9d83c81c0dba7aacc20fcc2f89c1e5423aa0529a4cd142", size = 65439, upload-time = "2025-06-13T06:52:36.976Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ec/27d4740fdeea71a7d559b405614b5d9b866028768a949e8dd58abed8474f/msgpack-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:da8f41e602574ece93dbbda1fab24650d6bf2a24089f9e9dbb4f5730ec1e58ad", size = 72234, upload-time = "2025-06-13T06:52:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/1f/bd/0792be119d7fe7dc2148689ef65c90507d82d20a204aab3b98c74a1f8684/msgpack-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f5be6b6bc52fad84d010cb45433720327ce886009d862f46b26d4d154001994b", size = 81882, upload-time = "2025-06-13T06:52:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/75/77/ce06c8e26a816ae8730a8e030d263c5289adcaff9f0476f9b270bdd7c5c2/msgpack-1.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3a89cd8c087ea67e64844287ea52888239cbd2940884eafd2dcd25754fb72232", size = 78414, upload-time = "2025-06-13T06:52:40.341Z" }, + { url = "https://files.pythonhosted.org/packages/73/27/190576c497677fb4a0d05d896b24aea6cdccd910f206aaa7b511901befed/msgpack-1.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d75f3807a9900a7d575d8d6674a3a47e9f227e8716256f35bc6f03fc597ffbf", size = 400927, upload-time = "2025-06-13T06:52:41.399Z" }, + { url = "https://files.pythonhosted.org/packages/ed/af/6a0aa5a06762e70726ec3c10fb966600d84a7220b52635cb0ab2dc64d32f/msgpack-1.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d182dac0221eb8faef2e6f44701812b467c02674a322c739355c39e94730cdbf", size = 405903, upload-time = "2025-06-13T06:52:42.699Z" }, + { url = "https://files.pythonhosted.org/packages/1e/80/3f3da358cecbbe8eb12360814bd1277d59d2608485934742a074d99894a9/msgpack-1.1.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1b13fe0fb4aac1aa5320cd693b297fe6fdef0e7bea5518cbc2dd5299f873ae90", size = 393192, upload-time = "2025-06-13T06:52:43.986Z" }, + { url = "https://files.pythonhosted.org/packages/98/c6/3a0ec7fdebbb4f3f8f254696cd91d491c29c501dbebd86286c17e8f68cd7/msgpack-1.1.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:435807eeb1bc791ceb3247d13c79868deb22184e1fc4224808750f0d7d1affc1", size = 393851, upload-time = "2025-06-13T06:52:45.177Z" }, + { url = "https://files.pythonhosted.org/packages/39/37/df50d5f8e68514b60fbe70f6e8337ea2b32ae2be030871bcd9d1cf7d4b62/msgpack-1.1.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:4835d17af722609a45e16037bb1d4d78b7bdf19d6c0128116d178956618c4e88", size = 400292, upload-time = "2025-06-13T06:52:46.381Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ec/1e067292e02d2ceb4c8cb5ba222c4f7bb28730eef5676740609dc2627e0f/msgpack-1.1.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a8ef6e342c137888ebbfb233e02b8fbd689bb5b5fcc59b34711ac47ebd504478", size = 401873, upload-time = "2025-06-13T06:52:47.957Z" }, + { url = "https://files.pythonhosted.org/packages/d3/31/e8c9c6b5b58d64c9efa99c8d181fcc25f38ead357b0360379fbc8a4234ad/msgpack-1.1.1-cp39-cp39-win32.whl", hash = "sha256:61abccf9de335d9efd149e2fff97ed5974f2481b3353772e8e2dd3402ba2bd57", size = 65028, upload-time = "2025-06-13T06:52:49.166Z" }, + { url = "https://files.pythonhosted.org/packages/20/d6/cd62cded572e5e25892747a5d27850170bcd03c855e9c69c538e024de6f9/msgpack-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:40eae974c873b2992fd36424a5d9407f93e97656d999f43fca9d29f820899084", size = 71700, upload-time = "2025-06-13T06:52:50.244Z" }, ] [[package]] -name = "mypy" -version = "1.19.1" +name = "msgpack" +version = "1.1.2" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version == '3.9.*'", ] -dependencies = [ - { name = "librt", marker = "python_full_version == '3.9.*' and platform_python_implementation != 'PyPy'" }, - { name = "mypy-extensions", marker = "python_full_version == '3.9.*'" }, - { name = "pathspec", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "tomli", marker = "python_full_version == '3.9.*'" }, - { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2f/63/e499890d8e39b1ff2df4c0c6ce5d371b6844ee22b8250687a99fd2f657a8/mypy-1.19.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5f05aa3d375b385734388e844bc01733bd33c644ab48e9684faa54e5389775ec", size = 13101333, upload-time = "2025-12-15T05:03:03.28Z" }, - { url = "https://files.pythonhosted.org/packages/72/4b/095626fc136fba96effc4fd4a82b41d688ab92124f8c4f7564bffe5cf1b0/mypy-1.19.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:022ea7279374af1a5d78dfcab853fe6a536eebfda4b59deab53cd21f6cd9f00b", size = 12164102, upload-time = "2025-12-15T05:02:33.611Z" }, - { url = "https://files.pythonhosted.org/packages/0c/5b/952928dd081bf88a83a5ccd49aaecfcd18fd0d2710c7ff07b8fb6f7032b9/mypy-1.19.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee4c11e460685c3e0c64a4c5de82ae143622410950d6be863303a1c4ba0e36d6", size = 12765799, upload-time = "2025-12-15T05:03:28.44Z" }, - { url = "https://files.pythonhosted.org/packages/2a/0d/93c2e4a287f74ef11a66fb6d49c7a9f05e47b0a4399040e6719b57f500d2/mypy-1.19.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de759aafbae8763283b2ee5869c7255391fbc4de3ff171f8f030b5ec48381b74", size = 13522149, upload-time = "2025-12-15T05:02:36.011Z" }, - { url = "https://files.pythonhosted.org/packages/7b/0e/33a294b56aaad2b338d203e3a1d8b453637ac36cb278b45005e0901cf148/mypy-1.19.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ab43590f9cd5108f41aacf9fca31841142c786827a74ab7cc8a2eacb634e09a1", size = 13810105, upload-time = "2025-12-15T05:02:40.327Z" }, - { url = "https://files.pythonhosted.org/packages/0e/fd/3e82603a0cb66b67c5e7abababce6bf1a929ddf67bf445e652684af5c5a0/mypy-1.19.1-cp310-cp310-win_amd64.whl", hash = "sha256:2899753e2f61e571b3971747e302d5f420c3fd09650e1951e99f823bc3089dac", size = 10057200, upload-time = "2025-12-15T05:02:51.012Z" }, - { url = "https://files.pythonhosted.org/packages/ef/47/6b3ebabd5474d9cdc170d1342fbf9dddc1b0ec13ec90bf9004ee6f391c31/mypy-1.19.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d8dfc6ab58ca7dda47d9237349157500468e404b17213d44fc1cb77bce532288", size = 13028539, upload-time = "2025-12-15T05:03:44.129Z" }, - { url = "https://files.pythonhosted.org/packages/5c/a6/ac7c7a88a3c9c54334f53a941b765e6ec6c4ebd65d3fe8cdcfbe0d0fd7db/mypy-1.19.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e3f276d8493c3c97930e354b2595a44a21348b320d859fb4a2b9f66da9ed27ab", size = 12083163, upload-time = "2025-12-15T05:03:37.679Z" }, - { url = "https://files.pythonhosted.org/packages/67/af/3afa9cf880aa4a2c803798ac24f1d11ef72a0c8079689fac5cfd815e2830/mypy-1.19.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2abb24cf3f17864770d18d673c85235ba52456b36a06b6afc1e07c1fdcd3d0e6", size = 12687629, upload-time = "2025-12-15T05:02:31.526Z" }, - { url = "https://files.pythonhosted.org/packages/2d/46/20f8a7114a56484ab268b0ab372461cb3a8f7deed31ea96b83a4e4cfcfca/mypy-1.19.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a009ffa5a621762d0c926a078c2d639104becab69e79538a494bcccb62cc0331", size = 13436933, upload-time = "2025-12-15T05:03:15.606Z" }, - { url = "https://files.pythonhosted.org/packages/5b/f8/33b291ea85050a21f15da910002460f1f445f8007adb29230f0adea279cb/mypy-1.19.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f7cee03c9a2e2ee26ec07479f38ea9c884e301d42c6d43a19d20fb014e3ba925", size = 13661754, upload-time = "2025-12-15T05:02:26.731Z" }, - { url = "https://files.pythonhosted.org/packages/fd/a3/47cbd4e85bec4335a9cd80cf67dbc02be21b5d4c9c23ad6b95d6c5196bac/mypy-1.19.1-cp311-cp311-win_amd64.whl", hash = "sha256:4b84a7a18f41e167f7995200a1d07a4a6810e89d29859df936f1c3923d263042", size = 10055772, upload-time = "2025-12-15T05:03:26.179Z" }, - { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" }, - { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" }, - { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" }, - { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" }, - { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" }, - { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" }, - { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" }, - { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" }, - { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" }, - { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" }, - { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" }, - { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" }, - { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" }, - { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" }, - { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" }, - { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" }, - { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" }, - { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" }, - { url = "https://files.pythonhosted.org/packages/b5/f7/88436084550ca9af5e610fa45286be04c3b63374df3e021c762fe8c4369f/mypy-1.19.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7bcfc336a03a1aaa26dfce9fff3e287a3ba99872a157561cbfcebe67c13308e3", size = 13102606, upload-time = "2025-12-15T05:02:46.833Z" }, - { url = "https://files.pythonhosted.org/packages/ca/a5/43dfad311a734b48a752790571fd9e12d61893849a01bff346a54011957f/mypy-1.19.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b7951a701c07ea584c4fe327834b92a30825514c868b1f69c30445093fdd9d5a", size = 12164496, upload-time = "2025-12-15T05:03:41.947Z" }, - { url = "https://files.pythonhosted.org/packages/88/f0/efbfa391395cce2f2771f937e0620cfd185ec88f2b9cd88711028a768e96/mypy-1.19.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b13cfdd6c87fc3efb69ea4ec18ef79c74c3f98b4e5498ca9b85ab3b2c2329a67", size = 12772068, upload-time = "2025-12-15T05:02:53.689Z" }, - { url = "https://files.pythonhosted.org/packages/25/05/58b3ba28f5aed10479e899a12d2120d582ba9fa6288851b20bf1c32cbb4f/mypy-1.19.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f28f99c824ecebcdaa2e55d82953e38ff60ee5ec938476796636b86afa3956e", size = 13520385, upload-time = "2025-12-15T05:02:38.328Z" }, - { url = "https://files.pythonhosted.org/packages/c5/a0/c006ccaff50b31e542ae69b92fe7e2f55d99fba3a55e01067dd564325f85/mypy-1.19.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c608937067d2fc5a4dd1a5ce92fd9e1398691b8c5d012d66e1ddd430e9244376", size = 13796221, upload-time = "2025-12-15T05:03:22.147Z" }, - { url = "https://files.pythonhosted.org/packages/b2/ff/8bdb051cd710f01b880472241bd36b3f817a8e1c5d5540d0b761675b6de2/mypy-1.19.1-cp39-cp39-win_amd64.whl", hash = "sha256:409088884802d511ee52ca067707b90c883426bd95514e8cfda8281dc2effe24", size = 10055456, upload-time = "2025-12-15T05:03:35.169Z" }, - { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" }, + { url = "https://files.pythonhosted.org/packages/f5/a2/3b68a9e769db68668b25c6108444a35f9bd163bb848c0650d516761a59c0/msgpack-1.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0051fffef5a37ca2cd16978ae4f0aef92f164df86823871b5162812bebecd8e2", size = 81318, upload-time = "2025-10-08T09:14:38.722Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e1/2b720cc341325c00be44e1ed59e7cfeae2678329fbf5aa68f5bda57fe728/msgpack-1.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a605409040f2da88676e9c9e5853b3449ba8011973616189ea5ee55ddbc5bc87", size = 83786, upload-time = "2025-10-08T09:14:40.082Z" }, + { url = "https://files.pythonhosted.org/packages/71/e5/c2241de64bfceac456b140737812a2ab310b10538a7b34a1d393b748e095/msgpack-1.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b696e83c9f1532b4af884045ba7f3aa741a63b2bc22617293a2c6a7c645f251", size = 398240, upload-time = "2025-10-08T09:14:41.151Z" }, + { url = "https://files.pythonhosted.org/packages/b7/09/2a06956383c0fdebaef5aa9246e2356776f12ea6f2a44bd1368abf0e46c4/msgpack-1.1.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:365c0bbe981a27d8932da71af63ef86acc59ed5c01ad929e09a0b88c6294e28a", size = 406070, upload-time = "2025-10-08T09:14:42.821Z" }, + { url = "https://files.pythonhosted.org/packages/0e/74/2957703f0e1ef20637d6aead4fbb314330c26f39aa046b348c7edcf6ca6b/msgpack-1.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:41d1a5d875680166d3ac5c38573896453bbbea7092936d2e107214daf43b1d4f", size = 393403, upload-time = "2025-10-08T09:14:44.38Z" }, + { url = "https://files.pythonhosted.org/packages/a5/09/3bfc12aa90f77b37322fc33e7a8a7c29ba7c8edeadfa27664451801b9860/msgpack-1.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:354e81bcdebaab427c3df4281187edc765d5d76bfb3a7c125af9da7a27e8458f", size = 398947, upload-time = "2025-10-08T09:14:45.56Z" }, + { url = "https://files.pythonhosted.org/packages/4b/4f/05fcebd3b4977cb3d840f7ef6b77c51f8582086de5e642f3fefee35c86fc/msgpack-1.1.2-cp310-cp310-win32.whl", hash = "sha256:e64c8d2f5e5d5fda7b842f55dec6133260ea8f53c4257d64494c534f306bf7a9", size = 64769, upload-time = "2025-10-08T09:14:47.334Z" }, + { url = "https://files.pythonhosted.org/packages/d0/3e/b4547e3a34210956382eed1c85935fff7e0f9b98be3106b3745d7dec9c5e/msgpack-1.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:db6192777d943bdaaafb6ba66d44bf65aa0e9c5616fa1d2da9bb08828c6b39aa", size = 71293, upload-time = "2025-10-08T09:14:48.665Z" }, + { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" }, + { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" }, + { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" }, + { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" }, + { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" }, + { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" }, + { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" }, + { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" }, + { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" }, + { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" }, + { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" }, + { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" }, + { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" }, + { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" }, + { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" }, + { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" }, + { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" }, + { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" }, + { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" }, + { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" }, + { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" }, + { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" }, + { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" }, + { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" }, + { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" }, + { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" }, + { url = "https://files.pythonhosted.org/packages/46/73/85469b4aa71d25e5949fee50d3c2cf46f69cea619fe97cfe309058080f75/msgpack-1.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ea5405c46e690122a76531ab97a079e184c0daf491e588592d6a23d3e32af99e", size = 81529, upload-time = "2025-10-08T09:15:46.069Z" }, + { url = "https://files.pythonhosted.org/packages/6c/3a/7d4077e8ae720b29d2b299a9591969f0d105146960681ea6f4121e6d0f8d/msgpack-1.1.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9fba231af7a933400238cb357ecccf8ab5d51535ea95d94fc35b7806218ff844", size = 84106, upload-time = "2025-10-08T09:15:47.064Z" }, + { url = "https://files.pythonhosted.org/packages/df/c0/da451c74746ed9388dca1b4ec647c82945f4e2f8ce242c25fb7c0e12181f/msgpack-1.1.2-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a8f6e7d30253714751aa0b0c84ae28948e852ee7fb0524082e6716769124bc23", size = 396656, upload-time = "2025-10-08T09:15:48.118Z" }, + { url = "https://files.pythonhosted.org/packages/e5/a1/20486c29a31ec9f0f88377fdf7eb7a67f30bcb5e0f89b7550f6f16d9373b/msgpack-1.1.2-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94fd7dc7d8cb0a54432f296f2246bc39474e017204ca6f4ff345941d4ed285a7", size = 404722, upload-time = "2025-10-08T09:15:49.328Z" }, + { url = "https://files.pythonhosted.org/packages/ad/ae/e613b0a526d54ce85447d9665c2ff8c3210a784378d50573321d43d324b8/msgpack-1.1.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:350ad5353a467d9e3b126d8d1b90fe05ad081e2e1cef5753f8c345217c37e7b8", size = 391838, upload-time = "2025-10-08T09:15:50.517Z" }, + { url = "https://files.pythonhosted.org/packages/49/6a/07f3e10ed4503045b882ef7bf8512d01d8a9e25056950a977bd5f50df1c2/msgpack-1.1.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6bde749afe671dc44893f8d08e83bf475a1a14570d67c4bb5cec5573463c8833", size = 397516, upload-time = "2025-10-08T09:15:51.646Z" }, + { url = "https://files.pythonhosted.org/packages/76/9b/a86828e75986c12a3809c1e5062f5eba8e0cae3dfa2bf724ed2b1bb72b4c/msgpack-1.1.2-cp39-cp39-win32.whl", hash = "sha256:ad09b984828d6b7bb52d1d1d0c9be68ad781fa004ca39216c8a1e63c0f34ba3c", size = 64863, upload-time = "2025-10-08T09:15:53.118Z" }, + { url = "https://files.pythonhosted.org/packages/14/a7/b1992b4fb3da3b413f5fb78a63bad42f256c3be2352eb69273c3789c2c96/msgpack-1.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:67016ae8c8965124fdede9d3769528ad8284f14d635337ffa6a713a580f6c030", size = 71540, upload-time = "2025-10-08T09:15:55.573Z" }, ] [[package]] -name = "mypy" -version = "1.20.2" +name = "msgpack" +version = "1.2.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15'", @@ -957,67 +2026,378 @@ resolution-markers = [ "python_full_version == '3.11.*'", "python_full_version == '3.10.*'", ] -dependencies = [ - { name = "librt", marker = "python_full_version >= '3.10' and platform_python_implementation != 'PyPy'" }, - { name = "mypy-extensions", marker = "python_full_version >= '3.10'" }, - { name = "pathspec", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "tomli", marker = "python_full_version == '3.10.*'" }, - { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/04/af/e3d4b3e9ec91a0ff9aabfdb38692952acf49bbb899c2e4c29acb3a6da3ae/mypy-1.20.2.tar.gz", hash = "sha256:e8222c26daaafd9e8626dec58ae36029f82585890589576f769a650dd20fd665", size = 3817349, upload-time = "2026-04-21T17:12:28.473Z" } +sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", hash = "sha256:04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647", size = 183960, upload-time = "2026-06-18T16:13:52.594Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/97/ce2502df2cecf2ef997b6c6527c4a223b92feb9e7b790cdc8dcd683f3a8a/mypy-1.20.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cf5a4db6dca263010e2c7bff081c89383c72d187ba2cf4c44759aac970e2f0c4", size = 14457059, upload-time = "2026-04-21T17:06:14.935Z" }, - { url = "https://files.pythonhosted.org/packages/c9/34/417ee60b822cc80c0f3dc9f495ad7fd8dbb8d8b2cf4baf22d4046d25d01d/mypy-1.20.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7b0e817b518bff7facd7f85ea05b643ad8bdcce684cf29784987b0a7c8e1f997", size = 13346816, upload-time = "2026-04-21T17:10:41.433Z" }, - { url = "https://files.pythonhosted.org/packages/4a/85/e20951978702df58379d0bcc2e8f7ccdca4e78cd7dc66dd3ddbf9b29d517/mypy-1.20.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97d7b9a485b40f8ca425460e89bf1da2814625b2da627c0dcc6aa46c92631d14", size = 13772593, upload-time = "2026-04-21T17:08:11.24Z" }, - { url = "https://files.pythonhosted.org/packages/63/a5/5441a13259ec516c56fd5de0fd96a69a9590ae6c5e5d3e5174aa84b97973/mypy-1.20.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e1c12f6d2db3d78b909b5f77513c11eb7f2dd2782b96a3ab6dffc7d44575c99", size = 14656635, upload-time = "2026-04-21T17:09:54.042Z" }, - { url = "https://files.pythonhosted.org/packages/3b/51/b89c69157c5e1f19fd125a65d991166a26906e7902f026f00feebbcfa2b9/mypy-1.20.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:89dce27e142d25ffbc154c1819383b69f2e9234dc4ed4766f42e0e8cb264ab5c", size = 14943278, upload-time = "2026-04-21T17:09:15.599Z" }, - { url = "https://files.pythonhosted.org/packages/e9/44/6b0eeecfe96d7cce1d71c66b8e03cb304aa70ec11f1955dc1d6b46aca3c3/mypy-1.20.2-cp310-cp310-win_amd64.whl", hash = "sha256:f376e37f9bf2a946872fc5fd1199c99310748e3c26c7a26683f13f8bdb756cbd", size = 10851915, upload-time = "2026-04-21T17:06:03.5Z" }, - { url = "https://files.pythonhosted.org/packages/3c/36/6593dc88545d75fb96416184be5392da5e2a8e8c2802a8597913e16ae25c/mypy-1.20.2-cp310-cp310-win_arm64.whl", hash = "sha256:6e2b469efd811707bc530fd1effef0f5d6eebcb7fe376affae69025da4b979a2", size = 9786676, upload-time = "2026-04-21T17:07:02.035Z" }, - { url = "https://files.pythonhosted.org/packages/1f/4d/9ebeae211caccbdaddde7ed5e31dfcf57faac66be9b11deb1dc6526c8078/mypy-1.20.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4077797a273e56e8843d001e9dfe4ba10e33323d6ade647ff260e5cd97d9758c", size = 14371307, upload-time = "2026-04-21T17:08:56.442Z" }, - { url = "https://files.pythonhosted.org/packages/95/d7/93473d34b61f04fac1aecc01368485c89c5c4af7a4b9a0cab5d77d04b63f/mypy-1.20.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cdecf62abcc4292500d7858aeae87a1f8f1150f4c4dd08fb0b336ee79b2a6df3", size = 13258917, upload-time = "2026-04-21T17:05:50.978Z" }, - { url = "https://files.pythonhosted.org/packages/e2/30/3dd903e8bafb7b5f7bf87fcd58f8382086dea2aa19f0a7b357f21f63071b/mypy-1.20.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c566c3a88b6ece59b3d70f65bedef17304f48eb52ff040a6a18214e1917b3254", size = 13700516, upload-time = "2026-04-21T17:11:33.161Z" }, - { url = "https://files.pythonhosted.org/packages/07/05/c61a140aba4c729ac7bc99ae26fc627c78a6e08f5b9dd319244ea71a3d7e/mypy-1.20.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0deb80d062b2479f2c87ae568f89845afc71d11bc41b04179e58165fd9f31e98", size = 14562889, upload-time = "2026-04-21T17:05:27.674Z" }, - { url = "https://files.pythonhosted.org/packages/fd/87/da78243742ffa8a36d98c3010f0d829f93d5da4e6786f1a1a6f2ad616502/mypy-1.20.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bba9ad231e92a3e424b3e56b65aa17704993425bba97e302c832f9466bb85bac", size = 14803844, upload-time = "2026-04-21T17:10:06.2Z" }, - { url = "https://files.pythonhosted.org/packages/37/52/10a1ddf91b40f843943a3c6db51e2df59c9e237f29d355e95eaab427461f/mypy-1.20.2-cp311-cp311-win_amd64.whl", hash = "sha256:baf593f2765fa3a6b1ef95807dbaa3d25b594f6a52adcc506a6b9cb115e1be67", size = 10846300, upload-time = "2026-04-21T17:12:23.886Z" }, - { url = "https://files.pythonhosted.org/packages/20/02/f9a4415b664c53bd34d6709be59da303abcae986dc4ac847b402edb6fa1e/mypy-1.20.2-cp311-cp311-win_arm64.whl", hash = "sha256:20175a1c0f49863946ec20b7f63255768058ac4f07d2b9ded6a6b46cfb5a9100", size = 9779498, upload-time = "2026-04-21T17:09:23.695Z" }, - { url = "https://files.pythonhosted.org/packages/71/4e/7560e4528db9e9b147e4c0f22660466bf30a0a1fe3d63d1b9d3b0fd354ee/mypy-1.20.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4dbfcf869f6b0517f70cf0030ba6ea1d6645e132337a7d5204a18d8d5636c02b", size = 14539393, upload-time = "2026-04-21T17:07:12.52Z" }, - { url = "https://files.pythonhosted.org/packages/32/d9/34a5efed8124f5a9234f55ac6a4ced4201e2c5b81e1109c49ad23190ec8c/mypy-1.20.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b6481b228d072315b053210b01ac320e1be243dc17f9e5887ef167f23f5fae4", size = 13361642, upload-time = "2026-04-21T17:06:53.742Z" }, - { url = "https://files.pythonhosted.org/packages/d1/14/eb377acf78c03c92d566a1510cda8137348215b5335085ef662ab82ecd3a/mypy-1.20.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34397cdced6b90b836e38182076049fdb41424322e0b0728c946b0939ebdf9f6", size = 13740347, upload-time = "2026-04-21T17:12:04.73Z" }, - { url = "https://files.pythonhosted.org/packages/b9/94/7e4634a32b641aa1c112422eed1bbece61ee16205f674190e8b536f884de/mypy-1.20.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5da6976f20cae27059ea8d0c86e7cef3de720e04c4bb9ee18e3690fdb792066", size = 14734042, upload-time = "2026-04-21T17:07:43.16Z" }, - { url = "https://files.pythonhosted.org/packages/7a/f3/f7e62395cb7f434541b4491a01149a4439e28ace4c0c632bbf5431e92d1f/mypy-1.20.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:56908d7e08318d39f85b1f0c6cfd47b0cac1a130da677630dac0de3e0623e102", size = 14964958, upload-time = "2026-04-21T17:11:00.665Z" }, - { url = "https://files.pythonhosted.org/packages/3e/0d/47e3c3a0ec2a876e35aeac365df3cac7776c36bbd4ed18cc521e1b9d255b/mypy-1.20.2-cp312-cp312-win_amd64.whl", hash = "sha256:d52ad8d78522da1d308789df651ee5379088e77c76cb1994858d40a426b343b9", size = 10911340, upload-time = "2026-04-21T17:10:49.179Z" }, - { url = "https://files.pythonhosted.org/packages/d6/b2/6c852d72e0ea8b01f49da817fb52539993cde327e7d010e0103dc12d0dac/mypy-1.20.2-cp312-cp312-win_arm64.whl", hash = "sha256:785b08db19c9f214dc37d65f7c165d19a30fcecb48abfa30f31b01b5acaabb58", size = 9833947, upload-time = "2026-04-21T17:09:05.267Z" }, - { url = "https://files.pythonhosted.org/packages/5b/c4/b93812d3a192c9bcf5df405bd2f30277cd0e48106a14d1023c7f6ed6e39b/mypy-1.20.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:edfbfca868cdd6bd8d974a60f8a3682f5565d3f5c99b327640cedd24c4264026", size = 14524670, upload-time = "2026-04-21T17:10:30.737Z" }, - { url = "https://files.pythonhosted.org/packages/f3/47/42c122501bff18eaf1e8f457f5c017933452d8acdc52918a9f59f6812955/mypy-1.20.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e2877a02380adfcdbc69071a0f74d6e9dbbf593c0dc9d174e1f223ffd5281943", size = 13336218, upload-time = "2026-04-21T17:08:44.069Z" }, - { url = "https://files.pythonhosted.org/packages/92/8f/75bbc92f41725fbd585fb17b440b1119b576105df1013622983e18640a93/mypy-1.20.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7488448de6007cd5177c6cea0517ac33b4c0f5ee9b5e9f2be51ce75511a85517", size = 13724906, upload-time = "2026-04-21T17:08:01.02Z" }, - { url = "https://files.pythonhosted.org/packages/a1/32/4c49da27a606167391ff0c39aa955707a00edc500572e562f7c36c08a71f/mypy-1.20.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bb9c2fa06887e21d6a3a868762acb82aec34e2c6fd0174064f27c93ede68ad15", size = 14726046, upload-time = "2026-04-21T17:11:22.354Z" }, - { url = "https://files.pythonhosted.org/packages/7f/fc/4e354a1bd70216359deb0c9c54847ee6b32ef78dfb09f5131ff99b494078/mypy-1.20.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d56a78b646f2e3daa865bc70cd5ec5a46c50045801ca8ff17a0c43abc97e3ee", size = 14955587, upload-time = "2026-04-21T17:12:16.033Z" }, - { url = "https://files.pythonhosted.org/packages/62/b2/c0f2056e9eb8f08c62cafd9715e4584b89132bdc832fcf85d27d07b5f3e5/mypy-1.20.2-cp313-cp313-win_amd64.whl", hash = "sha256:2a4102b03bb7481d9a91a6da8d174740c9c8c4401024684b9ca3b7cc5e49852f", size = 10922681, upload-time = "2026-04-21T17:06:35.842Z" }, - { url = "https://files.pythonhosted.org/packages/e5/14/065e333721f05de8ef683d0aa804c23026bcc287446b61cac657b902ccac/mypy-1.20.2-cp313-cp313-win_arm64.whl", hash = "sha256:a95a9248b0c6fd933a442c03c3b113c3b61320086b88e2c444676d3fd1ca3330", size = 9830560, upload-time = "2026-04-21T17:07:51.023Z" }, - { url = "https://files.pythonhosted.org/packages/ae/d1/b4ec96b0ecc620a4443570c6e95c867903428cfcde4206518eafdd5880c3/mypy-1.20.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:419413398fe250aae057fd2fe50166b61077083c9b82754c341cf4fd73038f30", size = 14524561, upload-time = "2026-04-21T17:06:27.325Z" }, - { url = "https://files.pythonhosted.org/packages/3a/63/d2c2ff4fa66bc49477d32dfa26e8a167ba803ea6a69c5efb416036909d30/mypy-1.20.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e73c07f23009962885c197ccb9b41356a30cc0e5a1d0c2ea8fd8fb1362d7f924", size = 13363883, upload-time = "2026-04-21T17:11:11.239Z" }, - { url = "https://files.pythonhosted.org/packages/2a/56/983916806bf4eddeaaa2c9230903c3669c6718552a921154e1c5182c701f/mypy-1.20.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c64e5973df366b747646fc98da921f9d6eba9716d57d1db94a83c026a08e0fb", size = 13742945, upload-time = "2026-04-21T17:08:34.181Z" }, - { url = "https://files.pythonhosted.org/packages/19/65/0cd9285ab010ee8214c83d67c6b49417c40d86ce46f1aa109457b5a9b8d7/mypy-1.20.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a65aa591af023864fd08a97da9974e919452cfe19cb146c8a5dc692626445dc", size = 14706163, upload-time = "2026-04-21T17:05:15.51Z" }, - { url = "https://files.pythonhosted.org/packages/94/97/48ff3b297cafcc94d185243a9190836fb1b01c1b0918fff64e941e973cc9/mypy-1.20.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4fef51b01e638974a6e69885687e9bd40c8d1e09a6cd291cca0619625cf1f558", size = 14938677, upload-time = "2026-04-21T17:05:39.562Z" }, - { url = "https://files.pythonhosted.org/packages/fd/a1/1b4233d255bdd0b38a1f284feeb1c143ca508c19184964e22f8d837ec851/mypy-1.20.2-cp314-cp314-win_amd64.whl", hash = "sha256:913485a03f1bcf5d279409a9d2b9ed565c151f61c09f29991e5faa14033da4c8", size = 11089322, upload-time = "2026-04-21T17:06:44.29Z" }, - { url = "https://files.pythonhosted.org/packages/78/c2/ce7ee2ba36aeb954ba50f18fa25d9c1188578654b97d02a66a15b6f09531/mypy-1.20.2-cp314-cp314-win_arm64.whl", hash = "sha256:c3bae4f855d965b5453784300c12ffc63a548304ac7f99e55d4dc7c898673aa3", size = 10017775, upload-time = "2026-04-21T17:07:20.732Z" }, - { url = "https://files.pythonhosted.org/packages/4e/a1/9d93a7d0b5859af0ead82b4888b46df6c8797e1bc5e1e262a08518c6d48e/mypy-1.20.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2de3dcea53babc1c3237a19002bc3d228ce1833278f093b8d619e06e7cc79609", size = 15549002, upload-time = "2026-04-21T17:08:23.107Z" }, - { url = "https://files.pythonhosted.org/packages/00/d2/09a6a10ee1bf0008f6c144d9676f2ca6a12512151b4e0ad0ff6c4fac5337/mypy-1.20.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:52b176444e2e5054dfcbcb8c75b0b719865c96247b37407184bbfca5c353f2c2", size = 14401942, upload-time = "2026-04-21T17:07:31.837Z" }, - { url = "https://files.pythonhosted.org/packages/57/da/9594b75c3c019e805250bed3583bdf4443ff9e6ef08f97e39ae308cb06f2/mypy-1.20.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:688c3312e5dadb573a2c69c82af3a298d43ecf9e6d264e0f95df960b5f6ac19c", size = 15041649, upload-time = "2026-04-21T17:09:34.653Z" }, - { url = "https://files.pythonhosted.org/packages/97/77/f75a65c278e6e8eba2071f7f5a90481891053ecc39878cc444634d892abe/mypy-1.20.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29752dbbf8cc53f89f6ac096d363314333045c257c9c75cbd189ca2de0455744", size = 15864588, upload-time = "2026-04-21T17:11:44.936Z" }, - { url = "https://files.pythonhosted.org/packages/d7/46/1a4e1c66e96c1a3246ddf5403d122ac9b0a8d2b7e65730b9d6533ba7a6d3/mypy-1.20.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:803203d2b6ea644982c644895c2f78b28d0e208bba7b27d9b921e0ec5eb207c6", size = 16093956, upload-time = "2026-04-21T17:10:17.683Z" }, - { url = "https://files.pythonhosted.org/packages/5a/2c/78a8851264dec38cd736ca5b8bc9380674df0dd0be7792f538916157716c/mypy-1.20.2-cp314-cp314t-win_amd64.whl", hash = "sha256:9bcb8aa397ff0093c824182fd76a935a9ba7ad097fcbef80ae89bf6c1731d8ec", size = 12568661, upload-time = "2026-04-21T17:11:54.473Z" }, - { url = "https://files.pythonhosted.org/packages/83/01/cd7318aa03493322ce275a0e14f4f52b8896335e4e79d4fb8153a7ad2b77/mypy-1.20.2-cp314-cp314t-win_arm64.whl", hash = "sha256:e061b58443f1736f8a37c48978d7ab581636d6ab03e3d4f99e3fa90463bb9382", size = 10389240, upload-time = "2026-04-21T17:09:42.719Z" }, - { url = "https://files.pythonhosted.org/packages/28/9a/f23c163e25b11074188251b0b5a0342625fc1cdb6af604757174fa9acc9b/mypy-1.20.2-py3-none-any.whl", hash = "sha256:a94c5a76ab46c5e6257c7972b6c8cff0574201ca7dc05647e33e795d78680563", size = 2637314, upload-time = "2026-04-21T17:05:54.5Z" }, + { url = "https://files.pythonhosted.org/packages/5b/16/f70100614b69feb3ade7285f08c9c52d6cda0a5c03f3f5e2facd63acb211/msgpack-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8c7b398c56ff125feae96c2737abfec5595f1fa0aa186df60c56040b8accb95c", size = 82926, upload-time = "2026-06-18T16:12:31.531Z" }, + { url = "https://files.pythonhosted.org/packages/e4/3c/08ecd5cdfe4e2de43aec79062028ad0f7b2d9b1fea5430068c198ba570da/msgpack-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1548006a91aa93c5da81f3bdcebc1a0d10cea2d25969754fbe848da622b2b895", size = 82730, upload-time = "2026-06-18T16:12:32.894Z" }, + { url = "https://files.pythonhosted.org/packages/19/9f/a70c9cb1a04ecc134005149367dcfe35d167284e8f65035a1e4156ad17b5/msgpack-1.2.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1dabedcd0f23559f3596428c6589c1cd8c6eaed3a0d720795b07b0225d769203", size = 400729, upload-time = "2026-06-18T16:12:34.052Z" }, + { url = "https://files.pythonhosted.org/packages/fa/7f/5ce020168cf0439041526e95aa068c722c016aee21624e331aeabeee2e8e/msgpack-1.2.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:83efa1c898e0fc5380fc0cabbf75164c52e3b5cbb45973710d75821928380c73", size = 407625, upload-time = "2026-06-18T16:12:35.239Z" }, + { url = "https://files.pythonhosted.org/packages/79/70/fb7668ce0386819303047057aef6fc1da73b584291d9cff82b821744e2ef/msgpack-1.2.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01e2dd6c9b19d333a00282330cc8a73d38d8dabc306dc5b42cd668c3ac82e833", size = 377891, upload-time = "2026-06-18T16:12:36.684Z" }, + { url = "https://files.pythonhosted.org/packages/3d/dc/9ebe654a73c3aed2e40aa6b52e3c2a02b5f53ef0085fa235a45d5b367f87/msgpack-1.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:350cb813d0af6e65d2f7ef0d729f7ff5be5a8bce03665892f43e5883d4ecc1b8", size = 391987, upload-time = "2026-06-18T16:12:37.839Z" }, + { url = "https://files.pythonhosted.org/packages/42/eb/b67cf64218a2fa25e1c671fe1d3dbb06cbeb973e71bc4b822da079862d0b/msgpack-1.2.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:ee1d9ed27d0497b848923746cf762ed2e7db24f4be7eec8e5cbe8c766aa707b7", size = 374603, upload-time = "2026-06-18T16:12:39.221Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2e/9ee200cde32fd1a0101b4006202fde554c1860adfb9bf7bff31ea4c08df8/msgpack-1.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:633727297ed063441fd1cda2288865487f33ad14eeb8831afb5f0c396a62cfce", size = 405121, upload-time = "2026-06-18T16:12:40.524Z" }, + { url = "https://files.pythonhosted.org/packages/43/b6/f10117be7ca7a51e8feed699a907b8e663a8cd66e115ae6b4fb30cc7945c/msgpack-1.2.1-cp310-cp310-win32.whl", hash = "sha256:298872ecf9e61950f1c6af4ca969b859ee91783bb920ef6e6172697d0c8aad74", size = 64088, upload-time = "2026-06-18T16:12:41.762Z" }, + { url = "https://files.pythonhosted.org/packages/ba/93/89976c696fb0224662239d952c47b4d1661b34d79a332ef5584facaa8579/msgpack-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:2ff164c1b0bcb740b073b99e945234d0212852fa378e44a208c425379140dbeb", size = 70113, upload-time = "2026-06-18T16:12:42.78Z" }, + { url = "https://files.pythonhosted.org/packages/f4/6b/e9b1cdc042c4458801d2545ed782a95f3d6ba8e270cce8745b8603c7f748/msgpack-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:29a3f6e9667868429d8240dfd063ea5ffdc1321c13d783aa23827a38de0dcb22", size = 82812, upload-time = "2026-06-18T16:12:45.022Z" }, + { url = "https://files.pythonhosted.org/packages/0c/3a/dd518a1bf78ed1e9ad8afe57307c079a00eafe4b3068932a27ca1ea56b4f/msgpack-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aded5bdf32609dc7987a49bbbd15a8ef096193f96dd8bbeb791de729e650acf5", size = 82739, upload-time = "2026-06-18T16:12:46.025Z" }, + { url = "https://files.pythonhosted.org/packages/70/e0/7ba9e1542bf0771a27b8b37c1316e3f95ae9d748fd765284655c476ad4ef/msgpack-1.2.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:146ee4e9ce80b365c6d4c47073da9da7bcec473e58194ceee5dd7620ace77e06", size = 414233, upload-time = "2026-06-18T16:12:47.029Z" }, + { url = "https://files.pythonhosted.org/packages/03/8d/671d81534ea0e2b0e8a121be100020da09eb78861fe3aa8f3ef7dcd3bed1/msgpack-1.2.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a28d076ca7c82b9c8728ad90b7147489449557038bed50e4241eb832395169b4", size = 423843, upload-time = "2026-06-18T16:12:48.19Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b6/e5c737515ed1f166664b87601b532f58cbb73d8aa6a90b99f7c2c5037e8e/msgpack-1.2.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7d31c0ac0c640f877804c67cb2bc9f4e23dc2db97e96c2e67fa27d38283b41f8", size = 390772, upload-time = "2026-06-18T16:12:49.624Z" }, + { url = "https://files.pythonhosted.org/packages/a8/46/62ed8c2e87d7021eab19921594d961ef3aa3794eec76c716dc30f3bfd433/msgpack-1.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8ff92d7feeaf5bc26c51495b69e2f99ed97ab79346fb6555f44be7dd2ac6503b", size = 409559, upload-time = "2026-06-18T16:12:50.936Z" }, + { url = "https://files.pythonhosted.org/packages/70/ff/59aa3887b860bbf43532835e192b1c388a17590d6068ae4f8b2bc74c906e/msgpack-1.2.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:779197a6513bab3c3632265e3d0f7cb3227e62510841a6f34f1eaa37efbb345e", size = 387838, upload-time = "2026-06-18T16:12:52.161Z" }, + { url = "https://files.pythonhosted.org/packages/09/11/f8563e471093420cf6478cb3271a0175d8402b82d879783d4035d2d03360/msgpack-1.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:67f6dd22fa72a93752643f07889796d62739a13415ee630169a8ce764f86cf9f", size = 421732, upload-time = "2026-06-18T16:12:53.556Z" }, + { url = "https://files.pythonhosted.org/packages/57/cf/e673683c4c6c90c1022b24c65af4b03eda72b182a1176ef6449069d66acc/msgpack-1.2.1-cp311-cp311-win32.whl", hash = "sha256:91054a783328e0ea7954b8771095705c8d2243b814743fbaadf14552c9c52c5d", size = 64091, upload-time = "2026-06-18T16:12:54.821Z" }, + { url = "https://files.pythonhosted.org/packages/3f/07/ca212739d179f9083bff2c7c08c24101c3555a334fadc2b876b18768a3ae/msgpack-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2eda0b7ebb1283a98d3e4492ac933c8af6aff59fd3df1c3ed024f536af4b1dc8", size = 70462, upload-time = "2026-06-18T16:12:55.898Z" }, + { url = "https://files.pythonhosted.org/packages/6d/be/6798347b425e26f35db82e69dd83c09716c856a3714e7bffc4c0860fd830/msgpack-1.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:6ee967f7c7e1df2890c671ff2ee51a28ded0efc95da3e507176dee881ce36c66", size = 65059, upload-time = "2026-06-18T16:12:57.053Z" }, + { url = "https://files.pythonhosted.org/packages/bc/dd/9e8cbd8f5582ca4b590336f2b91ee5662f6a6ca562b565abaf696a0f81ff/msgpack-1.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2ef59c659f289eddf8aa6623823f19fa2f40a4029266889eac7a2505dd210c35", size = 83531, upload-time = "2026-06-18T16:12:58.249Z" }, + { url = "https://files.pythonhosted.org/packages/50/2e/ebdb85a8da151397a2790363676b7ed7c125924fe618e4c6d8befb0cc62c/msgpack-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3567748a5107cb40cdf66a275430c2f87c07777698f4bfd25c35f44d533258c", size = 82657, upload-time = "2026-06-18T16:12:59.396Z" }, + { url = "https://files.pythonhosted.org/packages/26/aa/753ad8b007b464e1d8aa0c8e650b9c5f4f725e658fc5ac8a7635c55b7f6e/msgpack-1.2.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60926b75d00c8e816ef98f3034f484a8bc64242d66839cef4cf7e503142316a0", size = 410634, upload-time = "2026-06-18T16:13:00.383Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/6adabd4f6d5e686f97dd02ce7fce3fe4cf672cbac36b8f67ff4040e8ad8b/msgpack-1.2.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:020e881a764b20d8d7ca1a54fc01b8175519d108e3c3f194fddc200bda95951a", size = 419989, upload-time = "2026-06-18T16:13:01.776Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cc/85039b7b0eb168aaad7383a23c97e291a11f08351cb45a606ce865e4e3f1/msgpack-1.2.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4202c74688ca06591f78cb18988228bd4cca2cc75d57b60008372892d2f1e6e6", size = 377544, upload-time = "2026-06-18T16:13:03.637Z" }, + { url = "https://files.pythonhosted.org/packages/ed/bf/35963899493b32030c85fc513b723ae66144ac70c11ebc52e889e16e3d99/msgpack-1.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8b267ce94efb76fbd1b3373511420074ee3187f0f7811bf394531de13294735a", size = 400842, upload-time = "2026-06-18T16:13:05.012Z" }, + { url = "https://files.pythonhosted.org/packages/a6/df/8e2ac970c8f99264cd9997d1c73df5466bc19da3301d7dc5500862a9b089/msgpack-1.2.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e4f1d0f8f98ade9634e01fb704a408f9336c0a8f1117b369f5db83dc7551d8b1", size = 374108, upload-time = "2026-06-18T16:13:06.232Z" }, + { url = "https://files.pythonhosted.org/packages/17/dd/fa8bd265110dfa51c20cb529f9e6d240a16fafe7e645004c6af2d01353ba/msgpack-1.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f02cf17a6ca1abe29b5f980644f7551f94d71f2011509b26d8625ce038f0df64", size = 414939, upload-time = "2026-06-18T16:13:07.478Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b9/8377a5ad8953fc0437c70cc98d9ae29f27fe5ac5109fbec0812085865735/msgpack-1.2.1-cp312-cp312-win32.whl", hash = "sha256:0c0d9802354507bcba62af19c17918e3eb437cc25e6f50657d511b5856a77aac", size = 64504, upload-time = "2026-06-18T16:13:08.822Z" }, + { url = "https://files.pythonhosted.org/packages/57/7f/ce1e377df7e62461fefd9eb23bfb93a4a523f40a517b377b8f844d836828/msgpack-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:5c24aa15d5963051e1a5c62b12c50cd705992502b5ec1f3bece6046f33c9fc24", size = 71421, upload-time = "2026-06-18T16:13:09.828Z" }, + { url = "https://files.pythonhosted.org/packages/8f/32/ebfe84c9929f08f188d56c7a2fd913406a9ddad76a634697c1c43b8112e6/msgpack-1.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:4227224aaec8f7fbcbfbd4272319347b2bb4030366502600f8c45588c5187b07", size = 64775, upload-time = "2026-06-18T16:13:11.056Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ac/dcddcab6f6c20ecb387ca5e980371cdb3f87ff69aeca388be97eebc4c074/msgpack-1.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0a70e3cf2804a300d921bb0940426e35f4e489a23adfb77a808892241db0a064", size = 83151, upload-time = "2026-06-18T16:13:12.173Z" }, + { url = "https://files.pythonhosted.org/packages/64/71/fbcfa83a1d6a9c6091942d1cfd070962244664b87427a9a49a6897b1b219/msgpack-1.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:491cc39455ca765fad51fb451bf2915eb2cf41192ab5801ce8d67c1d614fe056", size = 82351, upload-time = "2026-06-18T16:13:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/e3/10/ddf7b06db879e8792d13934ddda09ff20bd2a583fd84c9b59aae9b0e650b/msgpack-1.2.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f310233ef7fb9c14e201c93639fe5f5260b005f56f0b29048e999c30935596cc", size = 407518, upload-time = "2026-06-18T16:13:14.233Z" }, + { url = "https://files.pythonhosted.org/packages/79/d3/36a46a8ed992b781acbc05928bd5bee3c810cb0c3563bf81a7b0c04a1a76/msgpack-1.2.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:787c9bebb5833e8f6fc8abca3c0597683d8d87f56a8842b6b89c75a5f3176e2d", size = 416405, upload-time = "2026-06-18T16:13:15.435Z" }, + { url = "https://files.pythonhosted.org/packages/f9/84/e8e9598b557c0ba6ddae901a73780a4c75ac667dddf59414b1e56a42fb34/msgpack-1.2.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dc871b997a9370d855b7394465f2f350e847a5b806dd38dcc9c989e7d87da155", size = 376257, upload-time = "2026-06-18T16:13:17.022Z" }, + { url = "https://files.pythonhosted.org/packages/40/16/738fe6d875ad7e2a9429c165322a4ec088f4f273cdfae63d96a89c467961/msgpack-1.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:85f57e960d877f2977f6430896191b04a21f8901b3b4baf2e4604329f4db5402", size = 397469, upload-time = "2026-06-18T16:13:18.287Z" }, + { url = "https://files.pythonhosted.org/packages/ca/be/6d5952df75a7f24f35833af764c3a6860780364cb3a0030beb8099e1b2b4/msgpack-1.2.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:1233ee2dd0cefba127583de50ea654677277047d238303521db35def3d7b2e7c", size = 372802, upload-time = "2026-06-18T16:13:19.685Z" }, + { url = "https://files.pythonhosted.org/packages/e1/39/e2ef7dbf0473bcb8dc7c50bf782a892d67414877b63e47fc88eb189ef5e6/msgpack-1.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e3dc2feb0876209d9c38aa56cb1de169bd6c4348f1aa48271f241226590993e6", size = 411273, upload-time = "2026-06-18T16:13:21.028Z" }, + { url = "https://files.pythonhosted.org/packages/ef/c5/133f4512a56e983a93445c836c9d94d88f3bc2e0980ff4b9e577bd8416ce/msgpack-1.2.1-cp313-cp313-win32.whl", hash = "sha256:6d09badf350af2be9d189184e04e64cf54ad93569ab3d96fca58bd3e84aad707", size = 64471, upload-time = "2026-06-18T16:13:22.293Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/577e10b055096a7dd40732358cabaf7180a20c79ed1dcdbb618e4b9deac7/msgpack-1.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:33f14fba63278b714efe6ad07e50ea5f03d91537aa6a1c5f1ceca4cf44013ca9", size = 71274, upload-time = "2026-06-18T16:13:23.455Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ee/0c0048e7cfbef23c6a94791b8959ab28155232e7956de8a305b5ff588f05/msgpack-1.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:afc5febcd4c99effbc02b528e49d6fd0760b2b7d48c05239e345a5fa6e743d9a", size = 64795, upload-time = "2026-06-18T16:13:24.687Z" }, + { url = "https://files.pythonhosted.org/packages/77/58/cce442852c6b9e1639c7c8ac8fd9143121cb32dab0f308df4d1426a8eb9c/msgpack-1.2.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:05f340e47e7e47d2da8db9b53e1bb1d294369e9ef45a747441309f6650b8351d", size = 83610, upload-time = "2026-06-18T16:13:25.724Z" }, + { url = "https://files.pythonhosted.org/packages/60/5c/15b4c7a0182f75ffa90751958ba36a9c01cafee367d49a3edc10ed140b01/msgpack-1.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:810b916696c86ef0deb3b74588480224df4c1b071136c34183e4a2a4284d7ac7", size = 83138, upload-time = "2026-06-18T16:13:26.781Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a6/99e58722feaffc5f2fbcc0c8c0d1451ab9f84097f7af87291b46af2390f4/msgpack-1.2.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ca0dacff965c47afdc3749a8469d7302a8f801d6a28758d55120d75e66ce6889", size = 406090, upload-time = "2026-06-18T16:13:28.072Z" }, + { url = "https://files.pythonhosted.org/packages/19/03/8c63e8cf52958534ef688625965ab04c269a6cadd8caef16758b380a821a/msgpack-1.2.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e2bf9280bceb5efca998435904b5d3e9fdbcc11d90dc9df30aec7973252b720", size = 412106, upload-time = "2026-06-18T16:13:29.427Z" }, + { url = "https://files.pythonhosted.org/packages/63/d2/155d9e71b40e41fd934bc0c48b9b2770f22263e1ac20aad8e29fdca7be3f/msgpack-1.2.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:aa6c4be5d1c02a42b066ca6ddb71adf36432868fdcdb6ee87e634e86e0674190", size = 374851, upload-time = "2026-06-18T16:13:30.631Z" }, + { url = "https://files.pythonhosted.org/packages/98/48/deaf2326262a8d5ea3295ce9649912ecd3f551ba7ec8e33c665d2ba583f3/msgpack-1.2.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec0e675d59150a6269ddc9139087c722292664a37d071a849c05c473350f1f2d", size = 396168, upload-time = "2026-06-18T16:13:31.977Z" }, + { url = "https://files.pythonhosted.org/packages/10/2a/b4410f906c2ec0008f1608d3ab5143afc3ad3f4e6da0fed3ea2231d0bef4/msgpack-1.2.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:dd3bfe82d53edfe4b7fc9a7ec9761e23a7a5b1dac22264505af428253c29ed24", size = 371959, upload-time = "2026-06-18T16:13:33.282Z" }, + { url = "https://files.pythonhosted.org/packages/59/86/1edc67270099a528fa2093ea60fe191233cd238e4bd30cfacf7db79fc959/msgpack-1.2.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5ad5467fc3f68b5468e06c5f788d712e9f8ffc8b0cd1bcb160c105c1ee92dae7", size = 408457, upload-time = "2026-06-18T16:13:34.567Z" }, + { url = "https://files.pythonhosted.org/packages/82/90/8b630fef07d8c5ab457b71ff2c217910c83d333c7a68472c186e87cc504a/msgpack-1.2.1-cp314-cp314-win32.whl", hash = "sha256:98b58bdb89c46190e4609bb36abe17c6d4105ad13f9c5f8f6f64d320f8ced3fb", size = 65942, upload-time = "2026-06-18T16:13:36.056Z" }, + { url = "https://files.pythonhosted.org/packages/16/f1/467b81e98b24dd3885d7b1857728797b4ffc76a7a7483af4fb321a07de3c/msgpack-1.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:74847557e28ce71bd3c438a447ca90e4b507e997ddbdef8a12a7b283b86c156b", size = 72627, upload-time = "2026-06-18T16:13:37.079Z" }, + { url = "https://files.pythonhosted.org/packages/a7/1d/5d8c4c89985feb6acefb82a09e501c60392261856d2408d20bfe4f0360b1/msgpack-1.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:b50b727bd652bdc37d950336c848ef20ec54a4cafc38dce19b1cd86ad625d0f7", size = 66908, upload-time = "2026-06-18T16:13:38.23Z" }, + { url = "https://files.pythonhosted.org/packages/1b/02/ad2afb678b4de94496cd432b581759b756a92c1192d8c767edd6b132efdc/msgpack-1.2.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8d00f177ca88a77c1cf848d204a38f249751650b601cb6532acc68805d8a8273", size = 86000, upload-time = "2026-06-18T16:13:39.44Z" }, + { url = "https://files.pythonhosted.org/packages/54/74/0b797484013128837f3b1cbb6cea019277c4de4e377dc512b4d9a0f92940/msgpack-1.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5bb9c386f0a329c035ddbab4b72d1028bf9627add8dda41070288563d57ed1b1", size = 86544, upload-time = "2026-06-18T16:13:40.447Z" }, + { url = "https://files.pythonhosted.org/packages/a9/b4/b774d7eb95561739907fec675582f83203cf41c597a418c2589b4bfb8e9d/msgpack-1.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20466cca18c49c7292a8984bc15d65857b171e7264bdcb5f96baf8be238791fc", size = 427661, upload-time = "2026-06-18T16:13:41.574Z" }, + { url = "https://files.pythonhosted.org/packages/b2/f9/3243191dc9937e00756c8bc1b0272fed8f23758e43df2a3b46f533e5090f/msgpack-1.2.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:196300e7e5d6e74d50f1607ab9c06c4a1484c383cd22defd727902591f7e8dde", size = 426375, upload-time = "2026-06-18T16:13:42.936Z" }, + { url = "https://files.pythonhosted.org/packages/23/c7/1693111db9944ba4ad4b67a1e788400d78a0b6af7a6523dc7e4e58f8274b/msgpack-1.2.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575957e79cd51903a4e8495a242442949641e08f1efd5197b43bebd3ea7682b4", size = 380495, upload-time = "2026-06-18T16:13:44.306Z" }, + { url = "https://files.pythonhosted.org/packages/3e/2b/92f86956a0c13e8662f7e2ad630c4eb4db07497b967589bd5245e018b2c1/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8c2ed1e48cc0f460bf3c7780e7137ff21a4e18433451916f2442c1b21036cd7d", size = 410897, upload-time = "2026-06-18T16:13:45.629Z" }, + { url = "https://files.pythonhosted.org/packages/da/ea/1479f72d200313a76fc2f823a79d1e07ed052ab7b8a0280640aa7b95de42/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5f6277e5f783c36786a145e0247fc189a03f35f84b251646e53592d2bc12b355", size = 378519, upload-time = "2026-06-18T16:13:46.998Z" }, + { url = "https://files.pythonhosted.org/packages/f5/4d/fa006060ffa1011d32bfae826fe766fe73e02982183601633b7121058ab3/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9389552ecf4784886345ead0647e4edc96bee37cbab05b75540f542f766c48c", size = 419815, upload-time = "2026-06-18T16:13:48.205Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/aab6c946570496b78e67804721f3d5e2d62a93081b9b37df77764ef56347/msgpack-1.2.1-cp314-cp314t-win32.whl", hash = "sha256:c1c79a604a2969a868a78b6ebd27a887e00c624f14f66b3038e0590cb23332d1", size = 70914, upload-time = "2026-06-18T16:13:49.385Z" }, + { url = "https://files.pythonhosted.org/packages/13/0a/e608956488a2af014cfe6e3d665e090b8ee42aa14b07f8f95b8880d66b09/msgpack-1.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f12038a35fabd52e56a3547bab42401af49a45caa6dd00b34c44de235bc93ee2", size = 77999, upload-time = "2026-06-18T16:13:50.467Z" }, + { url = "https://files.pythonhosted.org/packages/d2/8a/27e2e57055176e366a46b85d02d68e7a5bcfbdd8474c9706375d965f24d3/msgpack-1.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0adcf06ffde0777c0e1a9b771a2b1c4226ba1bbf748c8efcc02fcdeca3299107", size = 71160, upload-time = "2026-06-18T16:13:51.498Z" }, ] [[package]] -name = "mypy-extensions" -version = "1.1.0" +name = "numpy" +version = "1.24.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a4/9b/027bec52c633f6556dba6b722d9a0befb40498b9ceddd29cbe67a45a127c/numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463", size = 10911229, upload-time = "2023-06-26T13:39:33.218Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, + { url = "https://files.pythonhosted.org/packages/6b/80/6cdfb3e275d95155a34659163b83c09e3a3ff9f1456880bec6cc63d71083/numpy-1.24.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0bfb52d2169d58c1cdb8cc1f16989101639b34c7d3ce60ed70b19c63eba0b64", size = 19789140, upload-time = "2023-06-26T13:22:33.184Z" }, + { url = "https://files.pythonhosted.org/packages/64/5f/3f01d753e2175cfade1013eea08db99ba1ee4bdb147ebcf3623b75d12aa7/numpy-1.24.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed094d4f0c177b1b8e7aa9cba7d6ceed51c0e569a5318ac0ca9a090680a6a1b1", size = 13854297, upload-time = "2023-06-26T13:22:59.541Z" }, + { url = "https://files.pythonhosted.org/packages/5a/b3/2f9c21d799fa07053ffa151faccdceeb69beec5a010576b8991f614021f7/numpy-1.24.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fc682a374c4a8ed08b331bef9c5f582585d1048fa6d80bc6c35bc384eee9b4", size = 13995611, upload-time = "2023-06-26T13:23:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/10/be/ae5bf4737cb79ba437879915791f6f26d92583c738d7d960ad94e5c36adf/numpy-1.24.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ffe43c74893dbf38c2b0a1f5428760a1a9c98285553c89e12d70a96a7f3a4d6", size = 17282357, upload-time = "2023-06-26T13:23:51.446Z" }, + { url = "https://files.pythonhosted.org/packages/c0/64/908c1087be6285f40e4b3e79454552a701664a079321cff519d8c7051d06/numpy-1.24.4-cp310-cp310-win32.whl", hash = "sha256:4c21decb6ea94057331e111a5bed9a79d335658c27ce2adb580fb4d54f2ad9bc", size = 12429222, upload-time = "2023-06-26T13:24:13.849Z" }, + { url = "https://files.pythonhosted.org/packages/22/55/3d5a7c1142e0d9329ad27cece17933b0e2ab4e54ddc5c1861fbfeb3f7693/numpy-1.24.4-cp310-cp310-win_amd64.whl", hash = "sha256:b4bea75e47d9586d31e892a7401f76e909712a0fd510f58f5337bea9572c571e", size = 14841514, upload-time = "2023-06-26T13:24:38.129Z" }, + { url = "https://files.pythonhosted.org/packages/a9/cc/5ed2280a27e5dab12994c884f1f4d8c3bd4d885d02ae9e52a9d213a6a5e2/numpy-1.24.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f136bab9c2cfd8da131132c2cf6cc27331dd6fae65f95f69dcd4ae3c3639c810", size = 19775508, upload-time = "2023-06-26T13:25:08.882Z" }, + { url = "https://files.pythonhosted.org/packages/c0/bc/77635c657a3668cf652806210b8662e1aff84b818a55ba88257abf6637a8/numpy-1.24.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2926dac25b313635e4d6cf4dc4e51c8c0ebfed60b801c799ffc4c32bf3d1254", size = 13840033, upload-time = "2023-06-26T13:25:33.417Z" }, + { url = "https://files.pythonhosted.org/packages/a7/4c/96cdaa34f54c05e97c1c50f39f98d608f96f0677a6589e64e53104e22904/numpy-1.24.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:222e40d0e2548690405b0b3c7b21d1169117391c2e82c378467ef9ab4c8f0da7", size = 13991951, upload-time = "2023-06-26T13:25:55.725Z" }, + { url = "https://files.pythonhosted.org/packages/22/97/dfb1a31bb46686f09e68ea6ac5c63fdee0d22d7b23b8f3f7ea07712869ef/numpy-1.24.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7215847ce88a85ce39baf9e89070cb860c98fdddacbaa6c0da3ffb31b3350bd5", size = 17278923, upload-time = "2023-06-26T13:26:25.658Z" }, + { url = "https://files.pythonhosted.org/packages/35/e2/76a11e54139654a324d107da1d98f99e7aa2a7ef97cfd7c631fba7dbde71/numpy-1.24.4-cp311-cp311-win32.whl", hash = "sha256:4979217d7de511a8d57f4b4b5b2b965f707768440c17cb70fbf254c4b225238d", size = 12422446, upload-time = "2023-06-26T13:26:49.302Z" }, + { url = "https://files.pythonhosted.org/packages/d8/ec/ebef2f7d7c28503f958f0f8b992e7ce606fb74f9e891199329d5f5f87404/numpy-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b7b1fc9864d7d39e28f41d089bfd6353cb5f27ecd9905348c24187a768c79694", size = 14834466, upload-time = "2023-06-26T13:27:16.029Z" }, + { url = "https://files.pythonhosted.org/packages/11/10/943cfb579f1a02909ff96464c69893b1d25be3731b5d3652c2e0cf1281ea/numpy-1.24.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1452241c290f3e2a312c137a9999cdbf63f78864d63c79039bda65ee86943f61", size = 19780722, upload-time = "2023-06-26T13:27:49.573Z" }, + { url = "https://files.pythonhosted.org/packages/a7/ae/f53b7b265fdc701e663fbb322a8e9d4b14d9cb7b2385f45ddfabfc4327e4/numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f", size = 13843102, upload-time = "2023-06-26T13:28:12.288Z" }, + { url = "https://files.pythonhosted.org/packages/25/6f/2586a50ad72e8dbb1d8381f837008a0321a3516dfd7cb57fc8cf7e4bb06b/numpy-1.24.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5425b114831d1e77e4b5d812b69d11d962e104095a5b9c3b641a218abcc050e", size = 14039616, upload-time = "2023-06-26T13:28:35.659Z" }, + { url = "https://files.pythonhosted.org/packages/98/5d/5738903efe0ecb73e51eb44feafba32bdba2081263d40c5043568ff60faf/numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc", size = 17316263, upload-time = "2023-06-26T13:29:09.272Z" }, + { url = "https://files.pythonhosted.org/packages/d1/57/8d328f0b91c733aa9aa7ee540dbc49b58796c862b4fbcb1146c701e888da/numpy-1.24.4-cp38-cp38-win32.whl", hash = "sha256:4602244f345453db537be5314d3983dbf5834a9701b7723ec28923e2889e0bb2", size = 12455660, upload-time = "2023-06-26T13:29:33.434Z" }, + { url = "https://files.pythonhosted.org/packages/69/65/0d47953afa0ad569d12de5f65d964321c208492064c38fe3b0b9744f8d44/numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706", size = 14868112, upload-time = "2023-06-26T13:29:58.385Z" }, + { url = "https://files.pythonhosted.org/packages/9a/cd/d5b0402b801c8a8b56b04c1e85c6165efab298d2f0ab741c2406516ede3a/numpy-1.24.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2541312fbf09977f3b3ad449c4e5f4bb55d0dbf79226d7724211acc905049400", size = 19816549, upload-time = "2023-06-26T13:30:36.976Z" }, + { url = "https://files.pythonhosted.org/packages/14/27/638aaa446f39113a3ed38b37a66243e21b38110d021bfcb940c383e120f2/numpy-1.24.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9667575fb6d13c95f1b36aca12c5ee3356bf001b714fc354eb5465ce1609e62f", size = 13879950, upload-time = "2023-06-26T13:31:01.787Z" }, + { url = "https://files.pythonhosted.org/packages/8f/27/91894916e50627476cff1a4e4363ab6179d01077d71b9afed41d9e1f18bf/numpy-1.24.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a86ed21e4f87050382c7bc96571755193c4c1392490744ac73d660e8f564a9", size = 14030228, upload-time = "2023-06-26T13:31:26.696Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/d7b2a0417af6428440c0ad7cb9799073e507b1a465f827d058b826236964/numpy-1.24.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d11efb4dbecbdf22508d55e48d9c8384db795e1b7b51ea735289ff96613ff74d", size = 17311170, upload-time = "2023-06-26T13:31:56.615Z" }, + { url = "https://files.pythonhosted.org/packages/18/9d/e02ace5d7dfccee796c37b995c63322674daf88ae2f4a4724c5dd0afcc91/numpy-1.24.4-cp39-cp39-win32.whl", hash = "sha256:6620c0acd41dbcb368610bb2f4d83145674040025e5536954782467100aa8835", size = 12454918, upload-time = "2023-06-26T13:32:16.8Z" }, + { url = "https://files.pythonhosted.org/packages/63/38/6cc19d6b8bfa1d1a459daf2b3fe325453153ca7019976274b6f33d8b5663/numpy-1.24.4-cp39-cp39-win_amd64.whl", hash = "sha256:befe2bf740fd8373cf56149a5c23a0f601e82869598d41f8e188a0e9869926f8", size = 14867441, upload-time = "2023-06-26T13:32:40.521Z" }, + { url = "https://files.pythonhosted.org/packages/a4/fd/8dff40e25e937c94257455c237b9b6bf5a30d42dd1cc11555533be099492/numpy-1.24.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:31f13e25b4e304632a4619d0e0777662c2ffea99fcae2029556b17d8ff958aef", size = 19156590, upload-time = "2023-06-26T13:33:10.36Z" }, + { url = "https://files.pythonhosted.org/packages/42/e7/4bf953c6e05df90c6d351af69966384fed8e988d0e8c54dad7103b59f3ba/numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a", size = 16705744, upload-time = "2023-06-26T13:33:36.703Z" }, + { url = "https://files.pythonhosted.org/packages/fc/dd/9106005eb477d022b60b3817ed5937a43dad8fd1f20b0610ea8a32fcb407/numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2", size = 14734290, upload-time = "2023-06-26T13:34:05.409Z" }, +] + +[[package]] +name = "numpy" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015, upload-time = "2024-08-26T20:19:40.945Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245, upload-time = "2024-08-26T20:04:14.625Z" }, + { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540, upload-time = "2024-08-26T20:04:36.784Z" }, + { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623, upload-time = "2024-08-26T20:04:46.491Z" }, + { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774, upload-time = "2024-08-26T20:04:58.173Z" }, + { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081, upload-time = "2024-08-26T20:05:19.098Z" }, + { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451, upload-time = "2024-08-26T20:05:47.479Z" }, + { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572, upload-time = "2024-08-26T20:06:17.137Z" }, + { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722, upload-time = "2024-08-26T20:06:39.16Z" }, + { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170, upload-time = "2024-08-26T20:06:50.361Z" }, + { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558, upload-time = "2024-08-26T20:07:13.881Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137, upload-time = "2024-08-26T20:07:45.345Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552, upload-time = "2024-08-26T20:08:06.666Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957, upload-time = "2024-08-26T20:08:15.83Z" }, + { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573, upload-time = "2024-08-26T20:08:27.185Z" }, + { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330, upload-time = "2024-08-26T20:08:48.058Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895, upload-time = "2024-08-26T20:09:16.536Z" }, + { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253, upload-time = "2024-08-26T20:09:46.263Z" }, + { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074, upload-time = "2024-08-26T20:10:08.483Z" }, + { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640, upload-time = "2024-08-26T20:10:19.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230, upload-time = "2024-08-26T20:10:43.413Z" }, + { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803, upload-time = "2024-08-26T20:11:13.916Z" }, + { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835, upload-time = "2024-08-26T20:11:34.779Z" }, + { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499, upload-time = "2024-08-26T20:11:43.902Z" }, + { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497, upload-time = "2024-08-26T20:11:55.09Z" }, + { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158, upload-time = "2024-08-26T20:12:14.95Z" }, + { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173, upload-time = "2024-08-26T20:12:44.049Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174, upload-time = "2024-08-26T20:13:13.634Z" }, + { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701, upload-time = "2024-08-26T20:13:34.851Z" }, + { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313, upload-time = "2024-08-26T20:13:45.653Z" }, + { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179, upload-time = "2024-08-26T20:14:08.786Z" }, + { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942, upload-time = "2024-08-26T20:14:40.108Z" }, + { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512, upload-time = "2024-08-26T20:15:00.985Z" }, + { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976, upload-time = "2024-08-26T20:15:10.876Z" }, + { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494, upload-time = "2024-08-26T20:15:22.055Z" }, + { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596, upload-time = "2024-08-26T20:15:42.452Z" }, + { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099, upload-time = "2024-08-26T20:16:11.048Z" }, + { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823, upload-time = "2024-08-26T20:16:40.171Z" }, + { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424, upload-time = "2024-08-26T20:17:02.604Z" }, + { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809, upload-time = "2024-08-26T20:17:13.553Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314, upload-time = "2024-08-26T20:17:36.72Z" }, + { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288, upload-time = "2024-08-26T20:18:07.732Z" }, + { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793, upload-time = "2024-08-26T20:18:19.125Z" }, + { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885, upload-time = "2024-08-26T20:18:47.237Z" }, + { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784, upload-time = "2024-08-26T20:19:11.19Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.11.*'", +] +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/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" }, + { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" }, + { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" }, + { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" }, + { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" }, + { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" }, + { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" }, + { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" }, + { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" }, + { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" }, + { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" }, + { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" }, + { 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" }, + { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" }, + { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" }, + { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" }, + { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", +] +sdist = { url = "https://files.pythonhosted.org/packages/22/fd/89965aa4ac08c74998539fcbf24fa3540f3e15237fbeb6bcf9c908f4aade/numpy-2.5.1.tar.gz", hash = "sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3", size = 20755553, upload-time = "2026-07-04T17:08:00.933Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/7b/14687aa674250e5e546f616f486b0d56d3631cd5b2415739141ce40bdcea/numpy-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277", size = 16801574, upload-time = "2026-07-04T17:06:12.423Z" }, + { url = "https://files.pythonhosted.org/packages/e1/19/cc5bb2a3f2913d27d6dbb2c78d25921fabaedc6741d4a5a615a11f3c5bf3/numpy-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1", size = 11772250, upload-time = "2026-07-04T17:06:15.726Z" }, + { url = "https://files.pythonhosted.org/packages/42/77/fdf34a71dd30f54979b18603bee915e0aaf825b07afe79acd60b04b691e2/numpy-2.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0", size = 5331516, upload-time = "2026-07-04T17:06:17.913Z" }, + { url = "https://files.pythonhosted.org/packages/ce/e2/eb7efa015b4cce41e2517bf182a7fce0d7d5b9d9ed76a29bfa0f4fe4505c/numpy-2.5.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e", size = 6664863, upload-time = "2026-07-04T17:06:20.02Z" }, + { url = "https://files.pythonhosted.org/packages/a9/4b/a2b32dd94ee9ffbeecb28152240042a3949db33b1c834d44090b80e1b3b8/numpy-2.5.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75", size = 15167977, upload-time = "2026-07-04T17:06:21.621Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a9/6e73d68500f80773f65f0654ea932019d6694329a0eb0ed0533de38df376/numpy-2.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca", size = 16672469, upload-time = "2026-07-04T17:06:24.064Z" }, + { url = "https://files.pythonhosted.org/packages/24/7d/ad3e59015135f5261c95fd4cafeff159c955febd83a99a1d9250c4233815/numpy-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3", size = 16527531, upload-time = "2026-07-04T17:06:26.69Z" }, + { url = "https://files.pythonhosted.org/packages/83/d0/a39b2fbcde9cb17a1dac678f254b33a6336298af9df338824c685425d5e8/numpy-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9", size = 18431940, upload-time = "2026-07-04T17:06:29.521Z" }, + { url = "https://files.pythonhosted.org/packages/04/12/cff070947791c1ed425ff76413189adbdc2fbe215eba7ce7fa454a03c7f8/numpy-2.5.1-cp312-cp312-win32.whl", hash = "sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2", size = 6066764, upload-time = "2026-07-04T17:06:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/65/66/53f31807a48a750f9d748da273bc3fcedd12b27ff1f3e373bfec55ef2dc0/numpy-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2", size = 12430966, upload-time = "2026-07-04T17:06:34.926Z" }, + { url = "https://files.pythonhosted.org/packages/2b/2a/d1a88066b1c14186f5d3c0d18c94f17b064511982bab0578d49ee9d43c29/numpy-2.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b", size = 10350488, upload-time = "2026-07-04T17:06:37.785Z" }, + { url = "https://files.pythonhosted.org/packages/eb/07/ec2a3f0c91761581d4b7104a740791800025983f9a4dc4e73f91a99aeac4/numpy-2.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1", size = 16796419, upload-time = "2026-07-04T17:06:40.37Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ab/ddb499fc4f8780354395face5b65c7fd107bcd6e1d667a5f07d046956f6f/numpy-2.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6", size = 11765832, upload-time = "2026-07-04T17:06:42.768Z" }, + { url = "https://files.pythonhosted.org/packages/88/b3/3c28c558a09fc72100c646dac6d2fce8e834c471b0edca01a29996706117/numpy-2.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d", size = 5325143, upload-time = "2026-07-04T17:06:45.466Z" }, + { url = "https://files.pythonhosted.org/packages/5e/0e/ce19b985bb15c596f4f05954e76cccc77c845083b3b8f938a6c68e523128/numpy-2.5.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1", size = 6659749, upload-time = "2026-07-04T17:06:47.288Z" }, + { url = "https://files.pythonhosted.org/packages/2e/20/1ee6614d64332a1bba6411f38e68cb79eec1b2459e20a623777c5c5492a2/numpy-2.5.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd", size = 15164716, upload-time = "2026-07-04T17:06:49.494Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a7/2bcd3fdbb87804755c35b729bf8709d62025c5f4cfd7d5b2415997097515/numpy-2.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a", size = 16661440, upload-time = "2026-07-04T17:06:52.061Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d7/a41e3310c886fe457d36e670bbf24fae411aca8a7b6ad92a32afd924077c/numpy-2.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7", size = 16526305, upload-time = "2026-07-04T17:06:54.605Z" }, + { url = "https://files.pythonhosted.org/packages/53/75/4333a9a707c1edd3a4e1a0c58eca52c0f31e55089fa80db02b5565b24df7/numpy-2.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6", size = 18423008, upload-time = "2026-07-04T17:06:57.54Z" }, + { url = "https://files.pythonhosted.org/packages/ee/90/e314a32b1c11a2ffe818ddad3a57b50b4b6e1b6c487192eb50cdef0415d0/numpy-2.5.1-cp313-cp313-win32.whl", hash = "sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9", size = 6063885, upload-time = "2026-07-04T17:07:00.14Z" }, + { url = "https://files.pythonhosted.org/packages/10/70/800b3fca480af32df9e8ea9f3d4a0c8feb4b32d7f195d174eabbda4829ad/numpy-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74", size = 12425674, upload-time = "2026-07-04T17:07:02.387Z" }, + { url = "https://files.pythonhosted.org/packages/8b/0b/196350c122f50f6ca56846f2d71efd5e0d24b7b2e07355e019b2e2c7a11e/numpy-2.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107", size = 10350256, upload-time = "2026-07-04T17:07:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/db/f4/731b6085a83faf6ca843394cbd5e217280c214399f7e8b21b9f552af0ae2/numpy-2.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:7c786fe9a5bbe360022e584c5a34cf6b54265c71bd7ec8ac3d8fec38968071f8", size = 16795063, upload-time = "2026-07-04T17:07:07.374Z" }, + { url = "https://files.pythonhosted.org/packages/bf/64/0e215f2048dd11a55bb989ed41b3585ef57452404e638d703a211a3e4157/numpy-2.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32985c896d897419ef8da6917872d80b78ad0ea26d85b23245c7366ffde76d75", size = 11776652, upload-time = "2026-07-04T17:07:09.907Z" }, + { url = "https://files.pythonhosted.org/packages/b5/59/2b844c7a6e9deff69b404a66221e1542937734f65d5e6e39411876053862/numpy-2.5.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:efd736408cc97c79b9e6917338dfc8f06013b2274f992e96b1d9a81a71e2a2c2", size = 5335944, upload-time = "2026-07-04T17:07:12.227Z" }, + { url = "https://files.pythonhosted.org/packages/86/51/9bf7cb2cabcebc9e017e4ec7e6322b378317a542c08b4cb68479c1efc716/numpy-2.5.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:ab84dc6b074fa881cae55bea94cc4f68e285181ba7f32497bf7dee6b1496165b", size = 6656266, upload-time = "2026-07-04T17:07:14.368Z" }, + { url = "https://files.pythonhosted.org/packages/83/3e/fb7615b211b82a32f44d5180a6d421b61f84d4fadd578b48ba4ac34e189f/numpy-2.5.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caf3e317d33d60c37986b452613f4ab51246d0691350c03d0cb4a898627f4a95", size = 15179720, upload-time = "2026-07-04T17:07:16.272Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/0f992cb24560673496c5d68de61913b57166ce530ffda07c1f280e0cc464/numpy-2.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:54ad769f17bc2d833b620851989f62054fb9ab93c969d9e1dc3c8e3d56beea21", size = 16664835, upload-time = "2026-07-04T17:07:19.021Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2f/97d6475ee91afe2587797d09446f9d3e475ad4cb681662d824809327b75a/numpy-2.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c12afb53450fa976d4c681c50a7423729a4c51c0465ed9f32b8a9cabbc472373", size = 16539135, upload-time = "2026-07-04T17:07:22.015Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/4db81e4ba0be7e2776b1de68c82aa862c7f8ec27e1b4927d4ae075e20678/numpy-2.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8c11c405efc5ff6816d5983c96cdfa215bab3428961243af3ff59b228490438", size = 18426684, upload-time = "2026-07-04T17:07:24.941Z" }, + { url = "https://files.pythonhosted.org/packages/1f/64/c0ba2d90724d450279a7df8f32057241070250a26a7e2b5337d77347f481/numpy-2.5.1-cp314-cp314-win32.whl", hash = "sha256:f2479a47f8d5932d1718168a681ad6e536a9df484c83cfcf9de365e164537ace", size = 6116103, upload-time = "2026-07-04T17:07:27.622Z" }, + { url = "https://files.pythonhosted.org/packages/c1/1a/837f9ed7405adcd7a40538792eb169eddd8fa5630c16a1ef49dae71a30f4/numpy-2.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:24d0eb82c0541d3415a33425db64ae439dffccd7b4dbcb30e7c35120205c506a", size = 12562177, upload-time = "2026-07-04T17:07:29.887Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/49707938b6dd0a78a9178dd93227dc89e4c11af47f5c798d70366e8d0483/numpy-2.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5a4c988b38d261deeeaad9954e3deb091ad905c94e8bb6708654ef1d97f286b0", size = 10627739, upload-time = "2026-07-04T17:07:32.568Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c7/bb4b882cfe7f299cbc8b66e42e7dd78cf9d14e40f9469fc5e3db7e15b3bd/numpy-2.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a33276be12fa045805f477f22482088b66bb758ffbe89a9d21457de863a32e22", size = 11894709, upload-time = "2026-07-04T17:07:34.941Z" }, + { url = "https://files.pythonhosted.org/packages/40/3f/5af7f4a7f6224aef48017aa82bb6174c7a659d724be0c75017b7e64a55b4/numpy-2.5.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:f089d7b00756190aacf1f5d34bdf38c3c430ac82b4f868f8cede73380460fce7", size = 5453810, upload-time = "2026-07-04T17:07:37.495Z" }, + { url = "https://files.pythonhosted.org/packages/20/c9/3474309bc94d634d3f9c3eddf03250ecb8c22cd948ef16fef69a77cc5d7b/numpy-2.5.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:09e9bfd8d2cf479c7d174804fb3811c53a8e9f20a37444008606b57d6b7a826d", size = 6761189, upload-time = "2026-07-04T17:07:39.563Z" }, + { url = "https://files.pythonhosted.org/packages/90/8a/558ae39fdd55d7e7f7fef9a84a6e964ac6b23edbd2a07e52bb084500507d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e68d8dd1e7eba712948f2053a29ec86917bc70ba1358df869d9f06649ef9cf09", size = 15225039, upload-time = "2026-07-04T17:07:41.682Z" }, + { url = "https://files.pythonhosted.org/packages/63/27/ca7392b2d030277bdf0273e7d23255b3ee57d57a7c170a6f4fb3981e1e5d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99d5095fa265a0c4152e7bb12759e14381ef5496152f1ce58f44bdf55c44beb4", size = 16701306, upload-time = "2026-07-04T17:07:44.611Z" }, + { url = "https://files.pythonhosted.org/packages/02/42/03d53ae7996c44d4374a8262e9dc41671fd56cbb98f7d47ef85cf5da4c6b/numpy-2.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ab87a91b3cc3382b8956095bd8f95e00cf679bb81554339be1a2ba404a1473c1", size = 16589955, upload-time = "2026-07-04T17:07:47.694Z" }, + { url = "https://files.pythonhosted.org/packages/7b/15/6c1784ae469640e65db111e9a34b3d0f14d91e8a38b9ce34810ced370dbb/numpy-2.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:224ca51130ef7da85bea2191625181cb4f337f9cb64b471f10c1a12aa8b60077", size = 18464252, upload-time = "2026-07-04T17:07:50.684Z" }, + { url = "https://files.pythonhosted.org/packages/94/a8/f98e50356cf167df656c526c2dfeec2d7dde182f2a3da4b458a5938e2776/numpy-2.5.1-cp314-cp314t-win32.whl", hash = "sha256:6eab239876581b2b3c5a242281b6007bbdbcd1c7085d7709bb57c5929b11e6bf", size = 6263298, upload-time = "2026-07-04T17:07:53.445Z" }, + { url = "https://files.pythonhosted.org/packages/72/ac/96ae880cdecad0b3275d9359fcec72667b49a4863c9f12942e43679dda02/numpy-2.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:83ce9c80d5b521b0d77ddcbe5447c218d247929b6cc056ca5351342accfff0af", size = 12748623, upload-time = "2026-07-04T17:07:55.384Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5a/4d2b1601df3602dba7a14f3348ba9bfe94a18adb428e693df6154c293831/numpy-2.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:5a6db61f9aaa57e369905c67d852045d3c4f7126405b29d09b19dec118e9c9cb", size = 10697674, upload-time = "2026-07-04T17:07:58.506Z" }, +] + +[[package]] +name = "packageurl-python" +version = "0.17.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/d6/3b5a4e3cfaef7a53869a26ceb034d1ff5e5c27c814ce77260a96d50ab7bb/packageurl_python-0.17.6.tar.gz", hash = "sha256:1252ce3a102372ca6f86eb968e16f9014c4ba511c5c37d95a7f023e2ca6e5c25", size = 50618, upload-time = "2025-11-24T15:20:17.998Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/2f/c7277b7615a93f51b5fbc1eacfc1b75e8103370e786fd8ce2abf6e5c04ab/packageurl_python-0.17.6-py3-none-any.whl", hash = "sha256:31a85c2717bc41dd818f3c62908685ff9eebcb68588213745b14a6ee9e7df7c9", size = 36776, upload-time = "2025-11-24T15:20:16.962Z" }, ] [[package]] @@ -1030,32 +2410,452 @@ wheels = [ ] [[package]] -name = "pathspec" -version = "0.12.1" +name = "pillow" +version = "10.4.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.8.1' and python_full_version < '3.9'", "python_full_version < '3.8.1'", ] -sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/74/ad3d526f3bf7b6d3f408b73fde271ec69dfac8b81341a318ce825f2b3812/pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06", size = 46555059, upload-time = "2024-07-01T09:48:43.583Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" }, + { url = "https://files.pythonhosted.org/packages/0e/69/a31cccd538ca0b5272be2a38347f8839b97a14be104ea08b0db92f749c74/pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e", size = 3509271, upload-time = "2024-07-01T09:45:22.07Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9e/4143b907be8ea0bce215f2ae4f7480027473f8b61fcedfda9d851082a5d2/pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d", size = 3375658, upload-time = "2024-07-01T09:45:25.292Z" }, + { url = "https://files.pythonhosted.org/packages/8a/25/1fc45761955f9359b1169aa75e241551e74ac01a09f487adaaf4c3472d11/pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856", size = 4332075, upload-time = "2024-07-01T09:45:27.94Z" }, + { url = "https://files.pythonhosted.org/packages/5e/dd/425b95d0151e1d6c951f45051112394f130df3da67363b6bc75dc4c27aba/pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f", size = 4444808, upload-time = "2024-07-01T09:45:30.305Z" }, + { url = "https://files.pythonhosted.org/packages/b1/84/9a15cc5726cbbfe7f9f90bfb11f5d028586595907cd093815ca6644932e3/pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b", size = 4356290, upload-time = "2024-07-01T09:45:32.868Z" }, + { url = "https://files.pythonhosted.org/packages/b5/5b/6651c288b08df3b8c1e2f8c1152201e0b25d240e22ddade0f1e242fc9fa0/pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc", size = 4525163, upload-time = "2024-07-01T09:45:35.279Z" }, + { url = "https://files.pythonhosted.org/packages/07/8b/34854bf11a83c248505c8cb0fcf8d3d0b459a2246c8809b967963b6b12ae/pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e", size = 4463100, upload-time = "2024-07-01T09:45:37.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/63/0632aee4e82476d9cbe5200c0cdf9ba41ee04ed77887432845264d81116d/pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46", size = 4592880, upload-time = "2024-07-01T09:45:39.89Z" }, + { url = "https://files.pythonhosted.org/packages/df/56/b8663d7520671b4398b9d97e1ed9f583d4afcbefbda3c6188325e8c297bd/pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984", size = 2235218, upload-time = "2024-07-01T09:45:42.771Z" }, + { url = "https://files.pythonhosted.org/packages/f4/72/0203e94a91ddb4a9d5238434ae6c1ca10e610e8487036132ea9bf806ca2a/pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141", size = 2554487, upload-time = "2024-07-01T09:45:45.176Z" }, + { url = "https://files.pythonhosted.org/packages/bd/52/7e7e93d7a6e4290543f17dc6f7d3af4bd0b3dd9926e2e8a35ac2282bc5f4/pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1", size = 2243219, upload-time = "2024-07-01T09:45:47.274Z" }, + { url = "https://files.pythonhosted.org/packages/a7/62/c9449f9c3043c37f73e7487ec4ef0c03eb9c9afc91a92b977a67b3c0bbc5/pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c", size = 3509265, upload-time = "2024-07-01T09:45:49.812Z" }, + { url = "https://files.pythonhosted.org/packages/f4/5f/491dafc7bbf5a3cc1845dc0430872e8096eb9e2b6f8161509d124594ec2d/pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be", size = 3375655, upload-time = "2024-07-01T09:45:52.462Z" }, + { url = "https://files.pythonhosted.org/packages/73/d5/c4011a76f4207a3c151134cd22a1415741e42fa5ddecec7c0182887deb3d/pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3", size = 4340304, upload-time = "2024-07-01T09:45:55.006Z" }, + { url = "https://files.pythonhosted.org/packages/ac/10/c67e20445a707f7a610699bba4fe050583b688d8cd2d202572b257f46600/pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6", size = 4452804, upload-time = "2024-07-01T09:45:58.437Z" }, + { url = "https://files.pythonhosted.org/packages/a9/83/6523837906d1da2b269dee787e31df3b0acb12e3d08f024965a3e7f64665/pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe", size = 4365126, upload-time = "2024-07-01T09:46:00.713Z" }, + { url = "https://files.pythonhosted.org/packages/ba/e5/8c68ff608a4203085158cff5cc2a3c534ec384536d9438c405ed6370d080/pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319", size = 4533541, upload-time = "2024-07-01T09:46:03.235Z" }, + { url = "https://files.pythonhosted.org/packages/f4/7c/01b8dbdca5bc6785573f4cee96e2358b0918b7b2c7b60d8b6f3abf87a070/pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d", size = 4471616, upload-time = "2024-07-01T09:46:05.356Z" }, + { url = "https://files.pythonhosted.org/packages/c8/57/2899b82394a35a0fbfd352e290945440e3b3785655a03365c0ca8279f351/pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696", size = 4600802, upload-time = "2024-07-01T09:46:08.145Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d7/a44f193d4c26e58ee5d2d9db3d4854b2cfb5b5e08d360a5e03fe987c0086/pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496", size = 2235213, upload-time = "2024-07-01T09:46:10.211Z" }, + { url = "https://files.pythonhosted.org/packages/c1/d0/5866318eec2b801cdb8c82abf190c8343d8a1cd8bf5a0c17444a6f268291/pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91", size = 2554498, upload-time = "2024-07-01T09:46:12.685Z" }, + { url = "https://files.pythonhosted.org/packages/d4/c8/310ac16ac2b97e902d9eb438688de0d961660a87703ad1561fd3dfbd2aa0/pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22", size = 2243219, upload-time = "2024-07-01T09:46:14.83Z" }, + { url = "https://files.pythonhosted.org/packages/05/cb/0353013dc30c02a8be34eb91d25e4e4cf594b59e5a55ea1128fde1e5f8ea/pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94", size = 3509350, upload-time = "2024-07-01T09:46:17.177Z" }, + { url = "https://files.pythonhosted.org/packages/e7/cf/5c558a0f247e0bf9cec92bff9b46ae6474dd736f6d906315e60e4075f737/pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597", size = 3374980, upload-time = "2024-07-01T09:46:19.169Z" }, + { url = "https://files.pythonhosted.org/packages/84/48/6e394b86369a4eb68b8a1382c78dc092245af517385c086c5094e3b34428/pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80", size = 4343799, upload-time = "2024-07-01T09:46:21.883Z" }, + { url = "https://files.pythonhosted.org/packages/3b/f3/a8c6c11fa84b59b9df0cd5694492da8c039a24cd159f0f6918690105c3be/pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca", size = 4459973, upload-time = "2024-07-01T09:46:24.321Z" }, + { url = "https://files.pythonhosted.org/packages/7d/1b/c14b4197b80150fb64453585247e6fb2e1d93761fa0fa9cf63b102fde822/pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef", size = 4370054, upload-time = "2024-07-01T09:46:26.825Z" }, + { url = "https://files.pythonhosted.org/packages/55/77/40daddf677897a923d5d33329acd52a2144d54a9644f2a5422c028c6bf2d/pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a", size = 4539484, upload-time = "2024-07-01T09:46:29.355Z" }, + { url = "https://files.pythonhosted.org/packages/40/54/90de3e4256b1207300fb2b1d7168dd912a2fb4b2401e439ba23c2b2cabde/pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b", size = 4477375, upload-time = "2024-07-01T09:46:31.756Z" }, + { url = "https://files.pythonhosted.org/packages/13/24/1bfba52f44193860918ff7c93d03d95e3f8748ca1de3ceaf11157a14cf16/pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9", size = 4608773, upload-time = "2024-07-01T09:46:33.73Z" }, + { url = "https://files.pythonhosted.org/packages/55/04/5e6de6e6120451ec0c24516c41dbaf80cce1b6451f96561235ef2429da2e/pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42", size = 2235690, upload-time = "2024-07-01T09:46:36.587Z" }, + { url = "https://files.pythonhosted.org/packages/74/0a/d4ce3c44bca8635bd29a2eab5aa181b654a734a29b263ca8efe013beea98/pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a", size = 2554951, upload-time = "2024-07-01T09:46:38.777Z" }, + { url = "https://files.pythonhosted.org/packages/b5/ca/184349ee40f2e92439be9b3502ae6cfc43ac4b50bc4fc6b3de7957563894/pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9", size = 2243427, upload-time = "2024-07-01T09:46:43.15Z" }, + { url = "https://files.pythonhosted.org/packages/c3/00/706cebe7c2c12a6318aabe5d354836f54adff7156fd9e1bd6c89f4ba0e98/pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3", size = 3525685, upload-time = "2024-07-01T09:46:45.194Z" }, + { url = "https://files.pythonhosted.org/packages/cf/76/f658cbfa49405e5ecbfb9ba42d07074ad9792031267e782d409fd8fe7c69/pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb", size = 3374883, upload-time = "2024-07-01T09:46:47.331Z" }, + { url = "https://files.pythonhosted.org/packages/46/2b/99c28c4379a85e65378211971c0b430d9c7234b1ec4d59b2668f6299e011/pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70", size = 4339837, upload-time = "2024-07-01T09:46:49.647Z" }, + { url = "https://files.pythonhosted.org/packages/f1/74/b1ec314f624c0c43711fdf0d8076f82d9d802afd58f1d62c2a86878e8615/pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be", size = 4455562, upload-time = "2024-07-01T09:46:51.811Z" }, + { url = "https://files.pythonhosted.org/packages/4a/2a/4b04157cb7b9c74372fa867096a1607e6fedad93a44deeff553ccd307868/pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0", size = 4366761, upload-time = "2024-07-01T09:46:53.961Z" }, + { url = "https://files.pythonhosted.org/packages/ac/7b/8f1d815c1a6a268fe90481232c98dd0e5fa8c75e341a75f060037bd5ceae/pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc", size = 4536767, upload-time = "2024-07-01T09:46:56.664Z" }, + { url = "https://files.pythonhosted.org/packages/e5/77/05fa64d1f45d12c22c314e7b97398ffb28ef2813a485465017b7978b3ce7/pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a", size = 4477989, upload-time = "2024-07-01T09:46:58.977Z" }, + { url = "https://files.pythonhosted.org/packages/12/63/b0397cfc2caae05c3fb2f4ed1b4fc4fc878f0243510a7a6034ca59726494/pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309", size = 4610255, upload-time = "2024-07-01T09:47:01.189Z" }, + { url = "https://files.pythonhosted.org/packages/7b/f9/cfaa5082ca9bc4a6de66ffe1c12c2d90bf09c309a5f52b27759a596900e7/pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060", size = 2235603, upload-time = "2024-07-01T09:47:03.918Z" }, + { url = "https://files.pythonhosted.org/packages/01/6a/30ff0eef6e0c0e71e55ded56a38d4859bf9d3634a94a88743897b5f96936/pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea", size = 2554972, upload-time = "2024-07-01T09:47:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/48/2c/2e0a52890f269435eee38b21c8218e102c621fe8d8df8b9dd06fabf879ba/pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d", size = 2243375, upload-time = "2024-07-01T09:47:09.065Z" }, + { url = "https://files.pythonhosted.org/packages/56/70/f40009702a477ce87d8d9faaa4de51d6562b3445d7a314accd06e4ffb01d/pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736", size = 3509213, upload-time = "2024-07-01T09:47:11.662Z" }, + { url = "https://files.pythonhosted.org/packages/10/43/105823d233c5e5d31cea13428f4474ded9d961652307800979a59d6a4276/pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b", size = 3375883, upload-time = "2024-07-01T09:47:14.453Z" }, + { url = "https://files.pythonhosted.org/packages/3c/ad/7850c10bac468a20c918f6a5dbba9ecd106ea1cdc5db3c35e33a60570408/pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2", size = 4330810, upload-time = "2024-07-01T09:47:16.695Z" }, + { url = "https://files.pythonhosted.org/packages/84/4c/69bbed9e436ac22f9ed193a2b64f64d68fcfbc9f4106249dc7ed4889907b/pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680", size = 4444341, upload-time = "2024-07-01T09:47:19.334Z" }, + { url = "https://files.pythonhosted.org/packages/8f/4f/c183c63828a3f37bf09644ce94cbf72d4929b033b109160a5379c2885932/pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b", size = 4356005, upload-time = "2024-07-01T09:47:21.805Z" }, + { url = "https://files.pythonhosted.org/packages/fb/ad/435fe29865f98a8fbdc64add8875a6e4f8c97749a93577a8919ec6f32c64/pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd", size = 4525201, upload-time = "2024-07-01T09:47:24.457Z" }, + { url = "https://files.pythonhosted.org/packages/80/74/be8bf8acdfd70e91f905a12ae13cfb2e17c0f1da745c40141e26d0971ff5/pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84", size = 4460635, upload-time = "2024-07-01T09:47:26.841Z" }, + { url = "https://files.pythonhosted.org/packages/e4/90/763616e66dc9ad59c9b7fb58f863755e7934ef122e52349f62c7742b82d3/pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0", size = 4590283, upload-time = "2024-07-01T09:47:29.247Z" }, + { url = "https://files.pythonhosted.org/packages/69/66/03002cb5b2c27bb519cba63b9f9aa3709c6f7a5d3b285406c01f03fb77e5/pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e", size = 2235185, upload-time = "2024-07-01T09:47:32.205Z" }, + { url = "https://files.pythonhosted.org/packages/f2/75/3cb820b2812405fc7feb3d0deb701ef0c3de93dc02597115e00704591bc9/pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab", size = 2554594, upload-time = "2024-07-01T09:47:34.285Z" }, + { url = "https://files.pythonhosted.org/packages/31/85/955fa5400fa8039921f630372cfe5056eed6e1b8e0430ee4507d7de48832/pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d", size = 3509283, upload-time = "2024-07-01T09:47:36.394Z" }, + { url = "https://files.pythonhosted.org/packages/23/9c/343827267eb28d41cd82b4180d33b10d868af9077abcec0af9793aa77d2d/pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b", size = 3375691, upload-time = "2024-07-01T09:47:38.853Z" }, + { url = "https://files.pythonhosted.org/packages/60/a3/7ebbeabcd341eab722896d1a5b59a3df98c4b4d26cf4b0385f8aa94296f7/pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd", size = 4328295, upload-time = "2024-07-01T09:47:41.765Z" }, + { url = "https://files.pythonhosted.org/packages/32/3f/c02268d0c6fb6b3958bdda673c17b315c821d97df29ae6969f20fb49388a/pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126", size = 4440810, upload-time = "2024-07-01T09:47:44.27Z" }, + { url = "https://files.pythonhosted.org/packages/67/5d/1c93c8cc35f2fdd3d6cc7e4ad72d203902859a2867de6ad957d9b708eb8d/pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b", size = 4352283, upload-time = "2024-07-01T09:47:46.673Z" }, + { url = "https://files.pythonhosted.org/packages/bc/a8/8655557c9c7202b8abbd001f61ff36711cefaf750debcaa1c24d154ef602/pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c", size = 4521800, upload-time = "2024-07-01T09:47:48.813Z" }, + { url = "https://files.pythonhosted.org/packages/58/78/6f95797af64d137124f68af1bdaa13b5332da282b86031f6fa70cf368261/pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1", size = 4459177, upload-time = "2024-07-01T09:47:52.104Z" }, + { url = "https://files.pythonhosted.org/packages/8a/6d/2b3ce34f1c4266d79a78c9a51d1289a33c3c02833fe294ef0dcbb9cba4ed/pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df", size = 4589079, upload-time = "2024-07-01T09:47:54.999Z" }, + { url = "https://files.pythonhosted.org/packages/e3/e0/456258c74da1ff5bf8ef1eab06a95ca994d8b9ed44c01d45c3f8cbd1db7e/pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef", size = 2235247, upload-time = "2024-07-01T09:47:57.666Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/bef952bdb32aa53741f58bf21798642209e994edc3f6598f337f23d5400a/pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5", size = 2554479, upload-time = "2024-07-01T09:47:59.881Z" }, + { url = "https://files.pythonhosted.org/packages/bb/8e/805201619cad6651eef5fc1fdef913804baf00053461522fabbc5588ea12/pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e", size = 2243226, upload-time = "2024-07-01T09:48:02.508Z" }, + { url = "https://files.pythonhosted.org/packages/38/30/095d4f55f3a053392f75e2eae45eba3228452783bab3d9a920b951ac495c/pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4", size = 3493889, upload-time = "2024-07-01T09:48:04.815Z" }, + { url = "https://files.pythonhosted.org/packages/f3/e8/4ff79788803a5fcd5dc35efdc9386af153569853767bff74540725b45863/pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da", size = 3346160, upload-time = "2024-07-01T09:48:07.206Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ac/4184edd511b14f760c73f5bb8a5d6fd85c591c8aff7c2229677a355c4179/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026", size = 3435020, upload-time = "2024-07-01T09:48:09.66Z" }, + { url = "https://files.pythonhosted.org/packages/da/21/1749cd09160149c0a246a81d646e05f35041619ce76f6493d6a96e8d1103/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e", size = 3490539, upload-time = "2024-07-01T09:48:12.529Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f5/f71fe1888b96083b3f6dfa0709101f61fc9e972c0c8d04e9d93ccef2a045/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5", size = 3476125, upload-time = "2024-07-01T09:48:14.891Z" }, + { url = "https://files.pythonhosted.org/packages/96/b9/c0362c54290a31866c3526848583a2f45a535aa9d725fd31e25d318c805f/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885", size = 3579373, upload-time = "2024-07-01T09:48:17.601Z" }, + { url = "https://files.pythonhosted.org/packages/52/3b/ce7a01026a7cf46e5452afa86f97a5e88ca97f562cafa76570178ab56d8d/pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5", size = 2554661, upload-time = "2024-07-01T09:48:20.293Z" }, + { url = "https://files.pythonhosted.org/packages/e1/1f/5a9fcd6ced51633c22481417e11b1b47d723f64fb536dfd67c015eb7f0ab/pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b", size = 3493850, upload-time = "2024-07-01T09:48:23.03Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e6/3ea4755ed5320cb62aa6be2f6de47b058c6550f752dd050e86f694c59798/pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908", size = 3346118, upload-time = "2024-07-01T09:48:25.256Z" }, + { url = "https://files.pythonhosted.org/packages/0a/22/492f9f61e4648422b6ca39268ec8139277a5b34648d28f400faac14e0f48/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b", size = 3434958, upload-time = "2024-07-01T09:48:28.078Z" }, + { url = "https://files.pythonhosted.org/packages/f9/19/559a48ad4045704bb0547965b9a9345f5cd461347d977a56d178db28819e/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8", size = 3490340, upload-time = "2024-07-01T09:48:30.734Z" }, + { url = "https://files.pythonhosted.org/packages/d9/de/cebaca6fb79905b3a1aa0281d238769df3fb2ede34fd7c0caa286575915a/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a", size = 3476048, upload-time = "2024-07-01T09:48:33.292Z" }, + { url = "https://files.pythonhosted.org/packages/71/f0/86d5b2f04693b0116a01d75302b0a307800a90d6c351a8aa4f8ae76cd499/pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27", size = 3579366, upload-time = "2024-07-01T09:48:36.527Z" }, + { url = "https://files.pythonhosted.org/packages/37/ae/2dbfc38cc4fd14aceea14bc440d5151b21f64c4c3ba3f6f4191610b7ee5d/pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3", size = 2554652, upload-time = "2024-07-01T09:48:38.789Z" }, ] [[package]] -name = "pathspec" -version = "1.1.1" +name = "pillow" +version = "11.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/5d/45a3553a253ac8763f3561371432a90bdbe6000fbdcf1397ffe502aa206c/pillow-11.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860", size = 5316554, upload-time = "2025-07-01T09:13:39.342Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c8/67c12ab069ef586a25a4a79ced553586748fad100c77c0ce59bb4983ac98/pillow-11.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad", size = 4686548, upload-time = "2025-07-01T09:13:41.835Z" }, + { url = "https://files.pythonhosted.org/packages/2f/bd/6741ebd56263390b382ae4c5de02979af7f8bd9807346d068700dd6d5cf9/pillow-11.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7107195ddc914f656c7fc8e4a5e1c25f32e9236ea3ea860f257b0436011fddd0", size = 5859742, upload-time = "2025-07-03T13:09:47.439Z" }, + { url = "https://files.pythonhosted.org/packages/ca/0b/c412a9e27e1e6a829e6ab6c2dca52dd563efbedf4c9c6aa453d9a9b77359/pillow-11.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc3e831b563b3114baac7ec2ee86819eb03caa1a2cef0b481a5675b59c4fe23b", size = 7633087, upload-time = "2025-07-03T13:09:51.796Z" }, + { url = "https://files.pythonhosted.org/packages/59/9d/9b7076aaf30f5dd17e5e5589b2d2f5a5d7e30ff67a171eb686e4eecc2adf/pillow-11.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1f182ebd2303acf8c380a54f615ec883322593320a9b00438eb842c1f37ae50", size = 5963350, upload-time = "2025-07-01T09:13:43.865Z" }, + { url = "https://files.pythonhosted.org/packages/f0/16/1a6bf01fb622fb9cf5c91683823f073f053005c849b1f52ed613afcf8dae/pillow-11.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4445fa62e15936a028672fd48c4c11a66d641d2c05726c7ec1f8ba6a572036ae", size = 6631840, upload-time = "2025-07-01T09:13:46.161Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e6/6ff7077077eb47fde78739e7d570bdcd7c10495666b6afcd23ab56b19a43/pillow-11.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:71f511f6b3b91dd543282477be45a033e4845a40278fa8dcdbfdb07109bf18f9", size = 6074005, upload-time = "2025-07-01T09:13:47.829Z" }, + { url = "https://files.pythonhosted.org/packages/c3/3a/b13f36832ea6d279a697231658199e0a03cd87ef12048016bdcc84131601/pillow-11.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:040a5b691b0713e1f6cbe222e0f4f74cd233421e105850ae3b3c0ceda520f42e", size = 6708372, upload-time = "2025-07-01T09:13:52.145Z" }, + { url = "https://files.pythonhosted.org/packages/6c/e4/61b2e1a7528740efbc70b3d581f33937e38e98ef3d50b05007267a55bcb2/pillow-11.3.0-cp310-cp310-win32.whl", hash = "sha256:89bd777bc6624fe4115e9fac3352c79ed60f3bb18651420635f26e643e3dd1f6", size = 6277090, upload-time = "2025-07-01T09:13:53.915Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d3/60c781c83a785d6afbd6a326ed4d759d141de43aa7365725cbcd65ce5e54/pillow-11.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:19d2ff547c75b8e3ff46f4d9ef969a06c30ab2d4263a9e287733aa8b2429ce8f", size = 6985988, upload-time = "2025-07-01T09:13:55.699Z" }, + { url = "https://files.pythonhosted.org/packages/9f/28/4f4a0203165eefb3763939c6789ba31013a2e90adffb456610f30f613850/pillow-11.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:819931d25e57b513242859ce1876c58c59dc31587847bf74cfe06b2e0cb22d2f", size = 2422899, upload-time = "2025-07-01T09:13:57.497Z" }, + { url = "https://files.pythonhosted.org/packages/db/26/77f8ed17ca4ffd60e1dcd220a6ec6d71210ba398cfa33a13a1cd614c5613/pillow-11.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722", size = 5316531, upload-time = "2025-07-01T09:13:59.203Z" }, + { url = "https://files.pythonhosted.org/packages/cb/39/ee475903197ce709322a17a866892efb560f57900d9af2e55f86db51b0a5/pillow-11.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288", size = 4686560, upload-time = "2025-07-01T09:14:01.101Z" }, + { url = "https://files.pythonhosted.org/packages/d5/90/442068a160fd179938ba55ec8c97050a612426fae5ec0a764e345839f76d/pillow-11.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d", size = 5870978, upload-time = "2025-07-03T13:09:55.638Z" }, + { url = "https://files.pythonhosted.org/packages/13/92/dcdd147ab02daf405387f0218dcf792dc6dd5b14d2573d40b4caeef01059/pillow-11.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494", size = 7641168, upload-time = "2025-07-03T13:10:00.37Z" }, + { url = "https://files.pythonhosted.org/packages/6e/db/839d6ba7fd38b51af641aa904e2960e7a5644d60ec754c046b7d2aee00e5/pillow-11.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58", size = 5973053, upload-time = "2025-07-01T09:14:04.491Z" }, + { url = "https://files.pythonhosted.org/packages/f2/2f/d7675ecae6c43e9f12aa8d58b6012683b20b6edfbdac7abcb4e6af7a3784/pillow-11.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f", size = 6640273, upload-time = "2025-07-01T09:14:06.235Z" }, + { url = "https://files.pythonhosted.org/packages/45/ad/931694675ede172e15b2ff03c8144a0ddaea1d87adb72bb07655eaffb654/pillow-11.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e", size = 6082043, upload-time = "2025-07-01T09:14:07.978Z" }, + { url = "https://files.pythonhosted.org/packages/3a/04/ba8f2b11fc80d2dd462d7abec16351b45ec99cbbaea4387648a44190351a/pillow-11.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:932c754c2d51ad2b2271fd01c3d121daaa35e27efae2a616f77bf164bc0b3e94", size = 6715516, upload-time = "2025-07-01T09:14:10.233Z" }, + { url = "https://files.pythonhosted.org/packages/48/59/8cd06d7f3944cc7d892e8533c56b0acb68399f640786313275faec1e3b6f/pillow-11.3.0-cp311-cp311-win32.whl", hash = "sha256:b4b8f3efc8d530a1544e5962bd6b403d5f7fe8b9e08227c6b255f98ad82b4ba0", size = 6274768, upload-time = "2025-07-01T09:14:11.921Z" }, + { url = "https://files.pythonhosted.org/packages/f1/cc/29c0f5d64ab8eae20f3232da8f8571660aa0ab4b8f1331da5c2f5f9a938e/pillow-11.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:1a992e86b0dd7aeb1f053cd506508c0999d710a8f07b4c791c63843fc6a807ac", size = 6986055, upload-time = "2025-07-01T09:14:13.623Z" }, + { url = "https://files.pythonhosted.org/packages/c6/df/90bd886fabd544c25addd63e5ca6932c86f2b701d5da6c7839387a076b4a/pillow-11.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd", size = 2423079, upload-time = "2025-07-01T09:14:15.268Z" }, + { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload-time = "2025-07-01T09:14:17.648Z" }, + { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload-time = "2025-07-01T09:14:19.828Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload-time = "2025-07-03T13:10:04.448Z" }, + { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload-time = "2025-07-03T13:10:10.391Z" }, + { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload-time = "2025-07-01T09:14:21.63Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload-time = "2025-07-01T09:14:23.321Z" }, + { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload-time = "2025-07-01T09:14:25.237Z" }, + { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358, upload-time = "2025-07-01T09:14:27.053Z" }, + { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079, upload-time = "2025-07-01T09:14:30.104Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324, upload-time = "2025-07-01T09:14:31.899Z" }, + { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067, upload-time = "2025-07-01T09:14:33.709Z" }, + { url = "https://files.pythonhosted.org/packages/1e/93/0952f2ed8db3a5a4c7a11f91965d6184ebc8cd7cbb7941a260d5f018cd2d/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd", size = 2128328, upload-time = "2025-07-01T09:14:35.276Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e8/100c3d114b1a0bf4042f27e0f87d2f25e857e838034e98ca98fe7b8c0a9c/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8", size = 2170652, upload-time = "2025-07-01T09:14:37.203Z" }, + { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443, upload-time = "2025-07-01T09:14:39.344Z" }, + { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474, upload-time = "2025-07-01T09:14:41.843Z" }, + { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038, upload-time = "2025-07-01T09:14:44.008Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407, upload-time = "2025-07-03T13:10:15.628Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094, upload-time = "2025-07-03T13:10:21.857Z" }, + { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503, upload-time = "2025-07-01T09:14:45.698Z" }, + { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574, upload-time = "2025-07-01T09:14:47.415Z" }, + { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060, upload-time = "2025-07-01T09:14:49.636Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ea/502d938cbaeec836ac28a9b730193716f0114c41325db428e6b280513f09/pillow-11.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b", size = 6721407, upload-time = "2025-07-01T09:14:51.962Z" }, + { url = "https://files.pythonhosted.org/packages/45/9c/9c5e2a73f125f6cbc59cc7087c8f2d649a7ae453f83bd0362ff7c9e2aee2/pillow-11.3.0-cp313-cp313-win32.whl", hash = "sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3", size = 6273841, upload-time = "2025-07-01T09:14:54.142Z" }, + { url = "https://files.pythonhosted.org/packages/23/85/397c73524e0cd212067e0c969aa245b01d50183439550d24d9f55781b776/pillow-11.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51", size = 6978450, upload-time = "2025-07-01T09:14:56.436Z" }, + { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055, upload-time = "2025-07-01T09:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110, upload-time = "2025-07-01T09:14:59.79Z" }, + { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547, upload-time = "2025-07-01T09:15:01.648Z" }, + { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554, upload-time = "2025-07-03T13:10:27.018Z" }, + { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132, upload-time = "2025-07-03T13:10:33.01Z" }, + { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001, upload-time = "2025-07-01T09:15:03.365Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814, upload-time = "2025-07-01T09:15:05.655Z" }, + { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124, upload-time = "2025-07-01T09:15:07.358Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5a/6fec59b1dfb619234f7636d4157d11fb4e196caeee220232a8d2ec48488d/pillow-11.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c", size = 6747186, upload-time = "2025-07-01T09:15:09.317Z" }, + { url = "https://files.pythonhosted.org/packages/49/6b/00187a044f98255225f172de653941e61da37104a9ea60e4f6887717e2b5/pillow-11.3.0-cp313-cp313t-win32.whl", hash = "sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788", size = 6277546, upload-time = "2025-07-01T09:15:11.311Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5c/6caaba7e261c0d75bab23be79f1d06b5ad2a2ae49f028ccec801b0e853d6/pillow-11.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31", size = 6985102, upload-time = "2025-07-01T09:15:13.164Z" }, + { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803, upload-time = "2025-07-01T09:15:15.695Z" }, + { url = "https://files.pythonhosted.org/packages/73/f4/04905af42837292ed86cb1b1dabe03dce1edc008ef14c473c5c7e1443c5d/pillow-11.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12", size = 5278520, upload-time = "2025-07-01T09:15:17.429Z" }, + { url = "https://files.pythonhosted.org/packages/41/b0/33d79e377a336247df6348a54e6d2a2b85d644ca202555e3faa0cf811ecc/pillow-11.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a", size = 4686116, upload-time = "2025-07-01T09:15:19.423Z" }, + { url = "https://files.pythonhosted.org/packages/49/2d/ed8bc0ab219ae8768f529597d9509d184fe8a6c4741a6864fea334d25f3f/pillow-11.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632", size = 5864597, upload-time = "2025-07-03T13:10:38.404Z" }, + { url = "https://files.pythonhosted.org/packages/b5/3d/b932bb4225c80b58dfadaca9d42d08d0b7064d2d1791b6a237f87f661834/pillow-11.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673", size = 7638246, upload-time = "2025-07-03T13:10:44.987Z" }, + { url = "https://files.pythonhosted.org/packages/09/b5/0487044b7c096f1b48f0d7ad416472c02e0e4bf6919541b111efd3cae690/pillow-11.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027", size = 5973336, upload-time = "2025-07-01T09:15:21.237Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2d/524f9318f6cbfcc79fbc004801ea6b607ec3f843977652fdee4857a7568b/pillow-11.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77", size = 6642699, upload-time = "2025-07-01T09:15:23.186Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d2/a9a4f280c6aefedce1e8f615baaa5474e0701d86dd6f1dede66726462bbd/pillow-11.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874", size = 6083789, upload-time = "2025-07-01T09:15:25.1Z" }, + { url = "https://files.pythonhosted.org/packages/fe/54/86b0cd9dbb683a9d5e960b66c7379e821a19be4ac5810e2e5a715c09a0c0/pillow-11.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a", size = 6720386, upload-time = "2025-07-01T09:15:27.378Z" }, + { url = "https://files.pythonhosted.org/packages/e7/95/88efcaf384c3588e24259c4203b909cbe3e3c2d887af9e938c2022c9dd48/pillow-11.3.0-cp314-cp314-win32.whl", hash = "sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214", size = 6370911, upload-time = "2025-07-01T09:15:29.294Z" }, + { url = "https://files.pythonhosted.org/packages/2e/cc/934e5820850ec5eb107e7b1a72dd278140731c669f396110ebc326f2a503/pillow-11.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635", size = 7117383, upload-time = "2025-07-01T09:15:31.128Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e9/9c0a616a71da2a5d163aa37405e8aced9a906d574b4a214bede134e731bc/pillow-11.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6", size = 2511385, upload-time = "2025-07-01T09:15:33.328Z" }, + { url = "https://files.pythonhosted.org/packages/1a/33/c88376898aff369658b225262cd4f2659b13e8178e7534df9e6e1fa289f6/pillow-11.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae", size = 5281129, upload-time = "2025-07-01T09:15:35.194Z" }, + { url = "https://files.pythonhosted.org/packages/1f/70/d376247fb36f1844b42910911c83a02d5544ebd2a8bad9efcc0f707ea774/pillow-11.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653", size = 4689580, upload-time = "2025-07-01T09:15:37.114Z" }, + { url = "https://files.pythonhosted.org/packages/eb/1c/537e930496149fbac69efd2fc4329035bbe2e5475b4165439e3be9cb183b/pillow-11.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6", size = 5902860, upload-time = "2025-07-03T13:10:50.248Z" }, + { url = "https://files.pythonhosted.org/packages/bd/57/80f53264954dcefeebcf9dae6e3eb1daea1b488f0be8b8fef12f79a3eb10/pillow-11.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36", size = 7670694, upload-time = "2025-07-03T13:10:56.432Z" }, + { url = "https://files.pythonhosted.org/packages/70/ff/4727d3b71a8578b4587d9c276e90efad2d6fe0335fd76742a6da08132e8c/pillow-11.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b", size = 6005888, upload-time = "2025-07-01T09:15:39.436Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/716592277934f85d3be51d7256f3636672d7b1abfafdc42cf3f8cbd4b4c8/pillow-11.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477", size = 6670330, upload-time = "2025-07-01T09:15:41.269Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7fe6cddcc8827b01b1a9766f5fdeb7418680744f9082035bdbabecf1d57f/pillow-11.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50", size = 6114089, upload-time = "2025-07-01T09:15:43.13Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f5/06bfaa444c8e80f1a8e4bff98da9c83b37b5be3b1deaa43d27a0db37ef84/pillow-11.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b", size = 6748206, upload-time = "2025-07-01T09:15:44.937Z" }, + { url = "https://files.pythonhosted.org/packages/f0/77/bc6f92a3e8e6e46c0ca78abfffec0037845800ea38c73483760362804c41/pillow-11.3.0-cp314-cp314t-win32.whl", hash = "sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12", size = 6377370, upload-time = "2025-07-01T09:15:46.673Z" }, + { url = "https://files.pythonhosted.org/packages/4a/82/3a721f7d69dca802befb8af08b7c79ebcab461007ce1c18bd91a5d5896f9/pillow-11.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db", size = 7121500, upload-time = "2025-07-01T09:15:48.512Z" }, + { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload-time = "2025-07-01T09:15:50.399Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8e/9c089f01677d1264ab8648352dcb7773f37da6ad002542760c80107da816/pillow-11.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:48d254f8a4c776de343051023eb61ffe818299eeac478da55227d96e241de53f", size = 5316478, upload-time = "2025-07-01T09:15:52.209Z" }, + { url = "https://files.pythonhosted.org/packages/b5/a9/5749930caf674695867eb56a581e78eb5f524b7583ff10b01b6e5048acb3/pillow-11.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7aee118e30a4cf54fdd873bd3a29de51e29105ab11f9aad8c32123f58c8f8081", size = 4686522, upload-time = "2025-07-01T09:15:54.162Z" }, + { url = "https://files.pythonhosted.org/packages/43/46/0b85b763eb292b691030795f9f6bb6fcaf8948c39413c81696a01c3577f7/pillow-11.3.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:23cff760a9049c502721bdb743a7cb3e03365fafcdfc2ef9784610714166e5a4", size = 5853376, upload-time = "2025-07-03T13:11:01.066Z" }, + { url = "https://files.pythonhosted.org/packages/5e/c6/1a230ec0067243cbd60bc2dad5dc3ab46a8a41e21c15f5c9b52b26873069/pillow-11.3.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6359a3bc43f57d5b375d1ad54a0074318a0844d11b76abccf478c37c986d3cfc", size = 7626020, upload-time = "2025-07-03T13:11:06.479Z" }, + { url = "https://files.pythonhosted.org/packages/63/dd/f296c27ffba447bfad76c6a0c44c1ea97a90cb9472b9304c94a732e8dbfb/pillow-11.3.0-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:092c80c76635f5ecb10f3f83d76716165c96f5229addbd1ec2bdbbda7d496e06", size = 5956732, upload-time = "2025-07-01T09:15:56.111Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a0/98a3630f0b57f77bae67716562513d3032ae70414fcaf02750279c389a9e/pillow-11.3.0-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cadc9e0ea0a2431124cde7e1697106471fc4c1da01530e679b2391c37d3fbb3a", size = 6624404, upload-time = "2025-07-01T09:15:58.245Z" }, + { url = "https://files.pythonhosted.org/packages/de/e6/83dfba5646a290edd9a21964da07674409e410579c341fc5b8f7abd81620/pillow-11.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:6a418691000f2a418c9135a7cf0d797c1bb7d9a485e61fe8e7722845b95ef978", size = 6067760, upload-time = "2025-07-01T09:16:00.003Z" }, + { url = "https://files.pythonhosted.org/packages/bc/41/15ab268fe6ee9a2bc7391e2bbb20a98d3974304ab1a406a992dcb297a370/pillow-11.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:97afb3a00b65cc0804d1c7abddbf090a81eaac02768af58cbdcaaa0a931e0b6d", size = 6700534, upload-time = "2025-07-01T09:16:02.29Z" }, + { url = "https://files.pythonhosted.org/packages/64/79/6d4f638b288300bed727ff29f2a3cb63db054b33518a95f27724915e3fbc/pillow-11.3.0-cp39-cp39-win32.whl", hash = "sha256:ea944117a7974ae78059fcc1800e5d3295172bb97035c0c1d9345fca1419da71", size = 6277091, upload-time = "2025-07-01T09:16:04.4Z" }, + { url = "https://files.pythonhosted.org/packages/46/05/4106422f45a05716fd34ed21763f8ec182e8ea00af6e9cb05b93a247361a/pillow-11.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:e5c5858ad8ec655450a7c7df532e9842cf8df7cc349df7225c60d5d348c8aada", size = 6986091, upload-time = "2025-07-01T09:16:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/63/c6/287fd55c2c12761d0591549d48885187579b7c257bef0c6660755b0b59ae/pillow-11.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:6abdbfd3aea42be05702a8dd98832329c167ee84400a1d1f61ab11437f1717eb", size = 2422632, upload-time = "2025-07-01T09:16:08.142Z" }, + { url = "https://files.pythonhosted.org/packages/6f/8b/209bd6b62ce8367f47e68a218bffac88888fdf2c9fcf1ecadc6c3ec1ebc7/pillow-11.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3cee80663f29e3843b68199b9d6f4f54bd1d4a6b59bdd91bceefc51238bcb967", size = 5270556, upload-time = "2025-07-01T09:16:09.961Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e6/231a0b76070c2cfd9e260a7a5b504fb72da0a95279410fa7afd99d9751d6/pillow-11.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b5f56c3f344f2ccaf0dd875d3e180f631dc60a51b314295a3e681fe8cf851fbe", size = 4654625, upload-time = "2025-07-01T09:16:11.913Z" }, + { url = "https://files.pythonhosted.org/packages/13/f4/10cf94fda33cb12765f2397fc285fa6d8eb9c29de7f3185165b702fc7386/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e67d793d180c9df62f1f40aee3accca4829d3794c95098887edc18af4b8b780c", size = 4874207, upload-time = "2025-07-03T13:11:10.201Z" }, + { url = "https://files.pythonhosted.org/packages/72/c9/583821097dc691880c92892e8e2d41fe0a5a3d6021f4963371d2f6d57250/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d000f46e2917c705e9fb93a3606ee4a819d1e3aa7a9b442f6444f07e77cf5e25", size = 6583939, upload-time = "2025-07-03T13:11:15.68Z" }, + { url = "https://files.pythonhosted.org/packages/3b/8e/5c9d410f9217b12320efc7c413e72693f48468979a013ad17fd690397b9a/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:527b37216b6ac3a12d7838dc3bd75208ec57c1c6d11ef01902266a5a0c14fc27", size = 4957166, upload-time = "2025-07-01T09:16:13.74Z" }, + { url = "https://files.pythonhosted.org/packages/62/bb/78347dbe13219991877ffb3a91bf09da8317fbfcd4b5f9140aeae020ad71/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be5463ac478b623b9dd3937afd7fb7ab3d79dd290a28e2b6df292dc75063eb8a", size = 5581482, upload-time = "2025-07-01T09:16:16.107Z" }, + { url = "https://files.pythonhosted.org/packages/d9/28/1000353d5e61498aaeaaf7f1e4b49ddb05f2c6575f9d4f9f914a3538b6e1/pillow-11.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:8dc70ca24c110503e16918a658b869019126ecfe03109b754c402daff12b3d9f", size = 6984596, upload-time = "2025-07-01T09:16:18.07Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e3/6fa84033758276fb31da12e5fb66ad747ae83b93c67af17f8c6ff4cc8f34/pillow-11.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6", size = 5270566, upload-time = "2025-07-01T09:16:19.801Z" }, + { url = "https://files.pythonhosted.org/packages/5b/ee/e8d2e1ab4892970b561e1ba96cbd59c0d28cf66737fc44abb2aec3795a4e/pillow-11.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438", size = 4654618, upload-time = "2025-07-01T09:16:21.818Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6d/17f80f4e1f0761f02160fc433abd4109fa1548dcfdca46cfdadaf9efa565/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3", size = 4874248, upload-time = "2025-07-03T13:11:20.738Z" }, + { url = "https://files.pythonhosted.org/packages/de/5f/c22340acd61cef960130585bbe2120e2fd8434c214802f07e8c03596b17e/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c", size = 6583963, upload-time = "2025-07-03T13:11:26.283Z" }, + { url = "https://files.pythonhosted.org/packages/31/5e/03966aedfbfcbb4d5f8aa042452d3361f325b963ebbadddac05b122e47dd/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361", size = 4957170, upload-time = "2025-07-01T09:16:23.762Z" }, + { url = "https://files.pythonhosted.org/packages/cc/2d/e082982aacc927fc2cab48e1e731bdb1643a1406acace8bed0900a61464e/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7", size = 5581505, upload-time = "2025-07-01T09:16:25.593Z" }, + { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598, upload-time = "2025-07-01T09:16:27.732Z" }, +] + +[[package]] +name = "pillow" +version = "12.3.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15'", "python_full_version >= '3.12' and python_full_version < '3.15'", "python_full_version == '3.11.*'", "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/c2/669d88644cddb1485bd9534e63e8cf476c8e51cb3c3a1297677023505c0e/pillow-12.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6c0016e7b354317c4e9e525b937ac8596c38d2d232b419529b9cd7a1cd46e39a", size = 5392418, upload-time = "2026-07-01T11:53:27.808Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ba/3762f376a2948e3036488d773a146e0ae6ecc2ca03ac20e2615bd0b2ba02/pillow-12.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bcc33feacfaefce60c12fd500a277533bdc02b10a19f7f6d348763d8140bbba7", size = 4785287, upload-time = "2026-07-01T11:53:29.761Z" }, + { url = "https://files.pythonhosted.org/packages/07/50/b5d688cc9c52d4482f3d5bcab6ce20bc2a74a85d2343841c907444a3be2c/pillow-12.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5594fc43d548a7ed94949d139aa1341b270f1863f11cfd37f5a6c8b778a6b67f", size = 6253754, upload-time = "2026-07-01T11:53:32.298Z" }, + { url = "https://files.pythonhosted.org/packages/4e/89/36f4cd76cf4baf05c50ababb976249153f18c959171c7f6ba09a6f217260/pillow-12.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0606c8bf2cdefea14a43530f7657cbbb7ecf1c4222512492ef4a4434a9501ec", size = 6925605, upload-time = "2026-07-01T11:53:34.487Z" }, + { url = "https://files.pythonhosted.org/packages/eb/c0/4de58cf6633b9e3a6061ef4be6fb91fc3c90b812ece886f531e3c523d777/pillow-12.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:85f998ea1848bc6757289e739cfbdda3a04adfd58b02fc018ce54d754a5ce468", size = 6327788, upload-time = "2026-07-01T11:53:36.433Z" }, + { url = "https://files.pythonhosted.org/packages/87/3c/14d53682a19550dbbaf3b598f807d5457646c510805a44c7d7891cd1cd1a/pillow-12.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:25b9b82bb22e6e2b3cd07b39c68b7b862001226cb3dff7130d1cb914121b39ed", size = 7036288, upload-time = "2026-07-01T11:53:38.712Z" }, + { url = "https://files.pythonhosted.org/packages/38/1d/36279e3c77efe034e4cc2b0393ee74ffdb5a62391dacbf9b916154f5f0b8/pillow-12.3.0-cp310-cp310-win32.whl", hash = "sha256:37dc8f7bbb66efe481bb60defacef820c950c24713fb44962ed6aa2a50966de1", size = 6472396, upload-time = "2026-07-01T11:53:40.781Z" }, + { url = "https://files.pythonhosted.org/packages/48/7c/8fa0039574c476d7c6fa57dd7c32a130436877c6ec1e5ce1cc8ec44878c1/pillow-12.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:300557495eb45ebb8aec96c2da9c4be642fbf7cd937278b4013ba894ea8eb0eb", size = 7226887, upload-time = "2026-07-01T11:53:42.764Z" }, + { url = "https://files.pythonhosted.org/packages/fa/17/e324be141d173c1c919428066c3259f21c1b8982e564e01a4a81e96dbdcf/pillow-12.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:514435a37670e3e5e08f3945b68718b6ed329bb84367777e16f9f4dfe1e61a0f", size = 2568039, upload-time = "2026-07-01T11:53:45.372Z" }, + { url = "https://files.pythonhosted.org/packages/fb/c8/0a78b0e02d7ac54bc03e5321c9220da52f0c2ea83b21f7c40e7f3169c502/pillow-12.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:00808c5e14ef63ac5161091d242999076604ff74b883423a11e5d7bbb38bf756", size = 5392415, upload-time = "2026-07-01T11:53:47.162Z" }, + { url = "https://files.pythonhosted.org/packages/b2/5b/a02d30018abd97ced9f5a6c63d28597694a00d066516b9c1c6de45859fc9/pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6", size = 4785266, upload-time = "2026-07-01T11:53:49.079Z" }, + { url = "https://files.pythonhosted.org/packages/c8/98/766667a4be768150a202836acd9fad19c06824ca86c4286d3cf6b274964e/pillow-12.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcb46e2f9feff8d06323983bd83ed00c201fdcab3d74973e7072a889b3979fcd", size = 6263814, upload-time = "2026-07-01T11:53:51.32Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2d/ede717bc1144f63886c21fd349bb95860b0d1a21149ff16f2bb362b612b6/pillow-12.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23d27a3e0307ec2244cc51e7287b919aa68d097504ebe19df4e76a98a3eea5bd", size = 6934408, upload-time = "2026-07-01T11:53:53.487Z" }, + { url = "https://files.pythonhosted.org/packages/a3/48/9c58b685e69d49c31af6c8eb9012055fab7e665785165c84796e2c73ce72/pillow-12.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4f883547d4b7f0495ebe7056b0cc2aea76094e7a4abc8e933540f3271df27d9c", size = 6337160, upload-time = "2026-07-01T11:53:55.457Z" }, + { url = "https://files.pythonhosted.org/packages/ff/fa/dc2a5c0ba6df93f67c31d34b808b7ce440b40cdbf96f0b81cde1d1e6fa93/pillow-12.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:236ff70b9312fb68943c703aa842ca6a758abfa45ac187a5e7c1452e96ef72b5", size = 7045172, upload-time = "2026-07-01T11:53:57.736Z" }, + { url = "https://files.pythonhosted.org/packages/86/a5/444817a4d4c4c2417df00513086ca196f388d8f9ef40c2e4ccd1ad1af54b/pillow-12.3.0-cp311-cp311-win32.whl", hash = "sha256:10e41f0fbf1eec8cfd234b8fe17a4caac7c9d0db4c204d3c173a8f9f6ef3232b", size = 6472232, upload-time = "2026-07-01T11:53:59.767Z" }, + { url = "https://files.pythonhosted.org/packages/63/c6/4bad1b18d132a50b27e1365e1ab163616f7a5bb56d330f66f9d1d9d4f9d4/pillow-12.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8e95e1385e4998ae9694eeaa4730ba5457ff61185b3a55e2e7bea0880aef452a", size = 7233653, upload-time = "2026-07-01T11:54:02.066Z" }, + { url = "https://files.pythonhosted.org/packages/fd/16/00f91ab7760dc842f5aad55217e80fc4a7067a0604535249bc8a2d6d9870/pillow-12.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:ebaea975e03d3141d9d3a507df75c9b3ec90fa9d2ffd07567b3a978d9d790b26", size = 2568195, upload-time = "2026-07-01T11:54:04.622Z" }, + { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" }, + { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" }, + { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" }, + { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" }, + { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" }, + { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" }, + { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" }, + { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" }, + { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" }, + { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" }, + { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" }, + { url = "https://files.pythonhosted.org/packages/dc/01/001f65b68192f0228cc1dbbc8d2530ab5d58b61037ba0587f946fea607cd/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9cf95fe4d0f84c82d282745d9bb08ad9f926efa00be4697e767b814ce40d4330", size = 4161736, upload-time = "2026-07-01T11:54:51.156Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d2/0219746d0fd16fc8a84498e79452375be3797d3ce4044596ce565164b84f/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8728f216dcdb6e6d555cf971cb34076139ad74b31fc2c14da4fafc741c5f6217", size = 4255435, upload-time = "2026-07-01T11:54:53.414Z" }, + { url = "https://files.pythonhosted.org/packages/c8/02/8d0bc62ef0302318c46ff2a512822d2610e81c7aa46c9b3abe6cbaca5ad0/pillow-12.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a45650e8ce7fafffd731db8550230db6b0d306d181a90b67d3e6bca2f1990930", size = 3696262, upload-time = "2026-07-01T11:54:55.739Z" }, + { url = "https://files.pythonhosted.org/packages/85/e2/73c77d218410b14f5f2d565e8a998d5317b7b9c75368d29985139f7a46f0/pillow-12.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ba54cfebe86920a559a7c4d6b9050791c20513650a1952ebe3368c7dc70306f8", size = 5350344, upload-time = "2026-07-01T11:54:57.657Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/32c752228ae345f489e3a42499d817b6c3996da7e8a3bc7a04fc806b243b/pillow-12.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e158cb00350dc278f3b91551101aa7d12415a66ebf2c91d8d5ac14e56ddd3ad0", size = 4780131, upload-time = "2026-07-01T11:54:59.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/9d/8b2c807dbef61a5197c047afe99823787eb66f63daf9fb2432f91d6f0462/pillow-12.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9aeb04d6aef139de265b29683e119b638208f88cf73cdd1658aa07221165321", size = 6263757, upload-time = "2026-07-01T11:55:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/5c/44/c85361f65dbe00eea8576ee467c768d25129989efb76e94f205e9ca9bb46/pillow-12.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:251bf95b67017e27b13d82f5b326234ca62d70f9cf4c2b9032de2358a3b12c7b", size = 6936962, upload-time = "2026-07-01T11:55:03.93Z" }, + { url = "https://files.pythonhosted.org/packages/18/7e/e483414b35800b86b6f08dbbc7803fb5cd52c4d6f897f47d53ea2c7e6f65/pillow-12.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fe3cca2e4e8a592be0f269a1ca4835c25199d9f3ce815c8491048f785b0a0198", size = 6339171, upload-time = "2026-07-01T11:55:05.989Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f4/68c491844841ede6bed70189546b3ee9731cf9f2cbad396faff5e1ccba45/pillow-12.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:23aceaa007d6172b02c277f0cd359c79492bbb14f7072b4ede9fbcaf20648130", size = 7048116, upload-time = "2026-07-01T11:55:08.131Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/77f3f793fed8efc7d243f21b33c5a3f0d1c97ee70346d3db855587e155ff/pillow-12.3.0-cp314-cp314-win32.whl", hash = "sha256:af8d94b0db561cf68b88a267c5c44b49e134f525d0dc2cb7ed413a66bc23559a", size = 6467209, upload-time = "2026-07-01T11:55:10.408Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e0/492879f69d94f91f60fc8cd05ba03650e9520afebb2fb7aa12777d7c7f38/pillow-12.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:fdafc9cce40277e0f7a0feabce0ee50dd2fa1800f3b38015e51296b5e814048d", size = 7237707, upload-time = "2026-07-01T11:55:12.745Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ac/6b11f2875f1c2ac040d84e1bbf9cf22a88038f901ca1037898b280b38365/pillow-12.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:e91206ee562682b51b98ef4b26a6ef48fd84e15fd4c4bc5ec768eb641d206838", size = 2565995, upload-time = "2026-07-01T11:55:14.736Z" }, + { url = "https://files.pythonhosted.org/packages/52/69/c2208e56af9bfc1913afb24020297a691eb1d4ef688474c8a04913f65e04/pillow-12.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:164b31cd1a0490ab6efae01aa5df49da7061be0af1b30e035b6e9a1bfe34ee6e", size = 5352503, upload-time = "2026-07-01T11:55:17.076Z" }, + { url = "https://files.pythonhosted.org/packages/07/70/e5686d753e898a45d778ff1718dba8516ead6ab6b95d85fc8c4b70650cf2/pillow-12.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5afb51d599ea772b8365ae807ae557f18bccfe46ab261fd1c2a9ed700fc6eb17", size = 4782956, upload-time = "2026-07-01T11:55:19.448Z" }, + { url = "https://files.pythonhosted.org/packages/d5/37/25c6692f06927ee973ff18c8d9ee98ad0b4d84ee67a09610c2dd1447958e/pillow-12.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3edce1d53195db527e0191f84b71d02022de0540bf43a16ed734ed7537b07385", size = 6322855, upload-time = "2026-07-01T11:55:21.613Z" }, + { url = "https://files.pythonhosted.org/packages/cc/91/420637fcb8f1bc11029e403b4538e6694744428d8246118e45719f944556/pillow-12.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf16ba1b4d0b6b7c8e534936632270cf70eb00dbe09005bc345b2677b726855c", size = 6989642, upload-time = "2026-07-01T11:55:24.006Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/b94d7811281ccf0d143a1cf768d1c49e1e54af63e7b708ab2ee3eb87face/pillow-12.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:24870b09b224f7ae3c39ed07d10e819d06f8720bc551847b1d623832b5b0e28d", size = 6391281, upload-time = "2026-07-01T11:55:26.252Z" }, + { url = "https://files.pythonhosted.org/packages/d2/87/24233f785f55474dc02ce3e739c5528a77e3a862e9333d1dd7a25cc31f70/pillow-12.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:30f2aa603c41533cc25c05acd0da21636e84a315768feb631c937177db558931", size = 7096716, upload-time = "2026-07-01T11:55:28.318Z" }, + { url = "https://files.pythonhosted.org/packages/23/26/fcb2f6e37175b04f53570b59937867e2b80ee1685e744023153028fc14f9/pillow-12.3.0-cp314-cp314t-win32.whl", hash = "sha256:4b0a7fe987b14c31ebda6083f74f22b561fd3739bc0ac51e019622e3d72668c7", size = 6474125, upload-time = "2026-07-01T11:55:30.956Z" }, + { url = "https://files.pythonhosted.org/packages/90/de/3634abee5f1c9e13c56787b7d5517b0ba8d6de51700b95578cf338349c9f/pillow-12.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:962864dc93511324d51ddbb5b9f8731bf71675b93ca612a07441896f4688fb8c", size = 7242939, upload-time = "2026-07-01T11:55:34.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/2a/fd13f8eb24de5714a6eb444a3d67e2842c6c576e159a43793adf23051351/pillow-12.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45", size = 2567506, upload-time = "2026-07-01T11:55:35.988Z" }, + { url = "https://files.pythonhosted.org/packages/5d/dc/8fdce34ec725a33c81c6ba122b904d6b9024e50ea9ac7bede62fab54506c/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0feb2e9d6ad6c9e3c06effe9d00f3f1e618a6643273576b016f591e9315a7139", size = 4162063, upload-time = "2026-07-01T11:55:37.941Z" }, + { url = "https://files.pythonhosted.org/packages/76/66/2044b9a63d3b84ff048228dfcb7cd9bf0df983e8470971bf7d4c57b693de/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9e881fca225083806662a5c43d627d215f258ff43c890f831966c7d7ba9c7402", size = 4255549, upload-time = "2026-07-01T11:55:40.022Z" }, + { url = "https://files.pythonhosted.org/packages/52/7e/1f67e6f4ece6b582ee4b539decbcc9f848dc245a93ed8cd7338bafef72f1/pillow-12.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:4998562bf62a445225f22e07c896bb04b35b1b1f2eb6d760584c9c51d7a5f78c", size = 3696331, upload-time = "2026-07-01T11:55:41.98Z" }, + { url = "https://files.pythonhosted.org/packages/12/40/d306fc2c8e4d45d7f175c77edca7063be7b86fe7fe6e68f4353bf71d808c/pillow-12.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:dc624f6bc473dacdf7ef7eb8678d0d08edf15cd94fad6ae5c7d6cc67a4e4902f", size = 5350370, upload-time = "2026-07-01T11:55:44.028Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/668fb1437e8ce420f62d6106eb66e44a5971602a4d794615bdf79315d82d/pillow-12.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:71d6097b330eea8fd15097780c8e89cb1a8ce7838669f48c5bacd6f663dd4701", size = 4780147, upload-time = "2026-07-01T11:55:46.073Z" }, + { url = "https://files.pythonhosted.org/packages/0c/08/93fa2e70e30a2d81547e481b6ee2bb9522117221fb1e0ce4b5df70967677/pillow-12.3.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28ce87c5ab450a9dd970b52e5aca5fe63ed432d18a2eaddd1979a00a1ba24ace", size = 6273659, upload-time = "2026-07-01T11:55:48.264Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6d/043e96ff814fc31a33077e4cba86082167db520c93632afdf2042febbb0c/pillow-12.3.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b02afb9b97f65fbca5f31db6a2a3ba21aa93030225f150fa3f249717e938fb4", size = 6947439, upload-time = "2026-07-01T11:55:50.503Z" }, + { url = "https://files.pythonhosted.org/packages/af/92/ba71d2ee2ac0edf3fa33bd9d5ee9ee080da70b1766f3ca3934f9938ddac9/pillow-12.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:1182d52bc2d5e5d7d0949503aa7e36d12f42205dc287e4883f407b1988820d39", size = 6353577, upload-time = "2026-07-01T11:55:52.697Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ce/e63064e2122923ff687c8ad792d0d736a7b3920a56a46982e81a7fdd25d6/pillow-12.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e795b7eb908249c4e43c7c99fac7c2c75dab0c43566e37db472a355f63693d71", size = 7060394, upload-time = "2026-07-01T11:55:55.149Z" }, + { url = "https://files.pythonhosted.org/packages/54/76/a09cc3ccc8d773a7283d34c38bec1708f9e3cc932093cbc4c5e71ac4060b/pillow-12.3.0-cp315-cp315-win32.whl", hash = "sha256:57b3d78c95ba9059768b10e28b813002261d3f3dfc55cc48b0c988f625175827", size = 6467375, upload-time = "2026-07-01T11:55:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/3e/03/1846c49ba3b1d5550392a4bbd06d6fb4578e1cd91a803198b5c90f5f7d53/pillow-12.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:fa4ecea169a355be7a3ade2c783e2ed12f0e40d2c5621cda8b3297faf7fbb9f5", size = 7237048, upload-time = "2026-07-01T11:55:59.975Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bb/89f35dcc79610423f9f195504d7def7f0d1416a711541b42867e25fe3412/pillow-12.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:877c3f311ff35410f690861c4409e7ccbf0cd2f878e50628a28e5a0bb689e658", size = 2566006, upload-time = "2026-07-01T11:56:02.143Z" }, + { url = "https://files.pythonhosted.org/packages/30/88/707027ba09942dfa2c28759b5c222d769290a41c6d20ea60ec250801941f/pillow-12.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:e9871b1ffbfa9656b60aeee92ed5136a5742696006fa322b29ea3d8da0ecc9cf", size = 5352509, upload-time = "2026-07-01T11:56:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6d/00352fa25332c2569cd387851f568cc5a4b75a9adbfb37ac4fbce4c02eec/pillow-12.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53aa02d20d10c3d814d536aa4e5ac9b84ca0ff5a88377963b085ad6822f93e64", size = 4783167, upload-time = "2026-07-01T11:56:06.631Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/9e049dfa21af7c22427275720e2490267ba8138120add5c4c574deb69782/pillow-12.3.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:446c34dcc4324b084a53b705127dc15717b22c5e140ae0a3c38349d4efec071e", size = 6329237, upload-time = "2026-07-01T11:56:08.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/16/cf6eeaae8d0fce8dd390a33437cf68c5d5bd73834a2bc6e2f14efda0ab45/pillow-12.3.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf1845d02ad822a369a49f2bb9345b1614744267682e7a03527dc3bf6eea1777", size = 6997047, upload-time = "2026-07-01T11:56:11.379Z" }, + { url = "https://files.pythonhosted.org/packages/1e/69/dbf769bdd55f48bf5733cac28edc6364ffaa072ec9ba336266e4fe66be55/pillow-12.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:186941b6aef820ad110fb01fb06eb925374dc3a21b17e37ec9a53b250c6fe2d1", size = 6400440, upload-time = "2026-07-01T11:56:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e1/ffc9cfc2eea0d178da8018e18e959301ad9d6bc9f3edb7181e748a474b97/pillow-12.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f13c32a3abd6079a66d9526e18dad9b6d280384d49d7c54040cd57b6424041d9", size = 7105895, upload-time = "2026-07-01T11:56:16.575Z" }, + { url = "https://files.pythonhosted.org/packages/18/f0/a5595c1e8c3ae44b9828cb2f0fa8155e5095ef04d6327b8f61cf44a3df85/pillow-12.3.0-cp315-cp315t-win32.whl", hash = "sha256:1657923d2d45afb66526e5b933e5b3052e6bdea196c90d3abb2424e18c77dae8", size = 6474384, upload-time = "2026-07-01T11:56:18.855Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/62bcd9f844984c5938d3b05264a61d797a29d3e0812341a8204af70bbdee/pillow-12.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:8cd2f7bdda092d99c9fc2fb7391354f306d01443d22785d0cbfafa2e2c8bb418", size = 7243537, upload-time = "2026-07-01T11:56:21.214Z" }, + { url = "https://files.pythonhosted.org/packages/3d/68/1f3066acedf37673694a7141381d8f811ae97f30d34413d236abe7d489f1/pillow-12.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59", size = 2567491, upload-time = "2026-07-01T11:56:23.506Z" }, + { url = "https://files.pythonhosted.org/packages/75/18/2e8b40223153ccbc60df07f9e8928dc0c76202aa4e55ae9f53962b6510d6/pillow-12.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b3c777e849237620b022f7f297dd67705f9f5cf1685f09f02e46f93e92725468", size = 5302510, upload-time = "2026-07-01T11:56:25.736Z" }, + { url = "https://files.pythonhosted.org/packages/46/3e/51fabf59d5ab801ceab709453d3ab6b180083496579549de4c45ced6528a/pillow-12.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b343699e8308bdc51978310e1c959c584e7869cc8c40780058c87da7781a1e94", size = 4736058, upload-time = "2026-07-01T11:56:28.041Z" }, + { url = "https://files.pythonhosted.org/packages/bf/20/22fe9384b7949e25fb1293bcfc84fb82590ff4ea6b37c95b24d26d793d86/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbd139c8447d25dd750ab79ee274cc5e1fe80fc56340ab10b18a195e1b6eca3e", size = 5237776, upload-time = "2026-07-01T11:56:30.263Z" }, + { url = "https://files.pythonhosted.org/packages/08/14/f6ba68107680ffa74b39985f3f30884e41318fbc4250caa423c79b4788bb/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7e480451b9fa137494bccd3a7d69adbe8ac65a87d97be61e11f1b1050a5bac3", size = 5860358, upload-time = "2026-07-01T11:56:32.68Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0169bc772ec491108b62f644f8ecf1fe5d8ae5ebafde2ee2142210166903/pillow-12.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:04f01d28a6aaff387bf842a13be313df23ba0597a44f1a976c9feb3c6ff4711a", size = 7231786, upload-time = "2026-07-01T11:56:35.046Z" }, +] + +[[package]] +name = "pip" +version = "25.0.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/70/53/b309b4a497b09655cb7e07088966881a57d082f48ac3cb54ea729fd2c6cf/pip-25.0.1.tar.gz", hash = "sha256:88f96547ea48b940a3a385494e181e29fb8637898f88d88737c5049780f196ea", size = 1950850, upload-time = "2025-02-09T17:14:04.423Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/bc/b7db44f5f39f9d0494071bddae6880eb645970366d0a200022a1a93d57f5/pip-25.0.1-py3-none-any.whl", hash = "sha256:c46efd13b6aa8279f33f2864459c8ce587ea6a1a59ee20de055868d8f7688f7f", size = 1841526, upload-time = "2025-02-09T17:14:01.463Z" }, +] + +[[package]] +name = "pip" +version = "26.0.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ "python_full_version == '3.9.*'", ] -sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +sdist = { url = "https://files.pythonhosted.org/packages/48/83/0d7d4e9efe3344b8e2fe25d93be44f64b65364d3c8d7bc6dc90198d5422e/pip-26.0.1.tar.gz", hash = "sha256:c4037d8a277c89b320abe636d59f91e6d0922d08a05b60e85e53b296613346d8", size = 1812747, upload-time = "2026-02-05T02:20:18.702Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, + { url = "https://files.pythonhosted.org/packages/de/f0/c81e05b613866b76d2d1066490adf1a3dbc4ee9d9c839961c3fc8a6997af/pip-26.0.1-py3-none-any.whl", hash = "sha256:bdb1b08f4274833d62c1aa29e20907365a2ceb950410df15fc9521bad440122b", size = 1787723, upload-time = "2026-02-05T02:20:16.416Z" }, +] + +[[package]] +name = "pip" +version = "26.1.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/01/91/47e7d486260f618783899587af63ccf7980fb60245c3e63dd4571c6b57ad/pip-26.1.2.tar.gz", hash = "sha256:f49cd134c61cf2fd75e0ce2676db03e4054504a5a4986d00f8299ae632dc4605", size = 1840799, upload-time = "2026-05-31T17:33:58.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/95/6b5cb3461ea5673ba0995989746db58eb18b91b54dbf331e72f569540946/pip-26.1.2-py3-none-any.whl", hash = "sha256:382ff9f685ee3bc25864f820aa50505825f10f5458ffff07e30a6d96e5715cab", size = 1813144, upload-time = "2026-05-31T17:33:56.772Z" }, +] + +[[package]] +name = "pip-api" +version = "0.0.34" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pip", version = "25.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "pip", version = "26.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "pip", version = "26.1.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/f1/ee85f8c7e82bccf90a3c7aad22863cc6e20057860a1361083cd2adacb92e/pip_api-0.0.34.tar.gz", hash = "sha256:9b75e958f14c5a2614bae415f2adf7eeb54d50a2cfbe7e24fd4826471bac3625", size = 123017, upload-time = "2024-07-09T20:32:30.641Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/f7/ebf5003e1065fd00b4cbef53bf0a65c3d3e1b599b676d5383ccb7a8b88ba/pip_api-0.0.34-py3-none-any.whl", hash = "sha256:8b2d7d7c37f2447373aa2cf8b1f60a2f2b27a84e1e9e0294a3f6ef10eb3ba6bb", size = 120369, upload-time = "2024-07-09T20:32:29.099Z" }, +] + +[[package]] +name = "pip-audit" +version = "2.7.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +dependencies = [ + { name = "cachecontrol", version = "0.14.2", source = { registry = "https://pypi.org/simple" }, extra = ["filecache"], marker = "python_full_version < '3.9'" }, + { name = "cyclonedx-python-lib", version = "7.6.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "html5lib", marker = "python_full_version < '3.9'" }, + { name = "packaging", marker = "python_full_version < '3.9'" }, + { name = "pip-api", marker = "python_full_version < '3.9'" }, + { name = "pip-requirements-parser", marker = "python_full_version < '3.9'" }, + { name = "requests", version = "2.32.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "rich", version = "14.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "toml", marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/2f/d030d0d3a50b776f910dd87dc1d57dd4a27bfad176b85882f463632e4747/pip_audit-2.7.3.tar.gz", hash = "sha256:08891bbf179bffe478521f150818112bae998424f58bf9285c0078965aef38bc", size = 50365, upload-time = "2024-04-30T19:27:43.967Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/4a/c908ec8a527698a6539b431d70454e18aef04d4190ff48107ed4d3df99ff/pip_audit-2.7.3-py3-none-any.whl", hash = "sha256:46a11faee3323f76adf7987de8171daeb660e8f57d8088cc27fb1c1e5c7747b0", size = 56266, upload-time = "2024-04-30T19:27:42.177Z" }, +] + +[[package]] +name = "pip-audit" +version = "2.9.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "cachecontrol", version = "0.14.3", source = { registry = "https://pypi.org/simple" }, extra = ["filecache"], marker = "python_full_version == '3.9.*'" }, + { name = "cyclonedx-python-lib", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "packaging", marker = "python_full_version == '3.9.*'" }, + { name = "pip-api", marker = "python_full_version == '3.9.*'" }, + { name = "pip-requirements-parser", marker = "python_full_version == '3.9.*'" }, + { name = "platformdirs", version = "4.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "requests", version = "2.32.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "rich", version = "15.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "toml", marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cc/7f/28fad19a9806f796f13192ab6974c07c4a04d9cbb8e30dd895c3c11ce7ee/pip_audit-2.9.0.tar.gz", hash = "sha256:0b998410b58339d7a231e5aa004326a294e4c7c6295289cdc9d5e1ef07b1f44d", size = 52089, upload-time = "2025-04-07T16:45:23.679Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/9e/f4dfd9d3dadb6d6dc9406f1111062f871e2e248ed7b584cca6020baf2ac1/pip_audit-2.9.0-py3-none-any.whl", hash = "sha256:348b16e60895749a0839875d7cc27ebd692e1584ebe5d5cb145941c8e25a80bd", size = 58634, upload-time = "2025-04-07T16:45:22.056Z" }, +] + +[[package]] +name = "pip-audit" +version = "2.10.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "cachecontrol", version = "0.14.4", source = { registry = "https://pypi.org/simple" }, extra = ["filecache"], marker = "python_full_version >= '3.10'" }, + { name = "cyclonedx-python-lib", version = "11.11.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "packaging", marker = "python_full_version >= '3.10'" }, + { name = "pip-api", marker = "python_full_version >= '3.10'" }, + { name = "pip-requirements-parser", marker = "python_full_version >= '3.10'" }, + { name = "platformdirs", version = "4.9.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "requests", version = "2.34.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "rich", version = "15.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "tomli", marker = "python_full_version >= '3.10'" }, + { name = "tomli-w", marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/a4/f21d5f0a0edabcbce31560b73c7c5a6f72ae87af4236fd1069c8f59a353d/pip_audit-2.10.1.tar.gz", hash = "sha256:1eb4565d19ebe5d48996f4b770b4d2b32887e12cb12cfa637f1a064011b55ffc", size = 54275, upload-time = "2026-06-10T22:17:01.744Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/a7/b0c504148114047bd1bc9d97447453c6850ca176bb2f3c0038835994e8b7/pip_audit-2.10.1-py3-none-any.whl", hash = "sha256:99ef3f600a317c1945f1e89e227ef26e1c2d618429b8bd3fa6f4f7c440c4611a", size = 62023, upload-time = "2026-06-10T22:17:00.309Z" }, +] + +[[package]] +name = "pip-requirements-parser" +version = "32.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "pyparsing", version = "3.1.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "pyparsing", version = "3.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/2a/63b574101850e7f7b306ddbdb02cb294380d37948140eecd468fae392b54/pip-requirements-parser-32.0.1.tar.gz", hash = "sha256:b4fa3a7a0be38243123cf9d1f3518da10c51bdb165a2b2985566247f9155a7d3", size = 209359, upload-time = "2022-12-21T15:25:22.732Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/d0/d04f1d1e064ac901439699ee097f58688caadea42498ec9c4b4ad2ef84ab/pip_requirements_parser-32.0.1-py3-none-any.whl", hash = "sha256:4659bc2a667783e7a15d190f6fccf8b2486685b6dba4c19c3876314769c57526", size = 35648, upload-time = "2022-12-21T15:25:21.046Z" }, ] [[package]] @@ -1098,6 +2898,20 @@ 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 = "plotstyle" +version = "0.1.0" +source = { editable = "plotstyle" } +dependencies = [ + { name = "matplotlib", version = "3.7.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "matplotlib", version = "3.10.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, + { name = "matplotlib", version = "3.11.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] + +[package.metadata] +requires-dist = [{ name = "matplotlib", specifier = ">=3.7" }] + [[package]] name = "pluggy" version = "1.5.0" @@ -1127,6 +2941,41 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] +[[package]] +name = "py-serializable" +version = "1.1.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +dependencies = [ + { name = "defusedxml", marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/16/cf/6e482507764034d6c41423a19f33fdd59655052fdb2ca4358faa3b0bcfd1/py_serializable-1.1.2.tar.gz", hash = "sha256:89af30bc319047d4aa0d8708af412f6ce73835e18bacf1a080028bb9e2f42bdb", size = 55844, upload-time = "2024-10-01T15:55:43.642Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/f2/3483060562245668bb07193b65277f0ea619cabf530deb351911eb0453eb/py_serializable-1.1.2-py3-none-any.whl", hash = "sha256:801be61b0a1ba64c3861f7c624f1de5cfbbabf8b458acc9cdda91e8f7e5effa1", size = 22786, upload-time = "2024-10-01T15:55:42.498Z" }, +] + +[[package]] +name = "py-serializable" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "defusedxml", marker = "python_full_version >= '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/73/21/d250cfca8ff30c2e5a7447bc13861541126ce9bd4426cd5d0c9f08b5547d/py_serializable-2.1.0.tar.gz", hash = "sha256:9d5db56154a867a9b897c0163b33a793c804c80cee984116d02d49e4578fc103", size = 52368, upload-time = "2025-07-21T09:56:48.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/bf/7595e817906a29453ba4d99394e781b6fabe55d21f3c15d240f85dd06bb1/py_serializable-2.1.0-py3-none-any.whl", hash = "sha256:b56d5d686b5a03ba4f4db5e769dc32336e142fc3bd4d68a8c25579ebb0a67304", size = 23045, upload-time = "2025-07-21T09:56:46.848Z" }, +] + [[package]] name = "pygments" version = "2.19.2" @@ -1157,55 +3006,45 @@ wheels = [ ] [[package]] -name = "pylint" -version = "3.2.7" +name = "pymupdf" +version = "1.24.11" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.8.1' and python_full_version < '3.9'", "python_full_version < '3.8.1'", ] -dependencies = [ - { name = "astroid", version = "3.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "colorama", marker = "python_full_version < '3.9' and sys_platform == 'win32'" }, - { name = "dill", version = "0.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "isort", version = "5.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "mccabe", marker = "python_full_version < '3.9'" }, - { name = "platformdirs", version = "4.3.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "tomli", marker = "python_full_version < '3.9'" }, - { name = "tomlkit", version = "0.13.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, - { name = "typing-extensions", version = "4.13.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cf/e8/d59ce8e54884c9475ed6510685ef4311a10001674c28703b23da30f3b24d/pylint-3.2.7.tar.gz", hash = "sha256:1b7a721b575eaeaa7d39db076b6e7743c993ea44f57979127c517c6c572c803e", size = 1511922, upload-time = "2024-08-31T14:26:26.851Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/a3/3edbb6be649e311107b320141cae0353d4cc9c6593eba7691f16c53c9c71/PyMuPDF-1.24.11.tar.gz", hash = "sha256:6e45e57f14ac902029d4aacf07684958d0e58c769f47d9045b2048d0a3d20155", size = 51199098, upload-time = "2024-10-03T20:59:54.415Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/42/4d/c73bc0fca447b918611985c325cd7017fb762050eb9c6ac6fa7d9ac6fbe4/pylint-3.2.7-py3-none-any.whl", hash = "sha256:02f4aedeac91be69fb3b4bea997ce580a4ac68ce58b89eaefeaf06749df73f4b", size = 519906, upload-time = "2024-08-31T14:26:24.933Z" }, + { url = "https://files.pythonhosted.org/packages/f5/75/b059d603530d99926de2b6a64314f3534e2149ee5496142de550c66907ac/PyMuPDF-1.24.11-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:24c35ba9e731027ff24566b90d4986e9aac75e1ce47589b25de51e3c687ddb73", size = 18895391, upload-time = "2024-10-03T20:58:18.04Z" }, + { url = "https://files.pythonhosted.org/packages/16/f8/8396ca7218622cb3600c919b320a24f05b7c14bd81eea03f3f2182844a06/PyMuPDF-1.24.11-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:20c8eb65b855a33411246d6697a3f3166727fe2d8585753cf0db648730104be6", size = 18152689, upload-time = "2024-10-03T20:58:31.823Z" }, + { url = "https://files.pythonhosted.org/packages/55/3d/84bd559129d2ff07267baae0bde0c6f4f49232408b547971f7a2e1534cb9/PyMuPDF-1.24.11-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:32fd013e3c844f105c0a6a43ee82acc7cd0c900f6ff14f5eed9492840bbcbdd9", size = 19033047, upload-time = "2024-10-04T07:59:52.645Z" }, + { url = "https://files.pythonhosted.org/packages/ca/21/ad66778ad2485f87ef1d5a36f17ec8d4aee8ce247c8e46c673eff776a877/PyMuPDF-1.24.11-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2efb793644df99db0fe2468149048175cf25c5803997828efc9152aca838f5f2", size = 19563533, upload-time = "2024-10-03T20:58:58.548Z" }, + { url = "https://files.pythonhosted.org/packages/6a/92/9ff020892560f80433876ec904c0f2669d1d69403adf412565e54a946615/PyMuPDF-1.24.11-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9b7ac5b8ec3daec17f2e830962ed091610e576a5e531d2fe28c437fbd69b1969", size = 20691324, upload-time = "2024-10-03T20:58:46.085Z" }, + { url = "https://files.pythonhosted.org/packages/28/6b/a0247598f06585d84ae9927d6ed191d89d38686ad6bf0dadc0ed699a77e7/PyMuPDF-1.24.11-cp38-abi3-win32.whl", hash = "sha256:6fda6c7ed7e6ad74d9cfac5c3837ef42efd58c506440e2513a0a200bc3c4dbc0", size = 14685566, upload-time = "2024-10-03T20:59:21.644Z" }, + { url = "https://files.pythonhosted.org/packages/f6/03/99895f003d7ff59c83d524aeccecff4e1ee1f39a7724f88acfda4f67b8bc/PyMuPDF-1.24.11-cp38-abi3-win_amd64.whl", hash = "sha256:745ce77532702d6ddeeecb47306d3669629aa5ff82708318cd652881f493b0ba", size = 15984328, upload-time = "2024-10-03T20:59:11.654Z" }, ] [[package]] -name = "pylint" -version = "3.3.9" +name = "pymupdf" +version = "1.26.5" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version == '3.9.*'", ] -dependencies = [ - { name = "astroid", version = "3.3.11", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "colorama", marker = "python_full_version == '3.9.*' and sys_platform == 'win32'" }, - { name = "dill", version = "0.4.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "isort", version = "6.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "mccabe", marker = "python_full_version == '3.9.*'" }, - { name = "platformdirs", version = "4.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "tomli", marker = "python_full_version == '3.9.*'" }, - { name = "tomlkit", version = "0.14.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, - { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/04/9d/81c84a312d1fa8133b0db0c76148542a98349298a01747ab122f9314b04e/pylint-3.3.9.tar.gz", hash = "sha256:d312737d7b25ccf6b01cc4ac629b5dcd14a0fcf3ec392735ac70f137a9d5f83a", size = 1525946, upload-time = "2025-10-05T18:41:43.786Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8d/9a/e0a4e92a85fc17be7c54afdbb113f0ade2a8bca49856d510e28bd249e462/pymupdf-1.26.5.tar.gz", hash = "sha256:8ef335e07f648492df240f2247854d0e7c0467afb9c4dc2376ec30978ec158c3", size = 84319274, upload-time = "2025-10-10T14:04:51.826Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1a/a7/69460c4a6af7575449e615144aa2205b89408dc2969b87bc3df2f262ad0b/pylint-3.3.9-py3-none-any.whl", hash = "sha256:01f9b0462c7730f94786c283f3e52a1fbdf0494bbe0971a78d7277ef46a751e7", size = 523465, upload-time = "2025-10-05T18:41:41.766Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/7fc927fd66922ce838d4c974ff9a685c5f5aba108a5d94914dc05c9371f5/pymupdf-1.26.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bfb58f07ad631e5f71ad0bd6f1ff52700f7ba7ebb4973130e81e75b721beae1", size = 23065601, upload-time = "2025-10-10T13:58:43.98Z" }, + { url = "https://files.pythonhosted.org/packages/c1/e2/e87e62284ba98d59f1fd4fc7542ef2ed0002525754a485fa4077b3bbddae/pymupdf-1.26.5-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:d58599479bc471d3ae56c3d68d9160d0b7de8a3bd40221ddc3a4eaae2d281b86", size = 22412612, upload-time = "2025-10-10T13:59:04.846Z" }, + { url = "https://files.pythonhosted.org/packages/df/c2/af93c6367f79e9b5435f803bde51c1dc8225f054f8238162dda80b44986d/pymupdf-1.26.5-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7dfea81fdd73437a6a6ce83e1fcf556faee9327a6540571e58bf04fa362bb0cd", size = 23457410, upload-time = "2025-10-10T22:45:26.355Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/1292a0df4ff71fbc00dfa8c08759d17c97e1e8ea9277eb5bc5f079ca188d/pymupdf-1.26.5-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:caad0ffeb63dcc4a29ca40f3c68d7b78d32a932e834b0056b529cc0bdbaaffc9", size = 24064941, upload-time = "2025-10-10T13:59:48.544Z" }, + { url = "https://files.pythonhosted.org/packages/28/90/87b7fdfc9cd6991a3eb69a5752f6343374c34f258c511c242f4d60791eea/pymupdf-1.26.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e24e7a7d696bd398543cc5c147869edb2026d5d5a21b7f8e35db2f20170b389e", size = 24268203, upload-time = "2025-10-10T14:00:28.791Z" }, + { url = "https://files.pythonhosted.org/packages/2c/99/9d4b36485538e29df0a013fb02bbf6b5b0743a428fa07515e36631c43363/pymupdf-1.26.5-cp39-abi3-win32.whl", hash = "sha256:a2a42f5911d153a47bf5c3e162a0bfe8745eb9bec3e59fbaf87617b4003d8270", size = 17130722, upload-time = "2025-10-10T14:00:51.377Z" }, + { url = "https://files.pythonhosted.org/packages/c6/96/fd59c1532891762ea4815e73956c532053d5e26d56969e1e5d1e4ca4b207/pymupdf-1.26.5-cp39-abi3-win_amd64.whl", hash = "sha256:39a6fb58182b27b51ea8150a0cd2e4ee7e0cf71e9d6723978f28699b42ee61ae", size = 18747258, upload-time = "2025-10-10T14:01:37.346Z" }, ] [[package]] -name = "pylint" -version = "4.0.5" +name = "pymupdf" +version = "1.28.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15'", @@ -1213,19 +3052,46 @@ resolution-markers = [ "python_full_version == '3.11.*'", "python_full_version == '3.10.*'", ] -dependencies = [ - { name = "astroid", version = "4.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "colorama", marker = "python_full_version >= '3.10' and sys_platform == 'win32'" }, - { name = "dill", version = "0.4.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "isort", version = "8.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "mccabe", marker = "python_full_version >= '3.10'" }, - { name = "platformdirs", version = "4.9.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "tomli", marker = "python_full_version == '3.10.*'" }, - { name = "tomlkit", version = "0.14.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e4/b6/74d9a8a68b8067efce8d07707fe6a236324ee1e7808d2eb3646ec8517c7d/pylint-4.0.5.tar.gz", hash = "sha256:8cd6a618df75deb013bd7eb98327a95f02a6fb839205a6bbf5456ef96afb317c", size = 1572474, upload-time = "2026-02-20T09:07:33.621Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/e9/6d6c5d6c0a3551bffd47681a6240caf941727f195b45593cf20ab36f018f/pymupdf-1.28.0.tar.gz", hash = "sha256:e53f3567403a92da15caa9e7ae0164327fff48817e9f40175367fb9de524258d", size = 87637751, upload-time = "2026-06-29T09:08:47.547Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d5/6f/9ac2548e290764781f9e7e2aaf0685b086379dabfb29ca38536985471eaf/pylint-4.0.5-py3-none-any.whl", hash = "sha256:00f51c9b14a3b3ae08cff6b2cdd43f28165c78b165b628692e428fb1f8dc2cf2", size = 536694, upload-time = "2026-02-20T09:07:31.028Z" }, + { url = "https://files.pythonhosted.org/packages/c8/b7/88043e38cc7529de070f0c9bd267fa258035cca0b4ad5260536b994594a7/pymupdf-1.28.0-cp310-abi3-macosx_10_15_x86_64.whl", hash = "sha256:892b89ba88e8f98b53133b62877a9dc9b5e7dc6a4aeb837b612db56a8d2e03ac", size = 24597385, upload-time = "2026-06-29T09:03:30.608Z" }, + { url = "https://files.pythonhosted.org/packages/33/f4/23775bbda0781b61fc398cc75079a2b0e64696d8fcf93271748883e9627e/pymupdf-1.28.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:4d692dcf44d3566ae96bc6f6346c6ad432274a29ba617bf7a9fe18009e24adb4", size = 23828292, upload-time = "2026-06-29T09:03:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/1c/f5/bf75fc7a415722f8b33662054f82d88520c0cbfd4c36d0e08aeaec605e49/pymupdf-1.28.0-cp310-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:47a5c29ed4eb0744de9c4e37bb49b1259b18d4d75fcc8a7c130f7c9fa15956f6", size = 25045507, upload-time = "2026-06-29T09:04:03.86Z" }, + { url = "https://files.pythonhosted.org/packages/58/69/5d12c9f1f2d76f28383d6110a069c79fbfced5a4f97bb1ee6e8354f52bb7/pymupdf-1.28.0-cp310-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:44f0973f5e5edbaec95bc34b64e71d1959d4ee90b1328de1b4f4f5b4fa78673f", size = 25716599, upload-time = "2026-06-29T09:04:19.367Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b4/ec0e017bc42857cc86bd651441dbc41cc18be48d4698ecd27aac491e0c9a/pymupdf-1.28.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4d61ec323a706e153a12e262e51febfb43eeaa20977785ace135d18d48bcdc83", size = 25940489, upload-time = "2026-06-29T09:04:36.624Z" }, + { url = "https://files.pythonhosted.org/packages/06/86/f831fef09013f33b3c9c09fb3923f2ff53e1e437f6ace14b8ae46392f558/pymupdf-1.28.0-cp310-abi3-win32.whl", hash = "sha256:caea2b3b67347fd79e5d15ed7929b0e886aac594ea228073b6d39de0078189da", size = 18489703, upload-time = "2026-06-29T20:50:30.599Z" }, + { url = "https://files.pythonhosted.org/packages/2e/5d/1a03f53eb0449900469335fcfc742ca28e3ba159b7d650e0921d50b8b308/pymupdf-1.28.0-cp310-abi3-win_amd64.whl", hash = "sha256:e01e90fd86abfeb37ceb921eddb951f988a11d45ff6ce6b7664f2039849068ec", size = 19773102, upload-time = "2026-06-29T09:04:49.773Z" }, + { url = "https://files.pythonhosted.org/packages/72/f6/1e52ce243ca792254f6223b4017c5667194c146ce9b88baf37bc5eb3d1c9/pymupdf-1.28.0-cp313-abi3-pyemscripten_2025_0_wasm32.whl", hash = "sha256:74c6d00ba2a9aad3a635db73b07c15db462b480741d831a34a75a56535ebc22b", size = 18357011, upload-time = "2026-06-29T20:50:50.353Z" }, + { url = "https://files.pythonhosted.org/packages/62/b1/46b5b3d8ef3cc71114667cf10c4d8b33f39af97253af32e9a0986775b638/pymupdf-1.28.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:b3e1399c7a64c6914239116a369efcdaac4cfb9e838bde2656d7accc4a85c72d", size = 25753599, upload-time = "2026-06-29T09:05:09.398Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.1.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/83/08/13f3bce01b2061f2bbd582c9df82723de943784cf719a35ac886c652043a/pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032", size = 900231, upload-time = "2024-08-25T15:00:47.416Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/0c/0e3c05b1c87bb6a1c76d281b0f35e78d2d80ac91b5f8f524cebf77f51049/pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c", size = 104100, upload-time = "2024-08-25T15:00:45.361Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version == '3.9.*'", +] +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]] @@ -1295,52 +3161,15 @@ wheels = [ ] [[package]] -name = "pytokens" -version = "0.4.1" +name = "python-dateutil" +version = "2.9.0.post0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/34/b4e015b99031667a7b960f888889c5bd34ef585c85e1cb56a594b92836ac/pytokens-0.4.1.tar.gz", hash = "sha256:292052fe80923aae2260c073f822ceba21f3872ced9a68bb7953b348e561179a", size = 23015, upload-time = "2026-01-30T01:03:45.924Z" } +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/42/24/f206113e05cb8ef51b3850e7ef88f20da6f4bf932190ceb48bd3da103e10/pytokens-0.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a44ed93ea23415c54f3face3b65ef2b844d96aeb3455b8a69b3df6beab6acc5", size = 161522, upload-time = "2026-01-30T01:02:50.393Z" }, - { url = "https://files.pythonhosted.org/packages/d4/e9/06a6bf1b90c2ed81a9c7d2544232fe5d2891d1cd480e8a1809ca354a8eb2/pytokens-0.4.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:add8bf86b71a5d9fb5b89f023a80b791e04fba57960aa790cc6125f7f1d39dfe", size = 246945, upload-time = "2026-01-30T01:02:52.399Z" }, - { url = "https://files.pythonhosted.org/packages/69/66/f6fb1007a4c3d8b682d5d65b7c1fb33257587a5f782647091e3408abe0b8/pytokens-0.4.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:670d286910b531c7b7e3c0b453fd8156f250adb140146d234a82219459b9640c", size = 259525, upload-time = "2026-01-30T01:02:53.737Z" }, - { url = "https://files.pythonhosted.org/packages/04/92/086f89b4d622a18418bac74ab5db7f68cf0c21cf7cc92de6c7b919d76c88/pytokens-0.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4e691d7f5186bd2842c14813f79f8884bb03f5995f0575272009982c5ac6c0f7", size = 262693, upload-time = "2026-01-30T01:02:54.871Z" }, - { url = "https://files.pythonhosted.org/packages/b4/7b/8b31c347cf94a3f900bdde750b2e9131575a61fdb620d3d3c75832262137/pytokens-0.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:27b83ad28825978742beef057bfe406ad6ed524b2d28c252c5de7b4a6dd48fa2", size = 103567, upload-time = "2026-01-30T01:02:56.414Z" }, - { url = "https://files.pythonhosted.org/packages/3d/92/790ebe03f07b57e53b10884c329b9a1a308648fc083a6d4a39a10a28c8fc/pytokens-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d70e77c55ae8380c91c0c18dea05951482e263982911fc7410b1ffd1dadd3440", size = 160864, upload-time = "2026-01-30T01:02:57.882Z" }, - { url = "https://files.pythonhosted.org/packages/13/25/a4f555281d975bfdd1eba731450e2fe3a95870274da73fb12c40aeae7625/pytokens-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a58d057208cb9075c144950d789511220b07636dd2e4708d5645d24de666bdc", size = 248565, upload-time = "2026-01-30T01:02:59.912Z" }, - { url = "https://files.pythonhosted.org/packages/17/50/bc0394b4ad5b1601be22fa43652173d47e4c9efbf0044c62e9a59b747c56/pytokens-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b49750419d300e2b5a3813cf229d4e5a4c728dae470bcc89867a9ad6f25a722d", size = 260824, upload-time = "2026-01-30T01:03:01.471Z" }, - { url = "https://files.pythonhosted.org/packages/4e/54/3e04f9d92a4be4fc6c80016bc396b923d2a6933ae94b5f557c939c460ee0/pytokens-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d9907d61f15bf7261d7e775bd5d7ee4d2930e04424bab1972591918497623a16", size = 264075, upload-time = "2026-01-30T01:03:04.143Z" }, - { url = "https://files.pythonhosted.org/packages/d1/1b/44b0326cb5470a4375f37988aea5d61b5cc52407143303015ebee94abfd6/pytokens-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:ee44d0f85b803321710f9239f335aafe16553b39106384cef8e6de40cb4ef2f6", size = 103323, upload-time = "2026-01-30T01:03:05.412Z" }, - { url = "https://files.pythonhosted.org/packages/41/5d/e44573011401fb82e9d51e97f1290ceb377800fb4eed650b96f4753b499c/pytokens-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:140709331e846b728475786df8aeb27d24f48cbcf7bcd449f8de75cae7a45083", size = 160663, upload-time = "2026-01-30T01:03:06.473Z" }, - { url = "https://files.pythonhosted.org/packages/f0/e6/5bbc3019f8e6f21d09c41f8b8654536117e5e211a85d89212d59cbdab381/pytokens-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d6c4268598f762bc8e91f5dbf2ab2f61f7b95bdc07953b602db879b3c8c18e1", size = 255626, upload-time = "2026-01-30T01:03:08.177Z" }, - { url = "https://files.pythonhosted.org/packages/bf/3c/2d5297d82286f6f3d92770289fd439956b201c0a4fc7e72efb9b2293758e/pytokens-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24afde1f53d95348b5a0eb19488661147285ca4dd7ed752bbc3e1c6242a304d1", size = 269779, upload-time = "2026-01-30T01:03:09.756Z" }, - { url = "https://files.pythonhosted.org/packages/20/01/7436e9ad693cebda0551203e0bf28f7669976c60ad07d6402098208476de/pytokens-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5ad948d085ed6c16413eb5fec6b3e02fa00dc29a2534f088d3302c47eb59adf9", size = 268076, upload-time = "2026-01-30T01:03:10.957Z" }, - { url = "https://files.pythonhosted.org/packages/2e/df/533c82a3c752ba13ae7ef238b7f8cdd272cf1475f03c63ac6cf3fcfb00b6/pytokens-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:3f901fe783e06e48e8cbdc82d631fca8f118333798193e026a50ce1b3757ea68", size = 103552, upload-time = "2026-01-30T01:03:12.066Z" }, - { url = "https://files.pythonhosted.org/packages/cb/dc/08b1a080372afda3cceb4f3c0a7ba2bde9d6a5241f1edb02a22a019ee147/pytokens-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8bdb9d0ce90cbf99c525e75a2fa415144fd570a1ba987380190e8b786bc6ef9b", size = 160720, upload-time = "2026-01-30T01:03:13.843Z" }, - { url = "https://files.pythonhosted.org/packages/64/0c/41ea22205da480837a700e395507e6a24425151dfb7ead73343d6e2d7ffe/pytokens-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5502408cab1cb18e128570f8d598981c68a50d0cbd7c61312a90507cd3a1276f", size = 254204, upload-time = "2026-01-30T01:03:14.886Z" }, - { url = "https://files.pythonhosted.org/packages/e0/d2/afe5c7f8607018beb99971489dbb846508f1b8f351fcefc225fcf4b2adc0/pytokens-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29d1d8fb1030af4d231789959f21821ab6325e463f0503a61d204343c9b355d1", size = 268423, upload-time = "2026-01-30T01:03:15.936Z" }, - { url = "https://files.pythonhosted.org/packages/68/d4/00ffdbd370410c04e9591da9220a68dc1693ef7499173eb3e30d06e05ed1/pytokens-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b08dd6b86058b6dc07efe9e98414f5102974716232d10f32ff39701e841c4", size = 266859, upload-time = "2026-01-30T01:03:17.458Z" }, - { url = "https://files.pythonhosted.org/packages/a7/c9/c3161313b4ca0c601eeefabd3d3b576edaa9afdefd32da97210700e47652/pytokens-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:9bd7d7f544d362576be74f9d5901a22f317efc20046efe2034dced238cbbfe78", size = 103520, upload-time = "2026-01-30T01:03:18.652Z" }, - { url = "https://files.pythonhosted.org/packages/8f/a7/b470f672e6fc5fee0a01d9e75005a0e617e162381974213a945fcd274843/pytokens-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4a14d5f5fc78ce85e426aa159489e2d5961acf0e47575e08f35584009178e321", size = 160821, upload-time = "2026-01-30T01:03:19.684Z" }, - { url = "https://files.pythonhosted.org/packages/80/98/e83a36fe8d170c911f864bfded690d2542bfcfacb9c649d11a9e6eb9dc41/pytokens-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f50fd18543be72da51dd505e2ed20d2228c74e0464e4262e4899797803d7fa", size = 254263, upload-time = "2026-01-30T01:03:20.834Z" }, - { url = "https://files.pythonhosted.org/packages/0f/95/70d7041273890f9f97a24234c00b746e8da86df462620194cef1d411ddeb/pytokens-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc74c035f9bfca0255c1af77ddd2d6ae8419012805453e4b0e7513e17904545d", size = 268071, upload-time = "2026-01-30T01:03:21.888Z" }, - { url = "https://files.pythonhosted.org/packages/da/79/76e6d09ae19c99404656d7db9c35dfd20f2086f3eb6ecb496b5b31163bad/pytokens-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f66a6bbe741bd431f6d741e617e0f39ec7257ca1f89089593479347cc4d13324", size = 271716, upload-time = "2026-01-30T01:03:23.633Z" }, - { url = "https://files.pythonhosted.org/packages/79/37/482e55fa1602e0a7ff012661d8c946bafdc05e480ea5a32f4f7e336d4aa9/pytokens-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:b35d7e5ad269804f6697727702da3c517bb8a5228afa450ab0fa787732055fc9", size = 104539, upload-time = "2026-01-30T01:03:24.788Z" }, - { url = "https://files.pythonhosted.org/packages/30/e8/20e7db907c23f3d63b0be3b8a4fd1927f6da2395f5bcc7f72242bb963dfe/pytokens-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8fcb9ba3709ff77e77f1c7022ff11d13553f3c30299a9fe246a166903e9091eb", size = 168474, upload-time = "2026-01-30T01:03:26.428Z" }, - { url = "https://files.pythonhosted.org/packages/d6/81/88a95ee9fafdd8f5f3452107748fd04c24930d500b9aba9738f3ade642cc/pytokens-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79fc6b8699564e1f9b521582c35435f1bd32dd06822322ec44afdeba666d8cb3", size = 290473, upload-time = "2026-01-30T01:03:27.415Z" }, - { url = "https://files.pythonhosted.org/packages/cf/35/3aa899645e29b6375b4aed9f8d21df219e7c958c4c186b465e42ee0a06bf/pytokens-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d31b97b3de0f61571a124a00ffe9a81fb9939146c122c11060725bd5aea79975", size = 303485, upload-time = "2026-01-30T01:03:28.558Z" }, - { url = "https://files.pythonhosted.org/packages/52/a0/07907b6ff512674d9b201859f7d212298c44933633c946703a20c25e9d81/pytokens-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:967cf6e3fd4adf7de8fc73cd3043754ae79c36475c1c11d514fc72cf5490094a", size = 306698, upload-time = "2026-01-30T01:03:29.653Z" }, - { url = "https://files.pythonhosted.org/packages/39/2a/cbbf9250020a4a8dd53ba83a46c097b69e5eb49dd14e708f496f548c6612/pytokens-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:584c80c24b078eec1e227079d56dc22ff755e0ba8654d8383b2c549107528918", size = 116287, upload-time = "2026-01-30T01:03:30.912Z" }, - { url = "https://files.pythonhosted.org/packages/4a/08/968c22e06ab6570788964e2d5a702db9a3816e20ffde380b2b1385541d64/pytokens-0.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:da5baeaf7116dced9c6bb76dc31ba04a2dc3695f3d9f74741d7910122b456edc", size = 154847, upload-time = "2026-01-30T01:03:32.268Z" }, - { url = "https://files.pythonhosted.org/packages/09/2b/2061bb4b300e6921f7968724b185237627a8a3dc4f311e34079dfadf9b65/pytokens-0.4.1-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11edda0942da80ff58c4408407616a310adecae1ddd22eef8c692fe266fa5009", size = 238610, upload-time = "2026-01-30T01:03:33.809Z" }, - { url = "https://files.pythonhosted.org/packages/1e/64/abf6e43523ea9b4aea69bfe22788a518806741107238674e5c0fb6fc8dc1/pytokens-0.4.1-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0fc71786e629cef478cbf29d7ea1923299181d0699dbe7c3c0f4a583811d9fc1", size = 252493, upload-time = "2026-01-30T01:03:35.715Z" }, - { url = "https://files.pythonhosted.org/packages/dc/fb/bcb6784c87d1de182afb284f37b07bc172eebec91ddc20e83aec767e4963/pytokens-0.4.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:dcafc12c30dbaf1e2af0490978352e0c4041a7cde31f4f81435c2a5e8b9cabb6", size = 255651, upload-time = "2026-01-30T01:03:36.961Z" }, - { url = "https://files.pythonhosted.org/packages/1a/0c/0c33752be2209498661903f6f240779aea5c9adbd85d22336ce3f7718e81/pytokens-0.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:42f144f3aafa5d92bad964d471a581651e28b24434d184871bd02e3a0d956037", size = 104346, upload-time = "2026-01-30T01:03:38.069Z" }, - { url = "https://files.pythonhosted.org/packages/51/2a/f125667ce48105bf1f4e50e03cfa7b24b8c4f47684d7f1cf4dcb6f6b1c15/pytokens-0.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:34bcc734bd2f2d5fe3b34e7b3c0116bfb2397f2d9666139988e7a3eb5f7400e3", size = 161464, upload-time = "2026-01-30T01:03:39.11Z" }, - { url = "https://files.pythonhosted.org/packages/40/df/065a30790a7ca6bb48ad9018dd44668ed9135610ebf56a2a4cb8e513fd5c/pytokens-0.4.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:941d4343bf27b605e9213b26bfa1c4bf197c9c599a9627eb7305b0defcfe40c1", size = 246159, upload-time = "2026-01-30T01:03:40.131Z" }, - { url = "https://files.pythonhosted.org/packages/a5/1c/fd09976a7e04960dabc07ab0e0072c7813d566ec67d5490a4c600683c158/pytokens-0.4.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3ad72b851e781478366288743198101e5eb34a414f1d5627cdd585ca3b25f1db", size = 259120, upload-time = "2026-01-30T01:03:41.233Z" }, - { url = "https://files.pythonhosted.org/packages/52/49/59fdc6fc5a390ae9f308eadeb97dfc70fc2d804ffc49dd39fc97604622ec/pytokens-0.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:682fa37ff4d8e95f7df6fe6fe6a431e8ed8e788023c6bcc0f0880a12eab80ad1", size = 262196, upload-time = "2026-01-30T01:03:42.696Z" }, - { url = "https://files.pythonhosted.org/packages/3d/e7/d6734dccf0080e3dc00a55b0827ab5af30c886f8bc127bbc04bc3445daec/pytokens-0.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:30f51edd9bb7f85c748979384165601d028b84f7bd13fe14d3e065304093916a", size = 103510, upload-time = "2026-01-30T01:03:43.915Z" }, - { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" }, + { 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]] @@ -1423,6 +3252,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f0/0c/25113e0b5e103d7f1490c0e947e303fe4a696c10b501dea7a9f49d4e876c/pyyaml-6.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007", size = 158777, upload-time = "2025-09-25T21:33:15.55Z" }, ] +[[package]] +name = "requests" +version = "2.32.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +dependencies = [ + { name = "certifi", marker = "python_full_version < '3.9'" }, + { name = "charset-normalizer", marker = "python_full_version < '3.9'" }, + { name = "idna", version = "3.15", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, + { name = "urllib3", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258, upload-time = "2025-06-09T16:43:07.34Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847, upload-time = "2025-06-09T16:43:05.728Z" }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +dependencies = [ + { name = "certifi", marker = "python_full_version == '3.9.*'" }, + { name = "charset-normalizer", marker = "python_full_version == '3.9.*'" }, + { name = "idna", version = "3.18", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, + { name = "urllib3", version = "2.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "certifi", marker = "python_full_version >= '3.10'" }, + { name = "charset-normalizer", marker = "python_full_version >= '3.10'" }, + { name = "idna", version = "3.18", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "urllib3", version = "2.7.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +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 = "rich" version = "14.3.4" @@ -1461,6 +3348,49 @@ 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 = "ruff" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/94/1e5e4967626faf12fa56999cd6222dff6992ceb086ad7945756baf70c7a7/ruff-0.16.0.tar.gz", hash = "sha256:e460aafd5495ec89efaa6ced2e4a9a581116451e1c88b9d37ef497e0f8e93982", size = 4790557, upload-time = "2026-07-23T19:11:30.981Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/81/1c8818fee7ce1a04cd7d1b3172e0a8f8e4f1dc4feb7fc390e16daa8af323/ruff-0.16.0-py3-none-linux_armv6l.whl", hash = "sha256:e5115729eb08c585e5121978ba5d5b60caeae394ce21b9fb5e6cd33a1c6c9b1e", size = 10754633, upload-time = "2026-07-23T19:10:46.415Z" }, + { url = "https://files.pythonhosted.org/packages/23/df/beaf59c09d68db84304d555f188b276a77132a5d5b0b67a5c762aa143628/ruff-0.16.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3c954b1d580bfa035b41654f7858cc7e71d5fc3ac5b723dd62bd9133830ed522", size = 10969164, upload-time = "2026-07-23T19:10:50.271Z" }, + { url = "https://files.pythonhosted.org/packages/42/ce/741cd197496a1abbf51352710fd15ed995d2a2be87189c1da26a450d6e83/ruff-0.16.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e01c21d10eb1b29f47b7454e1f4056db9a3f0260c646aa88457c610291db9f81", size = 10488846, upload-time = "2026-07-23T19:10:52.639Z" }, + { url = "https://files.pythonhosted.org/packages/52/2a/a2db8e88cade358f5cdcb05674a917751074109315d014eb6352d9a893f7/ruff-0.16.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e364e5ed22ed8dc05082fd78e35308618260907ac2d3c1d637b2e682415b6c9", size = 10889729, upload-time = "2026-07-23T19:10:54.89Z" }, + { url = "https://files.pythonhosted.org/packages/42/65/62a771694ebd63029dc953e27dbad40e1588bd4860ff9fe881018fddaa49/ruff-0.16.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d327b8fc113a1d4421a04f3839d3752057c8dd1ee320223a6f3f52d04ada462a", size = 10568275, upload-time = "2026-07-23T19:10:56.993Z" }, + { url = "https://files.pythonhosted.org/packages/3f/e2/ced249fe8af5f086c5c58cc21cc3356d50f32f7401c5df87050c999620a7/ruff-0.16.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9b50c55e263103586b3dcf5f73d479eb8cb5fdb6098fec59a62891dab653717", size = 11385112, upload-time = "2026-07-23T19:10:59.615Z" }, + { url = "https://files.pythonhosted.org/packages/87/0b/05154977a8fd69eeb6c103271f55403bfd8711f5c0f8ed07489d95a504e7/ruff-0.16.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0ff4a79ce3ec0172f3241943835de1c4cb4e2dcd07f0f8c2d02603dbbbee4b17", size = 12207008, upload-time = "2026-07-23T19:11:02.154Z" }, + { url = "https://files.pythonhosted.org/packages/fb/29/98225831a3a1eab0e02f4acc6ca6559a98611dcc68b6965ff4b7234627c1/ruff-0.16.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e95c448fca1fb2a18372a9440926c5a6ee789639bb975c72e7ae6d0b04218ab4", size = 11650842, upload-time = "2026-07-23T19:11:04.557Z" }, + { url = "https://files.pythonhosted.org/packages/91/66/6bd3cf90500653d55dc0ffc8507aa8300bd49d0214b2e8cb4d3fef2943ba/ruff-0.16.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f11a8d11010301d0a398a2fdef67691feca7294da6aef55e2150e8fa2cd520b", size = 11400718, upload-time = "2026-07-23T19:11:09.233Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a2/a54eb4eae05d66364050a5d3b8a9c5ef88196531b3cbe7109d873f87f819/ruff-0.16.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:48044c678e9cb8698246c99b14aaccfa6601dea7379eb48a6f8f73f7a6d86cd0", size = 11426177, upload-time = "2026-07-23T19:11:11.994Z" }, + { url = "https://files.pythonhosted.org/packages/1a/be/16e3eea4b2a478a496919f5e36f17c4559e54620bd3bbac5d6affa068006/ruff-0.16.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:7aa0959bad8eb8bef50340154fc9b58678dae31fa4293afa38b44b6e552c0213", size = 10856126, upload-time = "2026-07-23T19:11:14.221Z" }, + { url = "https://files.pythonhosted.org/packages/a2/84/252eb8b868a16eec7257c14f504f77537e734b2d69c762e639e588e304a3/ruff-0.16.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:28ea2b7df8ebf7f9da6b7d47b230ab48f387c0a29be3b474c4d0740e197bb9af", size = 10571208, upload-time = "2026-07-23T19:11:16.378Z" }, + { url = "https://files.pythonhosted.org/packages/21/09/817a482f542f7570cbb4554b26e896610c7114f539b1d9e2d2145bf6bef6/ruff-0.16.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:33a3dfac8c35f81498dea9181bccc2f4c4bc8f1521a1dd9406e77643e0f0fb09", size = 11063329, upload-time = "2026-07-23T19:11:19.173Z" }, + { url = "https://files.pythonhosted.org/packages/2e/23/9403c180ca1cb9b1f7335f5c3e5305c09d49ea5b345196682a36028bde4a/ruff-0.16.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a5237a0bda500d30d81b8e07a6973a5cbc772864cbf746ae2f4e8a2e01c9f4ed", size = 11489751, upload-time = "2026-07-23T19:11:21.74Z" }, + { url = "https://files.pythonhosted.org/packages/b2/1d/1b2ef7bcde851c78d7f17f1cca13fd6dc695fc4b3d6197941e72cae5b132/ruff-0.16.0-py3-none-win32.whl", hash = "sha256:7fab76fa065c873f41ff744347c6e77bcc3dfec4bcc754dc26b63d23c0f7f5fb", size = 10785885, upload-time = "2026-07-23T19:11:23.947Z" }, + { url = "https://files.pythonhosted.org/packages/b2/a3/d5e4ef7a56be3f928ffb90b94c25ba7d3cb9c7fe0736aeaaedf361770712/ruff-0.16.0-py3-none-win_amd64.whl", hash = "sha256:429c117f022bf481fabd9d551e7a3952b24c65e6ef44337ea09d90bebef14472", size = 11923141, upload-time = "2026-07-23T19:11:26.409Z" }, + { url = "https://files.pythonhosted.org/packages/cb/9a/8415f2657cbe200f41a4531ccededf135505a92d4a012229121f885b26f9/ruff-0.16.0-py3-none-win_arm64.whl", hash = "sha256:14296fedcd2705c77ab8235439278bbb38f285cf7da5528b00b3e330c3d4872d", size = 11273407, upload-time = "2026-07-23T19:11:28.705Z" }, +] + +[[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 = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, +] + [[package]] name = "textual" version = "0.73.0" @@ -1524,6 +3454,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cd/01/c4555f9c8a692ff83d84930150540f743ce94c89234f9e9a15ff4baba3a8/textual-8.2.5-py3-none-any.whl", hash = "sha256:247d2aa2faf222749c321f88a736247f37ee2c023604079c7490bfacddfcd4b2", size = 727050, upload-time = "2026-04-30T08:03:01.421Z" }, ] +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, +] + [[package]] name = "tomli" version = "2.4.1" @@ -1579,32 +3518,37 @@ wheels = [ ] [[package]] -name = "tomlkit" -version = "0.13.3" +name = "tomli-w" +version = "1.2.0" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.8.1' and python_full_version < '3.9'", - "python_full_version < '3.8.1'", -] -sdist = { url = "https://files.pythonhosted.org/packages/cc/18/0bbf3884e9eaa38819ebe46a7bd25dcd56b67434402b66a58c4b8e552575/tomlkit-0.13.3.tar.gz", hash = "sha256:430cf247ee57df2b94ee3fbe588e71d362a941ebb545dec29b53961d61add2a1", size = 185207, upload-time = "2025-06-05T07:13:44.947Z" } +sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/75/8539d011f6be8e29f339c42e633aae3cb73bffa95dd0f9adec09b9c58e85/tomlkit-0.13.3-py3-none-any.whl", hash = "sha256:c89c649d79ee40629a9fda55f8ace8c6a1b42deb912b2a8fd8d942ddadb606b0", size = 38901, upload-time = "2025-06-05T07:13:43.546Z" }, + { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" }, ] [[package]] -name = "tomlkit" -version = "0.14.0" +name = "ty" +version = "0.0.63" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.15'", - "python_full_version >= '3.12' and python_full_version < '3.15'", - "python_full_version == '3.11.*'", - "python_full_version == '3.10.*'", - "python_full_version == '3.9.*'", -] -sdist = { url = "https://files.pythonhosted.org/packages/c3/af/14b24e41977adb296d6bd1fb59402cf7d60ce364f90c890bd2ec65c43b5a/tomlkit-0.14.0.tar.gz", hash = "sha256:cf00efca415dbd57575befb1f6634c4f42d2d87dbba376128adb42c121b87064", size = 187167, upload-time = "2026-01-13T01:14:53.304Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/ce/cbeaa5c7576fec643609dfbf200d59493523b1cc0481d4e7a5effcbf0630/ty-0.0.63.tar.gz", hash = "sha256:c2f66439393b3acac69306c117d4ae44638ce5fffa4a20c21046e85bd473359f", size = 6280695, upload-time = "2026-07-23T11:41:39.845Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b5/11/87d6d29fb5d237229d67973a6c9e06e048f01cf4994dee194ab0ea841814/tomlkit-0.14.0-py3-none-any.whl", hash = "sha256:592064ed85b40fa213469f81ac584f67a4f2992509a7c3ea2d632208623a3680", size = 39310, upload-time = "2026-01-13T01:14:51.965Z" }, + { url = "https://files.pythonhosted.org/packages/1a/e4/d17a8e113ab15c692fe6fb9c422112d4bee7e829d80ced35826b45d98d98/ty-0.0.63-py3-none-linux_armv6l.whl", hash = "sha256:9a4ef7782e3af314fb63d006bec5ac3025bd70fee774b4dcfb5e44e8564f1994", size = 12056302, upload-time = "2026-07-23T11:41:03.5Z" }, + { url = "https://files.pythonhosted.org/packages/be/0b/357234c815dc4bfcc88c3f860aa0983fe4228c8aa2a5bb16c35ee08a94af/ty-0.0.63-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:01eab0ab70d51ad10298aa2d4b058b387a1fe93e5ee52d2a1ee23e9c69ba8354", size = 11737674, upload-time = "2026-07-23T11:41:05.862Z" }, + { url = "https://files.pythonhosted.org/packages/1c/13/193d9aeeb6774690351cff9fafabd3ae9b54cc225d125e07fa004ce23bdc/ty-0.0.63-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a671b61eaad16178389e05b9c108c9cb75ae8d84968fe55906484f55d6268338", size = 11264191, upload-time = "2026-07-23T11:41:07.963Z" }, + { url = "https://files.pythonhosted.org/packages/4f/b7/c5843e16759a2b25fc8a7197473474038e585ac9fdaa6fa16aeb6384bf6a/ty-0.0.63-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b255cc83d95c51bb9ee4931303fdbece8cb1d6d7c655eb77a3f2c8f349fb64d6", size = 11818890, upload-time = "2026-07-23T11:41:09.885Z" }, + { url = "https://files.pythonhosted.org/packages/06/20/adf83ae1fc570d9bb449605e1eeeaa523ad2329ca838a636698b5c135d11/ty-0.0.63-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0da1e8183aa4f893421a173904478021498f542ee41273660538da6649a9631c", size = 11853141, upload-time = "2026-07-23T11:41:12.151Z" }, + { url = "https://files.pythonhosted.org/packages/ea/90/f8effd846e3ee13486ea08257c13094d58b9f188c5641bf609d6a7d5c09f/ty-0.0.63-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:128f38eb5a67199e3811426386f7ec96f41251ddf45e04ddc0bcbb29d4853245", size = 12545184, upload-time = "2026-07-23T11:41:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/b8/76/aac3a30d40431eb1d329acea016b248f5b6255e30ef3d28e19447e344be2/ty-0.0.63-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bedf34aff8b0557f2a7119b314a68a9c9e58c1d21554d0e2748f2c5fe6a1f638", size = 13062375, upload-time = "2026-07-23T11:41:16.441Z" }, + { url = "https://files.pythonhosted.org/packages/62/3d/0158733932893e17f6008dadd74c8d7aed422fefc66e47fe77888014fe8c/ty-0.0.63-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7328d63c34587606dce02935a25404f54cd0161bfe413b8f7fc21d174aead612", size = 12619461, upload-time = "2026-07-23T11:41:18.538Z" }, + { url = "https://files.pythonhosted.org/packages/f5/be/e280ad095b050778f16f493d49a073fa5f6d8f301d3e2e59be6a672ba05c/ty-0.0.63-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:504c4457f3a62afe836c1f26a2c9a12549299095f9cc4146778558df51a7515c", size = 12376402, upload-time = "2026-07-23T11:41:20.482Z" }, + { url = "https://files.pythonhosted.org/packages/57/57/619788bf335cb86b090470b557ae1eed33613dc24e12142505d32b462e58/ty-0.0.63-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7394ed39424b027c89d5f0c818871c791e33958b88f5bb13e14bd4a12a3ca631", size = 12671377, upload-time = "2026-07-23T11:41:22.489Z" }, + { url = "https://files.pythonhosted.org/packages/07/a2/0aff2cdd3c98e2c4729337542b8da0ce1980790e1600e0c4a717a1f46293/ty-0.0.63-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:94c3f155230490f8fb505911655e940c630c25cc0c35a76690cb413254fb4437", size = 11768090, upload-time = "2026-07-23T11:41:24.558Z" }, + { url = "https://files.pythonhosted.org/packages/43/4a/cdb5f1d26154144dfee08e1bd671daf827238170f7cee9dad43990bb2016/ty-0.0.63-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:c16e1d8b4f0ae99106d5f13a894034a202baf6cdab61e2bb1a239de82904f839", size = 11867747, upload-time = "2026-07-23T11:41:26.794Z" }, + { url = "https://files.pythonhosted.org/packages/7e/26/ecc09ecb70bc9fbfdf42fa57ff29568f173e8200df575a0d72dc2b8486f9/ty-0.0.63-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b66293dad89eaed4b9fbf3b661614dbeb85b59ba037178a3f9a0adedf264da5c", size = 12120000, upload-time = "2026-07-23T11:41:28.731Z" }, + { url = "https://files.pythonhosted.org/packages/14/07/862822f9c2c397785b69b25cf79b4dfc3c0d55684b9adf11ac194450f8e1/ty-0.0.63-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:8b29cc832e2ec73502c97dd7325d6ae0e085b34a33529a0f785192317d9862fc", size = 12477862, upload-time = "2026-07-23T11:41:30.847Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c2/50b08b641578d6f48e8aa28a91d0de32c91aa24dd926ed199e8afd2d37ea/ty-0.0.63-py3-none-win32.whl", hash = "sha256:f0a8fbfd1f990c0c5d85cce018d438969ac79e49247e2192c9745394bb7d17ab", size = 11433155, upload-time = "2026-07-23T11:41:33.28Z" }, + { url = "https://files.pythonhosted.org/packages/92/2d/d422a5568f0d1f317186be22241288dc6e08b71dc24aca223f22038ac2d2/ty-0.0.63-py3-none-win_amd64.whl", hash = "sha256:2aa2370bdd6f42e9f37518c812379bef70b9162f9e5aad511495229b0b71cb93", size = 12450036, upload-time = "2026-07-23T11:41:35.559Z" }, + { url = "https://files.pythonhosted.org/packages/35/97/2c9748e28ead0650c7ad3e5f74f178832ceabd7cb5c272a882f29eb32ee4/ty-0.0.63-py3-none-win_arm64.whl", hash = "sha256:95ac1a62162c3c7ac204731e95ebf766d62a46a7bfa238a6acbe923fcb772cb1", size = 11826243, upload-time = "2026-07-23T11:41:37.749Z" }, ] [[package]] @@ -1665,10 +3609,75 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/61/73/d21edf5b204d1467e06500080a50f79d49ef2b997c79123a536d4a17d97c/uc_micro_py-2.0.0-py3-none-any.whl", hash = "sha256:3603a3859af53e5a39bc7677713c78ea6589ff188d70f4fee165db88e22b242c", size = 6383, upload-time = "2026-03-01T06:31:26.257Z" }, ] +[[package]] +name = "urllib3" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677, upload-time = "2024-09-12T10:52:18.401Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338, upload-time = "2024-09-12T10:52:16.589Z" }, +] + +[[package]] +name = "urllib3" +version = "2.6.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +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 = "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 = "zipp" +version = "3.20.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.8.1' and python_full_version < '3.9'", + "python_full_version < '3.8.1'", +] +sdist = { url = "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", size = 24199, upload-time = "2024-09-13T13:44:16.101Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", size = 9200, upload-time = "2024-09-13T13:44:14.38Z" }, +] + [[package]] name = "zipp" version = "3.23.1" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.9.*'", +] sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", hash = "sha256:32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110", size = 25965, upload-time = "2026-04-13T23:21:46.6Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", hash = "sha256:0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc", size = 10378, upload-time = "2026-04-13T23:21:45.386Z" },