From 81814b3cfd2c41c02c02a7c1dacd793464810cc9 Mon Sep 17 00:00:00 2001 From: bsmith Date: Tue, 6 Jan 2026 17:11:08 -0800 Subject: [PATCH 1/2] scaffold init agentic skills for workspace --- skills/benchmark-and-perf/SKILL.md | 239 +++++++++++++++++++++++ skills/docs-and-release/SKILL.md | 258 +++++++++++++++++++++++++ skills/project-intake/SKILL.md | 172 +++++++++++++++++ skills/python-api-surface/SKILL.md | 185 ++++++++++++++++++ skills/rust-pyo3-function/SKILL.md | 192 ++++++++++++++++++ skills/test-and-quality-gates/SKILL.md | 257 ++++++++++++++++++++++++ 6 files changed, 1303 insertions(+) create mode 100644 skills/benchmark-and-perf/SKILL.md create mode 100644 skills/docs-and-release/SKILL.md create mode 100644 skills/project-intake/SKILL.md create mode 100644 skills/python-api-surface/SKILL.md create mode 100644 skills/rust-pyo3-function/SKILL.md create mode 100644 skills/test-and-quality-gates/SKILL.md diff --git a/skills/benchmark-and-perf/SKILL.md b/skills/benchmark-and-perf/SKILL.md new file mode 100644 index 0000000..4660342 --- /dev/null +++ b/skills/benchmark-and-perf/SKILL.md @@ -0,0 +1,239 @@ +--- +name: benchmark-and-perf +description: Measure, compare, and improve eo-processor performance safely. Use when adding/changing Rust compute kernels, refactoring hot paths, or making performance claims. Provides a repeatable benchmark protocol with correctness checks, profiling hints, and reporting guidelines. +license: Proprietary. See repository LICENSE +compatibility: Assumes a local Rust toolchain and Python environment capable of building the PyO3 extension (maturin). Benchmarking may use repo scripts/artifacts under benchmarking/ and dist_bench*. Network access not required. +metadata: + author: eo-processor maintainers + version: "1.0" +--- + +# Benchmarking & performance skill (eo-processor) + +Use this skill to make performance work **repeatable**, **measurable**, and **safe** in a hybrid Rust+PyO3+Python Earth Observation library. + +The core objective is to answer, defensibly: +1) Did performance change (time, memory, allocations)? +2) Did correctness change (numerics, dtype/shape contract)? +3) Is the change worth the complexity? + +--- + +## When to activate + +Activate this skill when you: +- add a new Rust kernel or change an existing one +- refactor any hot loop / ndarray expression in Rust +- adjust parallelism, chunking, or algorithmic complexity +- change dtype handling (float32/float64) or NaN/Inf behavior (performance often couples to semantics) +- plan to claim speedups in docs/CHANGELOG/PR + +Do **not** activate for trivial doc updates or purely cosmetic refactors. + +--- + +## Principles (performance without breaking trust) + +1. **Correctness is a gate**: benchmarking without validating outputs is not acceptable. +2. **Measure the right thing**: avoid benchmarking builds that differ in optimization flags; compare like-for-like. +3. **Warm up**: compilation and caching effects can dominate first-run timings. +4. **Use representative shapes**: EO workloads are usually large (e.g., 1k²–10k² rasters), not just toy arrays. +5. **Avoid accidental regressions**: track both speed and memory; faster-but-alloc-heavy can be worse in real pipelines. +6. **No unverified claims**: do not claim performance improvements without before/after numbers and parameters. + +--- + +## Step 1: Define the benchmark question + +Write down: +- What operation is being measured? (function name and version) +- What data sizes/shapes? (e.g., 1000x1000, 5000x5000) +- What data distribution? (random uniform, realistic reflectance range, with/without NaNs) +- What environment? (CPU model optional, OS, Python version, Rust release build, number of threads) +- What metric? (wall time, throughput in pixels/s, peak RSS if available) + +### Acceptance criteria examples +- “New implementation must be ≥ 1.2× faster than baseline for 5000x5000 float64 arrays” +- “No more than +5% memory overhead compared to baseline” +- “Numerical difference within tolerance (float64: 1e-12; float32: 1e-5)” + +--- + +## Step 2: Always pin build mode & runtime settings + +### Build mode +- Benchmark only **release** builds for the Rust extension. +- Ensure you’re not comparing a debug build vs release build. +- If you compare against NumPy, ensure BLAS settings are stable. + +### Threading +Performance changes can be dominated by threading differences: +- Pin thread counts consistently across runs. +- If the repo uses Rayon or similar internally, control its thread count via environment (document what you used). +- For NumPy baselines, ensure you understand whether BLAS threads are involved. + +### Stability +- Close other heavy processes. +- Prefer running multiple trials and report median (and optionally p95). + +--- + +## Step 3: Correctness check BEFORE timing + +Before timing, validate: +- output shape matches contract +- dtype matches contract +- outputs are finite/NaN per contract +- values match baseline within tolerance + +### Baseline options +Pick the best available baseline: +- an existing eo-processor implementation (before refactor) +- a pure NumPy reference implementation of the formula +- a known-correct small example with asserted values + +If you can’t produce a correctness check, stop and add one first (usually a unit test in `tests/`). + +--- + +## Step 4: Benchmark protocol (repeatable) + +Use this protocol for each benchmark you report: + +1) **Generate inputs** + - Use seeded random generation for reproducibility. + - Use realistic ranges (e.g., reflectance in [0, 1]) unless the function expects something else. + +2) **Warm-up** + - Call the function at least once to warm caches and ensure the extension is loaded. + +3) **Time multiple trials** + - Run N trials (e.g., 5–20). + - Record the median and a dispersion metric (min/max or p95). + +4) **Report** + - Provide: shape, dtype, trials, median time, throughput, build mode, thread count. + +### Example Python timing skeleton (adapt to repo norms) +- Use `time.perf_counter()` not `time.time()` +- Avoid counting array creation time in the timed region +- Ensure outputs are consumed to avoid lazy evaluation traps (especially if using Dask wrappers) + +--- + +## Step 5: Evaluate results (interpretation) + +### Speedup thresholds +- < 1.05×: likely noise or not worth complexity unless it also reduces memory or fixes bugs. +- 1.05×–1.2×: consider whether it’s worth it; check memory/allocations and sustained performance. +- ≥ 1.2×: usually meaningful for EO rasters; still verify no semantic drift. + +### Check for regressions +- Small arrays sometimes get slower while large arrays get faster. That’s acceptable if the library targets large rasters—just document it. +- Watch for “fast median, slow tail”: if p95 worsened, investigate allocation spikes or scheduling. + +### Memory and allocations +If possible, assess: +- intermediate allocations (ndarray expression temporaries are common) +- peak memory usage (large rasters can OOM quickly) + +If you can’t measure memory precisely, at least reason about allocations: +- Did you add temporaries? +- Did you switch from in-place fill to multiple intermediate arrays? + +--- + +## Step 6: Profiling & root-cause techniques (use selectively) + +Use profiling only when the benchmark indicates a meaningful issue. + +### Common performance traps in this repo’s domain +- Extra temporaries from chained ndarray arithmetic +- Unintended dtype conversions / casts +- Poor cache locality due to iteration order +- Branch-heavy inner loops (NaN handling, conditional masking) +- Parallel overhead dominating small inputs + +### Suggested methods (choose what applies) +- Add lightweight internal instrumentation (counts, timing spans) temporarily; remove before commit. +- Compare “fused loop” vs “expression-based” implementations. +- Ensure the hottest path is in Rust (not Python glue). + +If you can’t profile locally, you can still: +- reduce the workload to isolate which step dominates +- compare variants with minimal changes to infer the cause + +--- + +## Step 7: How to make performance changes safely + +Preferred sequence: +1. Implement change with correctness tests. +2. Benchmark before/after with pinned settings. +3. If speedup is real, clean up code and document results. +4. If speedup is not real, revert or open a performance issue with data. + +### Safe optimizations (common wins) +- Fuse computations into a single pass over the array data. +- Precompute invariants outside inner loops. +- Reduce allocations: write into a preallocated output array. +- Avoid repeated bounds checks where safe and idiomatic (without `unsafe` unless justified). + +### Risky optimizations (require stronger evidence) +- Introducing `unsafe` +- Changing NaN/Inf behavior for speed +- Changing dtype semantics (float32 vs float64) +- Altering parallel thresholds or scheduling without benchmarks on multiple shapes + +--- + +## Reporting template (use in your response/PR) + +When you use this skill, report results in this format: + +### Benchmark setup +- Function(s): `...` +- Build: release (how built) +- Hardware/OS: (if known) +- Threads: (Rayon/BLAS/Python settings) +- Input: shape(s), dtype(s), distribution (seeded) + +### Correctness +- Baseline: (existing impl / NumPy reference) +- Tolerance: (e.g., rtol/atol) +- Result: pass/fail (and any notes about NaN behavior) + +### Performance results +For each shape/dtype: +- Before: median X ms (N trials) +- After: median Y ms (N trials) +- Speedup: X/Y (or %) +- Throughput: pixels/s (optional) +- Notes: memory/allocations qualitative notes + +### Decision +- Keep / revise / revert +- Follow-ups (tests, docs, perf issue) + +--- + +## Definition of done (for perf work) + +You’re done when: +- [ ] Correctness is validated against a baseline +- [ ] Benchmarks are repeatable and documented (inputs + settings) +- [ ] Any performance claim has before/after numbers +- [ ] No unacceptable memory regression is introduced (or it’s explicitly justified) +- [ ] Tests cover at least one representative correctness case and key edge cases +- [ ] The change doesn’t silently alter public semantics (or docs/versioning reflect it) + +--- + +## Local references (repo) + +- Engineering rules & quality gates: `AGENTS.md` +- User-facing docs and performance notes: `README.md`, `QUICKSTART.md` +- Complex workflows: `WORKFLOWS.md` +- Benchmark artifacts and harnesses: `benchmarking/`, `dist_bench.json`, `dist_bench.md`, `benchmark-*.json` +- Scripts and maintenance tooling: `scripts/` +- Tests: `tests/` diff --git a/skills/docs-and-release/SKILL.md b/skills/docs-and-release/SKILL.md new file mode 100644 index 0000000..c6bdf6b --- /dev/null +++ b/skills/docs-and-release/SKILL.md @@ -0,0 +1,258 @@ +--- +name: docs-and-release +description: Keep documentation, versioning, and release artifacts consistent for eo-processor. Use when changing public APIs, adding features, updating performance claims, or preparing a release (align README/QUICKSTART/docs, stubs, changelog, and pyproject/Cargo versions). +license: Proprietary. See repository LICENSE +compatibility: Designed for this repository’s hybrid Rust+PyO3+Python package. Assumes ability to build/test locally and update markdown/Sphinx docs when present. +metadata: + author: eo-processor maintainers + version: "1.0" +--- + +# Docs & release consistency skill (eo-processor) + +Use this skill to prevent the most common “shipped-but-confusing” failures: +- docs don’t match behavior +- types don’t match runtime +- versioning doesn’t reflect the change +- examples don’t run +- performance claims are unverified or outdated + +This repo is hybrid (Rust + PyO3 + Python packaging), so **documentation is part of the API**. Treat it with the same rigor as code. + +--- + +## When to activate + +Activate this skill when you: +- add or change a public function +- modify function semantics (NaN behavior, epsilon rules, dtype handling, shape rules) +- update performance characteristics or parallelism behavior +- modify packaging/build metadata (pyproject, Cargo, maturin config) +- prepare a release (or anything that looks like one: version bump, changelog update, docs refresh) + +Do *not* activate for purely internal refactors that produce no user-visible change—unless those refactors affect performance or behavior indirectly. + +--- + +## Core invariants (must always hold) + +1. **Public API is coherent across layers** + - Rust export (PyO3) ↔ Python re-export ↔ typing stubs ↔ docs ↔ tests + +2. **Examples are truthful** + - Code snippets in `README.md` / `QUICKSTART.md` should be runnable with minimal edits. + - Avoid pseudo-code that suggests features that do not exist. + +3. **Versioning matches semantics** + - Patch: bug fix, no API expansion + - Minor: new backward-compatible features + - Major: breaking changes (signature or contract changes) + +4. **Performance claims are substantiated** + - No “faster” claims without before/after numbers and workload context. + +--- + +## Step 1: Classify your change (to decide what to update) + +Choose the most specific category: + +### A) Public API addition (new function) +You must update: +- Python exports (`__init__.py`) + `__all__` (if used) +- typing stubs (`__init__.pyi`) +- `README.md` API summary (and/or index listing sections) +- tests (at least correctness + one edge case) +- docs (if repo has `docs/` API listings) + +Often update: +- `QUICKSTART.md` if it improves onboarding meaningfully (avoid bloat) +- `CHANGELOG` entry (if repo uses it for releases) + +### B) Public API behavior change (contract change) +You must update: +- docs describing behavior (formula, ranges, NaN/Inf handling, epsilon) +- tests to encode the new contract (and prevent regression) +- typing stubs if signature/dtype changes + +You must consider: +- semver implications (minor vs major depending on breakage) +- compatibility strategies (deprecation path, alias, warnings) + +### C) Bug fix +You must update: +- tests (regression test that fails before fix) +- docs only if user-facing behavior is clarified or corrected + +Usually: +- patch version bump (unless fix introduces new feature) +- changelog entry if repo practice expects it + +### D) Docs-only update +You must ensure: +- examples remain correct +- no stale references to removed/renamed functions +- claims are accurate (especially performance and supported environments) + +--- + +## Step 2: Documentation update checklist (minimum set) + +### README alignment +Update `README.md` when: +- a public function is added/removed/renamed +- formulas or semantics change (e.g., epsilon, masking rules) +- performance story changes + +Ensure: +- function name matches runtime import path (`from eo_processor import ...`) +- example inputs match expected dtype/range conventions +- outputs and interpretation notes are consistent (especially for indices) + +### Quickstart discipline +Update `QUICKSTART.md` only if: +- it materially reduces time-to-first-success for a new user +- it adds a simple, representative example (not a full tutorial) + +Avoid: +- duplicating large sections from README +- adding niche workflows that belong in `WORKFLOWS.md` or `docs/` + +### Workflows and examples +Update `WORKFLOWS.md` / `examples/` when: +- a new feature unlocks a compelling end-to-end workflow +- behavior changes would break published workflows + +Rule: +- workflows can be more narrative; README should stay concise. + +### Longer-form docs (`docs/`) +If this repo has generated docs (e.g., Sphinx): +- update API listings (autosummary pages, function lists) +- ensure cross-references resolve +- keep architecture/performance pages consistent with current implementation + +If docs build is part of CI, treat docs build failures as release blockers. + +--- + +## Step 3: Release readiness checklist (versioning + changelog + artifacts) + +### Version bump rules +Decide the version bump based on user-visible impact: +- Patch: + - bug fixes + - doc corrections + - internal refactor with no semantic change +- Minor: + - new function(s) + - optional parameters added with backward-compatible defaults + - performance improvements that do not change semantics +- Major: + - function removed + - signature changes that break callers + - semantic/contract changes that break expectations (dtype/range/NaN behavior) + +### Keep version sources consistent +In a hybrid Rust+Python repo, version may exist in multiple places (commonly): +- `pyproject.toml` (Python package version) +- Rust crate metadata (`Cargo.toml`) +- optionally a Python `__version__` constant (if present) + +The invariant is: **the version users see matches the release tag and changelog**. + +If the repo publishes to PyPI, ensure the Python package version is authoritative. + +### Changelog discipline +If the repo maintains a `CHANGELOG`: +- add an entry for user-visible changes +- write in terms of user impact (what changed, how to use it, any migration notes) +- include performance notes only when benchmarked and reproducible + +--- + +## Step 4: Performance documentation rules + +Any time you modify a hot path or claim performance changes: +- include benchmark context: + - function(s) + - array shapes + - dtype(s) + - build mode (release) + - thread settings (if applicable) + - before/after numbers (median of multiple trials) + +Do not: +- claim “X% faster” based on a single run +- compare debug vs release +- compare different thread counts or different BLAS settings without acknowledging it + +If benchmarks are stored in repo artifacts (e.g., `dist_bench.md`, `benchmark-*.json`), update them only if you actually re-ran them. + +--- + +## Step 5: Consistency sweep (the “find all references” mental pass) + +Before considering the work done: +- search for old function names and update them in: + - README + - quickstart + - docs + - examples + - tests + - type stubs +- ensure any added function is included in: + - Python exports + - typing stubs + - docs API list + +Also verify: +- no documentation references non-existent CLI flags or modules +- formulas match the implementation (including any epsilon or masking) +- input scaling guidance is explicit for EO data (reflectance vs scaled integers) + +--- + +## Output format: “Docs & release summary” + +When you use this skill, provide a short summary: + +1. **User-visible changes** +2. **Docs updated** (list files) +3. **Versioning decision** (patch/minor/major and why) +4. **Changelog entry** (what you added) +5. **Examples/workflows impacted** +6. **Verification plan** (what you will run) + +Example: + +- User-visible changes: Added `ndmi(a, b)` index and documented expected scaling. +- Docs updated: `README.md`, `docs/...` (API list), `QUICKSTART.md` (optional). +- Version: Minor (new backward-compatible function). +- Changelog: Added “New: NDMI index”. +- Examples: Updated `examples/...` to include NDMI usage. +- Verification: build extension, run pytest for new tests, run lint/type checks, optionally run docs build. + +--- + +## Definition of done + +You’re done when: +- [ ] Public API exports, typing stubs, docs, and tests all agree +- [ ] Version bump (if any) matches semver implications +- [ ] Changelog reflects user-visible change (if repo uses it) +- [ ] Published examples are correct and consistent +- [ ] No unverified performance claims remain in docs +- [ ] No references to removed/renamed functions remain + +--- + +## Local references (repo) + +- Engineering policies and mandatory checklist: `AGENTS.md` +- User docs: `README.md`, `QUICKSTART.md` +- Workflows: `WORKFLOWS.md` +- Docs (if present): `docs/` +- Packaging: `pyproject.toml`, `Cargo.toml` +- Python API surface and typing: `python/eo_processor/` +- Tests: `tests/` diff --git a/skills/project-intake/SKILL.md b/skills/project-intake/SKILL.md new file mode 100644 index 0000000..6394794 --- /dev/null +++ b/skills/project-intake/SKILL.md @@ -0,0 +1,172 @@ +--- +name: project-intake +description: Build a fast, accurate mental model of the eo-processor repo and the user’s task. Use when starting work, when requirements are unclear, or before making multi-file changes (Rust+PyO3+Python packaging/tests/docs). +license: Proprietary. See repository LICENSE +compatibility: Designed for agentic engineering in this repository; assumes local filesystem access and ability to run Rust/Python tooling. +metadata: + author: eo-processor maintainers + version: "1.0" +--- + +# Project intake & repo map (eo-processor) + +Use this skill to (1) clarify what you’re building, (2) map the repository, and (3) choose the smallest safe change set. + +## Goals + +1. Produce a **repo map**: key directories, entrypoints, and “where to change what”. +2. Translate the user request into **concrete acceptance criteria**. +3. Identify **risk areas** (performance, numerical stability, API surface, safety) and a **verification plan**. + +Non-goals: +- Don’t start coding until you can point to the exact files you’ll touch and why. +- Don’t broaden scope. If the request implies refactors, propose them separately. + +--- + +## 1) Clarify the task (requirements triage) + +Write down: +- **User intent**: What outcome do they want? (feature, bug fix, perf, docs) +- **Inputs/outputs**: data shapes (1D/2D), dtypes, expected ranges, NaN handling. +- **API surface**: new public function? change existing behavior? CLI change? +- **Constraints**: performance target, memory limits, backwards compatibility. +- **Examples**: at least one concrete example call and expected result properties. + +### Minimal clarifying questions (ask only if blocked) +Ask *at most 3* questions, only when needed to proceed safely: +1. “Is this intended to be a new public API or internal refactor?” +2. “What shapes/dtypes should be supported (1D/2D, float32/float64)?” +3. “Any expected behavior for nodata/NaNs or divide-by-zero?” + +If you can infer defaults from existing patterns in the repo, proceed without asking. + +--- + +## 2) Repository map (what’s where) + +Build a short map like this (fill with repo-specific paths): + +### Core implementation +- `src/` — Rust crate implementing fast EO ops via PyO3 (native extension). +- `Cargo.toml` — Rust crate config and dependencies. +- `python/eo_processor/` — Python package wrapper: exports, docstrings, typing stubs. +- `pyproject.toml` / `uv.lock` — Python packaging + dependency lock. + +### Tests & quality +- `tests/` — Python tests (pytest). +- `tox.ini` / `pytest.ini` — test environments and config. +- Lint/type tooling likely defined in `pyproject.toml` (ruff/mypy) and Rust (`clippy`, `fmt`). + +### Docs & user guides +- `README.md` — primary API & examples. +- `QUICKSTART.md` — onboarding quickstart. +- `WORKFLOWS.md` — complex usage examples / pipelines. +- `docs/` — longer-form docs (if present; check for Sphinx/MD pipeline). + +### Scripts / maintenance +- `scripts/` — maintenance scripts (e.g., coverage badge generation). + +--- + +## 3) Change classification (choose the correct workflow) + +Pick exactly one dominant category and follow it: + +### A) New function (most common) +- Implement in Rust, expose through PyO3, export in Python, add typing stub, add tests, update docs. + +### B) Bug fix +- Reproduce -> minimal fix -> regression test -> confirm no API break. + +### C) Performance improvement +- Benchmark before/after, verify correctness, avoid unsafe, document speedup context. + +### D) Docs-only / packaging +- Keep changes isolated; ensure examples remain runnable. + +--- + +## 4) Safety/performance checklist (pre-implementation) + +Before you change code, write: +- **Numerical stability plan**: EPS usage, division-by-zero behavior, NaNs, clipping rules. +- **Shape validation**: ensure consistent behavior for mismatched shapes. +- **Threading / parallelism**: confirm any parallel approach matches project conventions. +- **No side effects**: core ops should not do file I/O or network I/O. + +Common pitfalls in EO numeric code: +- silent `NaN` propagation vs deliberate masking +- dtype promotion surprises (float32 vs float64) +- divide-by-zero in normalized differences +- avoid unnecessary allocations for large rasters + +--- + +## 5) Verification plan (what you will run) + +Define a verification plan proportional to risk: + +### Always +- Rust formatting and linting +- Python linting and typing (when Python layer touched) +- Unit tests relevant to changed behavior + +### When touching Rust core +- `cargo fmt` +- `cargo clippy` (treat warnings as errors) +- `cargo test` or at least `cargo check` + +### When touching Python API/tests +- run targeted `pytest` for affected test module(s) +- run `tox` env used by the project (pick the most current default) + +### When coverage impacted +- run coverage job and regenerate badge if this repo mandates it + +--- + +## 6) Output format: the “Intake Summary” you should produce + +When this skill is used, produce a short “Intake Summary” before coding: + +1. **Problem statement** +2. **Proposed approach** +3. **Files likely to change** (list exact paths) +4. **Acceptance criteria** (bullet list) +5. **Test/verification plan** +6. **Risks & mitigations** + +Example template: + +- Problem: … +- Approach: … +- Files: + - `src/...` + - `python/eo_processor/...` + - `tests/...` + - `README.md` +- Acceptance criteria: + - … +- Verification: + - … +- Risks: + - … + +--- + +## 7) Heuristics for good agent behavior in this repo + +- Prefer small, reviewable commits. +- Preserve public API stability. +- Keep Rust+Python exports/stubs/docs synchronized. +- Don’t claim performance improvements without benchmarks. +- Don’t introduce new dependencies unless clearly justified. + +--- + +## References (local) + +- Repo operations guide: `AGENTS.md` +- User-facing docs: `README.md`, `QUICKSTART.md` +- Workflows: `WORKFLOWS.md` diff --git a/skills/python-api-surface/SKILL.md b/skills/python-api-surface/SKILL.md new file mode 100644 index 0000000..22a4ef3 --- /dev/null +++ b/skills/python-api-surface/SKILL.md @@ -0,0 +1,185 @@ +--- +name: python-api-surface +description: Maintain the public Python API for eo-processor, including exports, __all__, docstrings, and type stubs. Use when adding/renaming functions, changing signatures/behavior, or ensuring Python typing and user-facing docs stay consistent with the Rust/PyO3 core. +license: Proprietary. See repository LICENSE +compatibility: Intended for this repository’s Python package (python/eo_processor) paired with a Rust PyO3 extension; assumes numpy/xarray usage patterns and standard Python tooling (pytest, ruff, mypy, tox/uv). +metadata: + author: eo-processor maintainers + version: "1.0" +--- + +# Python API surface & typing skill (eo-processor) + +Use this skill when you need to change anything users import from `eo_processor`, or when you change behavior/signatures in the Rust core and must keep **Python exports + typing stubs + docs + tests** aligned. + +This skill is intentionally opinionated: **public API stability and consistency beat cleverness**. + +--- + +## What “Python API surface” means in this repo + +The user-visible API typically includes: + +- `python/eo_processor/__init__.py` + - imports from the compiled extension module + - `__all__` + - module docstring / high-level documentation + - occasionally `__version__` or metadata (if present in this repo) +- `python/eo_processor/__init__.pyi` + - the canonical typing surface for users and CI type checks +- Any Python helpers/wrappers that sit on top of the Rust core (if present) +- Documentation that enumerates functions and guides usage: + - `README.md` (always) + - `QUICKSTART.md` (only when it materially improves onboarding) + - `docs/` (if the repo generates longer-form docs) + +**Key invariant:** if it’s public, it must be importable, typed, tested, and documented (at least minimally). + +--- + +## Activation checklist (before you edit) + +1. Identify whether the change is: + - **new public function** + - **renamed function** + - **signature change** + - **behavior change** + - **docs-only change** +2. Identify the **single source of truth** for the behavior (usually Rust core), and confirm: + - input shapes (1D/2D), dtype(s), and expected ranges + - NaN/Inf behavior + - divide-by-zero / epsilon strategy (if applicable) +3. Decide if the function should be **public**: + - If it’s stable, broadly useful, and not experimental → public. + - If it’s internal glue or unstable → keep internal, don’t export. + +If any of those are unclear and you cannot infer them from existing functions, stop and ask the user for clarification (max 3 targeted questions). + +--- + +## Step-by-step workflow + +### Step 1: Wire exports correctly + +When a function is intended to be public: + +1. Import it into `python/eo_processor/__init__.py` from the extension module (or its wrapper module). +2. Add it to `__all__`. +3. Ensure naming matches docs and tests exactly. + +**Rules:** +- Re-export under a single canonical name. Avoid multiple aliases unless there’s a compatibility story. +- Keep ordering/grouping consistent (e.g., indices together, masking together, temporal stats together). + +### Step 2: Define the typing contract in `__init__.pyi` + +The `.pyi` signature should be: +- accurate to runtime behavior (including accepted dtypes/shapes) +- helpful to users (clear parameter names, optional defaults) +- consistent across the library (similar functions should have similar typing style) + +**Typing guidance:** +- Prefer `numpy.typing.NDArray` for NumPy arrays. +- If the project supports `xarray.DataArray` directly at runtime, either: + - provide overloads, or + - document that `xarray` usage is via `xr.apply_ufunc` and keep types NumPy-focused. +- Don’t promise more than the function actually supports (e.g., don’t type as accepting `ArrayLike` if it fails on lists). + +**Return type:** +- If the function returns a new array: `NDArray[np.floating[Any]]` or a specific `np.float64` / `np.float32` depending on behavior. +- If dtype is guaranteed (common in Rust kernels), reflect that explicitly. + +### Step 3: Update docstrings and high-level docs + +For user-facing completeness: +- Ensure `README.md` mentions the function in the right section (API summary / feature list). +- Provide a minimal example snippet in docs if this is a new capability. +- If it’s an EO index, include: + - formula + - band meanings + - expected input scaling (0–1 reflectance vs scaled integers) + - output range and interpretation notes + +Keep docs concise; move deep explanations to `docs/` if the repo uses it. + +### Step 4: Add/adjust tests + +Any public API change requires tests. At minimum: +- a correctness test on a small array +- shape mismatch behavior (if relevant) +- stability (near-zero denominator) tests for ratio/normalized difference functions + +When behavior changes: +- update or add a regression test that captures the intended new behavior +- avoid “brittle” tests that encode implementation quirks rather than contract + +--- + +## Compatibility and deprecation rules + +### Renames +If renaming a public function: +- Prefer a deprecation window: + - keep old name available and forward it to the new name + - add a deprecation note in docs + - (optionally) emit a `DeprecationWarning` from the old alias +- Update: + - docs, tests, `__all__`, stubs + - any examples referencing the old name + +### Signature changes +Avoid breaking signature changes. If necessary: +- make new args optional with safe defaults +- document default behavior carefully +- update stubs and tests + +If a breaking change is unavoidable, it must be explicit and coordinated with versioning policy. + +--- + +## Quality bar (must pass before “done”) + +- [ ] Public function is importable from `eo_processor` +- [ ] `__all__` includes it (if this repo uses `__all__` as canonical) +- [ ] `.pyi` typing matches runtime behavior +- [ ] Tests cover correctness + key edge cases +- [ ] Docs mention the function and provide guidance +- [ ] No redundant exports or conflicting names +- [ ] No undocumented behavior change + +--- + +## Common pitfalls (avoid) + +- Adding a Rust function but forgetting: + - `python/eo_processor/__init__.py` export + - `python/eo_processor/__init__.pyi` stub + - docs update + - tests +- Typing promises that runtime can’t fulfill (e.g., `ArrayLike` when only `ndarray` works) +- Silent behavioral changes without a corresponding doc/test update +- Inconsistent naming (e.g., `normalizedDifference` vs `normalized_difference`) +- Returning different dtype than typed/documented +- “Convenience” broadcasting rules in one function that don’t exist elsewhere + +--- + +## Suggested “API change summary” format (use in your response/PR) + +When you use this skill, summarize the API outcome: + +1. **What changed** +2. **How to use it** (minimal snippet) +3. **Typing contract** (inputs/outputs) +4. **Edge cases** (NaN, divide-by-zero, shape mismatch) +5. **Tests added/updated** + +--- + +## Local references (repo) + +- Engineering and checklists: `AGENTS.md` +- User docs: `README.md`, `QUICKSTART.md` +- Workflows/examples: `WORKFLOWS.md`, `examples/` +- Python surface: `python/eo_processor/__init__.py`, `python/eo_processor/__init__.pyi` +- Tests: `tests/` diff --git a/skills/rust-pyo3-function/SKILL.md b/skills/rust-pyo3-function/SKILL.md new file mode 100644 index 0000000..73c7a1c --- /dev/null +++ b/skills/rust-pyo3-function/SKILL.md @@ -0,0 +1,192 @@ +--- +name: rust-pyo3-function +description: Implement or modify a Rust function exposed to Python via PyO3 in eo-processor. Use when adding new compute kernels, fixing numerical/shape bugs in the Rust core, or wiring Rust functions into the Python module safely and consistently. +license: Proprietary. See repository LICENSE +compatibility: Requires Rust toolchain and Python packaging via maturin; assumes NumPy arrays passed through PyO3/numpy bindings. +metadata: + author: eo-processor maintainers + version: "1.0" +--- + +# Rust + PyO3 function skill (eo-processor) + +Use this skill when you need to add or change a Rust implementation that is exposed to Python. The goal is: **correct math + stable API + high performance + predictable behavior**. + +## Activation checklist (before you code) + +1. Identify the *public Python name* of the function (e.g., `ndvi`) and confirm whether this is: + - a new function, or + - a behavior change, or + - a bug fix (no API change). +2. Find existing patterns in: + - `src/` for Rust/PyO3 style + - `python/eo_processor/` for exports/docstrings + - `python/eo_processor/__init__.pyi` for typing + - `tests/` for numerical expectations. +3. Define expected behavior for: + - shape mismatches + - division by zero / near-zero denominators + - NaN/Inf handling + - dtype support and output dtype. + +If anything is ambiguous, decide based on existing functions in this repo (stay consistent). + +--- + +## Design rules (repo conventions) + +### 1) Keep the core pure +- Rust compute kernels should be **pure functions**: no file I/O, no network access, no global state. +- Deterministic results for deterministic inputs. + +### 2) Validate shapes early, fail clearly +- If the function expects aligned shapes, check and raise a Python-friendly error. +- Do not silently broadcast unless the repo already does that everywhere. + +### 3) Numerical stability is not optional +- For normalized differences and ratios, guard denominators with a small epsilon. +- Use a *consistent* epsilon strategy across similar functions. +- Make NaN behavior explicit (propagate vs sanitize) and match existing functions. + +### 4) Avoid unnecessary allocations +- Prefer single-pass loops where possible. +- Avoid creating multiple temporaries for large rasters. +- If using ndarray operations, be mindful of intermediate allocations. + +### 5) Don’t introduce `unsafe` without a compelling reason +- If you think you need `unsafe`, stop and provide: + - justification (benchmark evidence), + - a safety argument, + - tests that would catch UB-like symptoms. + +--- + +## Implementation workflow (step-by-step) + +### Step A: Specify the API contract +Write down: +- signature at Python level (args, defaults, return) +- expected input shapes and dtypes +- output dtype +- error behavior & messages + +Example contract for a normalized difference: +- Inputs: `a`, `b` float arrays (1D or 2D depending on existing patterns) +- Output: float array same shape +- Math: `(a - b) / (a + b + EPS)` +- Errors: shape mismatch -> `ValueError` (or the project’s standard) + +### Step B: Implement Rust function with PyO3 glue +Typical structure: +1. Accept `Python` token and `PyReadonlyArray*` inputs. +2. Convert to `ndarray::ArrayView*` using `.as_array()`. +3. Validate shape compatibility. +4. Allocate output (or create new array) and fill it. +5. Return `PyArray*` via `into_pyarray(py)` (or existing conventions). + +Prefer returning a new array rather than mutating inputs. + +### Step C: Register with the module +- Ensure the `#[pyfunction]` is added to the module in the `#[pymodule]` initializer. +- Keep ordering, naming, and grouping consistent with neighboring functions. + +### Step D: Maintain Python surface coherence +Whenever you add/rename a Rust-exposed function, you almost always need to update: +- `python/eo_processor/__init__.py` (exports and `__all__`) +- `python/eo_processor/__init__.pyi` (typing stub) +- docs (`README.md` at minimum; `docs/` if used by the repo) +- tests (`tests/`) + +If the change is internal-only, do not export it publicly. + +--- + +## Error handling guidance (PyO3) + +- Prefer returning `PyResult`. +- Use Pythonic errors; typical choices: + - `ValueError` for invalid shapes/values + - `TypeError` for wrong types (rare if signature enforces arrays) +- Error messages should be: + - actionable + - short + - consistent across functions. + +--- + +## Performance guidance + +### What to optimize first +1. Avoid extra allocations / temporaries. +2. Ensure tight loops with minimal branching in the inner loop. +3. Use contiguous iteration patterns when possible. + +### When to benchmark +Benchmark if: +- you’re adding a new kernel, or +- you changed the inner loop, or +- you changed dtype handling. + +Don’t claim speedups without before/after numbers and array sizes. + +--- + +## Testing expectations (what to add) + +Add tests that cover: +1. **Correctness**: known inputs with known outputs (small arrays). +2. **Stability**: near-zero denominators; ensure outputs are finite if expected. +3. **Shape behavior**: mismatch raises the correct error. +4. **NaN behavior**: if inputs contain NaN, outcome matches contract. +5. **Dtype behavior**: float32/float64 if supported by project conventions. + +For numerical comparisons: +- use tolerances appropriate for float64/float32 +- avoid exact equality for floats unless intentionally exact. + +--- + +## Documentation expectations + +For a new EO index function, document: +- the formula +- what each band represents +- recommended input scaling (e.g., reflectance 0–1 vs scaled ints) +- typical output range and interpretation + +Keep docs short in `README.md` and move deeper material to `docs/` if present. + +--- + +## “Done” checklist (must be true before you stop) + +- [ ] Rust function implemented with correct math and shape checks +- [ ] Function is registered in the PyO3 module +- [ ] Python exports updated (if public) +- [ ] Typing stubs updated (if public) +- [ ] Tests added/updated and pass +- [ ] Docs updated (if public) +- [ ] Lint/format gates pass for Rust (+ Python if touched) +- [ ] No unnecessary new dependencies + +--- + +## Common pitfalls (avoid these) + +- Returning wrong shape due to accidental broadcast or flattening +- Implicit dtype casts causing precision loss +- Division by zero producing noisy Inf/NaN without being documented +- Adding a Rust function but forgetting Python `__init__.py` / `__init__.pyi` +- Performance regressions from extra temporaries +- Changing behavior without updating tests and docs + +--- + +## Local references (repo) + +- Engineering rules & checklists: `AGENTS.md` +- User docs and API overview: `README.md`, `QUICKSTART.md` +- Existing workflows/examples: `WORKFLOWS.md`, `examples/` +- Rust crate entrypoints and module registration: `src/` +- Python exports/stubs: `python/eo_processor/` +- Tests: `tests/` diff --git a/skills/test-and-quality-gates/SKILL.md b/skills/test-and-quality-gates/SKILL.md new file mode 100644 index 0000000..19c3b6a --- /dev/null +++ b/skills/test-and-quality-gates/SKILL.md @@ -0,0 +1,257 @@ +--- +name: test-and-quality-gates +description: Run and interpret eo-processor quality gates (Rust+Python) and add the right tests for changes. Use when verifying work, fixing CI failures, or before committing PR-ready changes (fmt/clippy, ruff/mypy, pytest/tox, coverage, and minimal regression tests). +license: Proprietary. See repository LICENSE +compatibility: Assumes local Rust toolchain and Python tooling (tox/uv/pytest/ruff/mypy) are available; intended for this repository’s hybrid Rust+PyO3+Python package. +metadata: + author: eo-processor maintainers + version: "1.0" +--- + +# Test & quality gates skill (eo-processor) + +Use this skill to keep changes safe and shippable by running the correct checks, adding the **right** tests, and diagnosing failures efficiently across **Rust**, **Python**, and **packaging** boundaries. + +This repo is a hybrid: +- Rust core (PyO3 extension) +- Python package surface +- Tests primarily in Python +- Multiple quality gates (format, lint, type, unit, coverage, docs) + +## When to activate +Activate this skill when you are: +- about to make a commit / open a PR +- fixing CI failures +- adding or changing a public API +- modifying numerical kernels (risk of subtle regressions) +- touching build/packaging (maturin, pyproject, Cargo) + +--- + +## Gate 0: Decide what changed (scope-driven checklist) + +First, classify your change. This determines which gates must run. + +### A) Docs only +- Run: markdown sanity (optional), and ensure examples still look correct +- You can usually skip compilation checks unless docs reference generated API content + +### B) Python-only logic (no Rust changes) +- Run: ruff + mypy (if configured) + pytest (or tox) +- Coverage if tests changed or coverage is tracked for this change + +### C) Rust core change (PyO3 extension) +- Run: cargo fmt + clippy + (test/check) +- Rebuild extension and run Python tests that exercise the path +- If any Python API was touched, also run Python gates + +### D) Public API change (new function / signature / behavior) +- Run: **everything relevant**: + - Rust gates (if Rust involved) + - Python gates (exports, typing, tests) + - Docs updates and (if present) docs build + - Coverage gates if the change impacts coverage tracking + +**Rule:** the broader the public impact, the more gates you run. + +--- + +## Gate 1: Test design (what tests to add) + +### Always add at least one regression test for: +- a bug fix (reproduces old failure, asserts new behavior) +- a behavior change (encodes the new contract) +- a new public function (correctness + edge case) + +### Recommended test coverage for numerical kernels (EO indices / ratios) +Add tests that cover: + +1) **Correctness on tiny arrays** +- Hand-computable examples (2x2, 1D length 4) +- Assert shape and values within tolerance + +2) **Stability edge cases** +- denominators near zero +- extremely small/large floats if relevant +- confirm behavior for divide-by-zero matches contract (finite vs inf vs NaN) + +3) **Shape behavior** +- mismatched shapes should raise a predictable, Python-friendly error + +4) **NaN / nodata behavior** +- if inputs can contain NaN: ensure behavior is consistent with the repo contract +- only sanitize NaNs if that is explicitly part of the function contract + +5) **Dtype behavior** +- if float32 and float64 are supported, include both (or at least confirm output dtype is stable) + +### Tolerances +- Prefer `np.testing.assert_allclose` (or equivalent) +- Use tighter tolerances for float64 than float32 +- Avoid exact float equality unless the operation is guaranteed exact + +### Avoid brittle tests +- Don’t test implementation details (loop order, internal eps value) unless the contract depends on it. +- Test behavior and contract, not incidental formatting. + +--- + +## Gate 2: Rust quality gates (when Rust is touched) + +### Required +1. Format: +- Run Rust formatter (repo standard) + +2. Lint: +- Run clippy with warnings treated as errors (repo standard) + +3. Compile/test: +- Run Rust tests if they exist +- If no Rust tests apply, at least ensure the crate checks/compiles + +### Failure triage (Rust) +When a Rust gate fails: +- **fmt**: apply format; do not hand-fight formatting +- **clippy**: + - treat warnings as real issues + - prefer clear, idiomatic fixes + - don’t suppress warnings unless there’s a documented reason +- **borrow checker / lifetime**: + - simplify ownership at API boundaries (convert views once, avoid unnecessary clones) +- **performance concerns**: + - avoid introducing extra allocations + - watch for accidental temporaries in ndarray expressions + +--- + +## Gate 3: Python quality gates (when Python/stubs/tests are touched) + +### Required (as applicable) +1. Lint: +- run the repo’s linter (ruff is common here) + +2. Types: +- run mypy (if configured) focusing on `python/eo_processor` and stubs + +3. Unit tests: +- run pytest for relevant test modules +- run the canonical tox environment if that’s the repo standard + +### Failure triage (Python) +- **ruff**: fix high-signal issues (unused imports, incorrect comparisons, unsafe patterns) +- **mypy**: + - update stubs to match runtime behavior + - prefer precise types over `Any` unless you truly can’t express it +- **pytest failures**: + - confirm it’s not a stale compiled artifact (rebuild extension if Rust changed) + - isolate failing test with a targeted run + - inspect dtype/shape differences first for numerical failures + +--- + +## Gate 4: Integration gate (Rust ↔ Python) + +Use this gate whenever Rust core changed or new functions were added. + +Checklist: +- Can you import `eo_processor` successfully? +- Can you call the changed/new function from Python? +- Do the Python exports and stubs match the compiled module? +- Do tests exercise the actual compiled path (not a fallback)? + +Common integration failures: +- forgot to register the function in the PyO3 `#[pymodule]` +- forgot to re-export in `python/eo_processor/__init__.py` +- stubs (`__init__.pyi`) are out of sync +- stale build wheel/extension loaded in the environment + +--- + +## Gate 5: Coverage gate (when tests changed) + +Run coverage gates if: +- you added or removed tests +- you changed Python logic +- the repo’s CI enforces coverage thresholds +- coverage badges/artifacts are tracked + +If coverage is updated and the repo expects it: +- run the coverage job +- regenerate any badge or report artifacts as per repo conventions + +Do not “game” coverage with meaningless tests. Add tests that encode real behavior. + +--- + +## Gate 6: Docs gate (when public API changes) + +At minimum, ensure: +- `README.md` is updated if the public API surface changed +- quickstart/examples remain consistent with the API + +If the repo has a docs build: +- run it when: + - new functions are added to API listings + - cross-references might break + - docs tooling or dependencies changed + +--- + +## Minimal “pre-commit” checklist for this repo + +If you are about to commit, you should be able to say “yes” to all applicable items: + +- [ ] Rust formatted (if Rust touched) +- [ ] Rust clippy passes with warnings as errors (if Rust touched) +- [ ] Rust compiles / tests pass (if Rust touched) +- [ ] Python lint passes (if Python touched) +- [ ] Type check passes (if Python/stubs touched) +- [ ] Unit tests pass (always run relevant subset; full tox if risky change) +- [ ] Public API exports/stubs/docs/tests consistent (if public API touched) +- [ ] Coverage updated if required by repo policy (if test/coverage impacted) +- [ ] No unrelated changes staged +- [ ] No secrets, no large binary artifacts + +--- + +## Debugging playbook (fast triage) + +### 1) Reproduce quickly +- run the smallest failing command (single test module, single lint tool) +- avoid running the full suite until you have a hypothesis + +### 2) Investigate likely boundaries first +For EO numeric code, the usual suspects are: +- dtype conversion (float32 vs float64) +- integer-scaled inputs vs reflectance (0–1) assumptions +- divide-by-zero / epsilon differences +- shape mismatch or unexpected broadcasting + +### 3) Reduce the case +- create a tiny reproducer array in a test +- assert intermediate invariants (shape, dtype, finite) + +### 4) Fix root cause, then strengthen the test +- if you fixed a bug, add a test that would have failed before + +--- + +## Expected output when this skill is used + +When you activate this skill, produce a short actionable plan like: + +1. **Gates to run** (based on change type) +2. **Tests to add/update** (what and why) +3. **Failure triage steps** (if something fails) +4. **Definition of done** (what must be green) + +--- + +## Local references (repo) +- Core engineering rules & mandatory checklist: `AGENTS.md` +- User docs: `README.md`, `QUICKSTART.md` +- Workflows: `WORKFLOWS.md` +- Rust core: `src/`, `Cargo.toml` +- Python package surface: `python/eo_processor/` +- Tests: `tests/` +- Tool configuration: `pyproject.toml`, `tox.ini`, `pytest.ini` From d4ed097353a785da142fb8006fc7dad082c96afc Mon Sep 17 00:00:00 2001 From: bsmith Date: Tue, 6 Jan 2026 20:38:11 -0800 Subject: [PATCH 2/2] bfast-monitor example after skill definition created --- Makefile | 32 +- examples/README.md | 1 + .../bfast_break_date_frac.png | Bin 0 -> 46531 bytes .../_out_bfast_monitor/bfast_confidence.png | Bin 0 -> 57516 bytes .../bfast_detected_mask.png | Bin 0 -> 13447 bytes .../_out_bfast_monitor/bfast_magnitude.png | Bin 0 -> 57201 bytes .../bfast_timeseries_y32_x96.png | Bin 0 -> 63842 bytes .../bfast_timeseries_y64_x64.png | Bin 0 -> 63402 bytes examples/bfast_monitor_example.py | 437 ++++++++++ pyproject.toml | 1 + skills/README.md | 58 ++ skills/examples-and-smoke-tests/SKILL.md | 266 ++++++ src/workflows.rs | 187 +++-- uv.lock | 756 ++++++++++++++++++ 14 files changed, 1668 insertions(+), 70 deletions(-) create mode 100644 examples/_out_bfast_monitor/bfast_break_date_frac.png create mode 100644 examples/_out_bfast_monitor/bfast_confidence.png create mode 100644 examples/_out_bfast_monitor/bfast_detected_mask.png create mode 100644 examples/_out_bfast_monitor/bfast_magnitude.png create mode 100644 examples/_out_bfast_monitor/bfast_timeseries_y32_x96.png create mode 100644 examples/_out_bfast_monitor/bfast_timeseries_y64_x64.png create mode 100644 examples/bfast_monitor_example.py create mode 100644 skills/README.md create mode 100644 skills/examples-and-smoke-tests/SKILL.md diff --git a/Makefile b/Makefile index c884305..3765f6f 100644 --- a/Makefile +++ b/Makefile @@ -13,7 +13,7 @@ PYTEST_RUN = $(VENV_DIR)/bin/pytest # Default and Setup Targets # ============================================================================== -.PHONY: all setup sync develop build install clean test lint docs help +.PHONY: all setup sync develop build build-wheel install install-wheel reinstall clean test lint docs help all: develop @@ -35,16 +35,32 @@ develop: sync ## Install the Rust code as a Python module for development # Build, Clean, and Utility Targets # ============================================================================== -build: sync ## Build the release wheels for distribution - @echo "⚙️ Building release wheels..." +# Build a wheel (does NOT install it into the current environment) +build-wheel: sync ## Build the release wheel(s) for distribution (outputs to dist/) + @echo "⚙️ Building release wheel(s) into dist/ ..." # NOTE: This target assumes the virtual environment is manually activated uv run maturin build --release --out dist -install: build ## Install the project from the built wheel - @echo "📦 Installing built wheel into environment..." - # Find the latest built wheel and install it - uv pip uninstall eo_processor || true - uv pip install .[dask] +# Backwards-compatible alias (historically named "build") +build: build-wheel ## Alias for build-wheel + +# Install from the freshly built wheel in dist/ (the correct companion to build-wheel) +install-wheel: build-wheel ## Install the freshly built wheel from dist/ into the current environment + @echo "📦 Installing freshly built wheel into current environment..." + # Uninstall any previously installed distribution variants (name can differ across tools) + uv pip uninstall -y eo-processor eo_processor || true + # Install the wheel we just built. --force-reinstall ensures the native extension updates. + uv pip install --force-reinstall dist/*.whl + +# Backwards-compatible alias for "install" (historically misleading in this repo) +install: install-wheel ## Alias for install-wheel + +reinstall: sync ## Build and install the wheel into the current environment + @echo "⚙️ Building release wheel..." + uv run maturin build --release --out dist + @echo "📦 Installing freshly built wheel..." + uv pip uninstall eo-processor eo_processor || true + uv pip install --force-reinstall dist/*.whl clean: ## Clean up build artifacts @echo "🧹 Cleaning up..." diff --git a/examples/README.md b/examples/README.md index 8b7edbf..d828b20 100644 --- a/examples/README.md +++ b/examples/README.md @@ -5,6 +5,7 @@ This directory contains runnable Python scripts demonstrating usage of the high- ## Files - `basic_usage.py`: Core spectral indices (NDVI, NDWI, EVI, normalized difference) on 1D and 2D arrays plus performance snippet and temporal stats. +- `bfast_monitor_example.py`: Demonstrates `bfast_monitor` change detection on a synthetic seasonal time series (break vs stable) and includes optional PNG outputs (`--png`) for visualization. - `xarray_dask_usage.py`: Integration with XArray and Dask for chunked / lazy evaluation and time-series workflows. - `map_blocks.py`: Compares `xarray.apply_ufunc`, `xarray.map_blocks`, and `dask.array.map_blocks` for NDVI computation performance. - `temporal_operations.py`: Demonstrates `temporal_mean`, `temporal_std`, median compositing, and NaN handling. diff --git a/examples/_out_bfast_monitor/bfast_break_date_frac.png b/examples/_out_bfast_monitor/bfast_break_date_frac.png new file mode 100644 index 0000000000000000000000000000000000000000..41073d457ffd7c264885fe1d8e5dfaf67cbe758c GIT binary patch literal 46531 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 z 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 h0crpM literal 0 HcmV?d00001 diff --git a/examples/_out_bfast_monitor/bfast_detected_mask.png b/examples/_out_bfast_monitor/bfast_detected_mask.png new file mode 100644 index 0000000000000000000000000000000000000000..d3ff065e4606f60700e99a880abbc646617427d7 GIT binary patch literal 13447 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 literal 0 HcmV?d00001 diff --git a/examples/_out_bfast_monitor/bfast_magnitude.png b/examples/_out_bfast_monitor/bfast_magnitude.png new file mode 100644 index 0000000000000000000000000000000000000000..7a5bd5c8b1d7fa4e395608d1359748ab5462f2b6 GIT binary patch literal 57201 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 JtaD0e0sslC{7?V@ literal 0 HcmV?d00001 diff --git a/examples/_out_bfast_monitor/bfast_timeseries_y32_x96.png b/examples/_out_bfast_monitor/bfast_timeseries_y32_x96.png new file mode 100644 index 0000000000000000000000000000000000000000..89d8114ff0be3dc434d8da4ae6fe7769cd392a64 GIT binary patch literal 63842 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

s z=um{RmZFJKCG=JQ?!23X#bNEWX%PRF%-k3SOYyVaIxQ}e|H`|B$5C8*3~OtBjwad% zZbVdNOwGV(S^kxY<|ztcxk=`4abA5veUN4Cj!j8!*WLni<2fiIdG}4-+Y8U*UhV+Z zi^<$?!Zg1NHsWDu?vk3Mu|A#RIDNV(Xl#;M_q^qmRG}6Su6IM`-~gedS!C~9Iyx-8 zBVQ=+4+{vWQc{-O$0q0X=(Sy1fS=7l3Alu7eh#}7!b+=Jw9ShhAm;bn3(B%RUE9HC z2kPpFZ_^)Wliz^QL3~b4Vauf|fW~t$2Z^y?m_{7cI&Zm9WNm{NbJJH{arE1YWv<;a zOw?B|@X17FHmyH5hk(XG0U1!H*msbMN~`@}p+g2>WU+vMNILX)BQ7awBuz+1(tH}k z%MI;%zmlm@6~}mPlpNGR;I2a3uBL;GoOTESPanWx!!0be6HWoy^vO*ZGq0&svTr7j zFC_kRaE z&h!qeU(*Y1*)FGV`)sr>8=t2KiPdamH9Vku({zO`?Y(m_;xJ&2aTztyPkq_2XdW8qj_2LGpz+=ca>nNf+a$8AuU@#M zwx!O1htSV(cn(5zzT2sU?V@*}nxqQu8G`B9U6QD(Z{Ws0?|ul!Z3s53z+~D2IA2#< zp+gc)JN^+}F1-aE6s}9+TH!O? z(-|@p2C4pG+}mbwrmeA0F6zBeN)&b501{{vLswtxTt literal 0 HcmV?d00001 diff --git a/examples/_out_bfast_monitor/bfast_timeseries_y64_x64.png b/examples/_out_bfast_monitor/bfast_timeseries_y64_x64.png new file mode 100644 index 0000000000000000000000000000000000000000..989345881c20db64c623cca9638ec373077a67fc GIT binary patch literal 63402 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дryUGXA zmf?OXp3B_81lE$28yh<+3mQ6m&O?nCy*C{?N{~*}M>sfIJRpWHtNT$M)05 np.ndarray: + """ + Create a 16-day cadence list of dates as integers (YYYYMMDD). + + Uses pandas for correctness and simplicity. + """ + start_year = start_yyyymmdd // 10000 + start_month = (start_yyyymmdd // 100) % 100 + start_day = start_yyyymmdd % 100 + + end_year = end_yyyymmdd // 10000 + end_month = (end_yyyymmdd // 100) % 100 + end_day = end_yyyymmdd % 100 + + start = f"{start_year:04d}-{start_month:02d}-{start_day:02d}" + end = f"{end_year:04d}-{end_month:02d}-{end_day:02d}" + + dates = pd.to_datetime(pd.date_range(start=start, end=end, freq="16D")) + return (dates.year * 10000 + dates.month * 100 + dates.day).to_numpy(dtype=np.int64) + + +def _frac_years_from_yyyymmdd(dates_int: np.ndarray) -> np.ndarray: + """ + Convert YYYYMMDD int dates to fractional years (year + day_of_year/365.25). + + Uses pandas for correctness (avoids invalid date parsing edge cases). + """ + years = dates_int // 10000 + months = (dates_int // 100) % 100 + days = dates_int % 100 + + dates = pd.to_datetime( + { + "year": years.astype(int), + "month": months.astype(int), + "day": days.astype(int), + } + ) + # pandas returns a Series here; day-of-year is accessed via the `.dt` accessor. + doy = dates.dt.dayofyear.to_numpy(dtype=np.float64) + + return years.astype(np.float64) + doy / 365.25 + + +def _make_synthetic_stack( + *, + height: int, + width: int, + dates_int: np.ndarray, + history_start_date: int, + monitor_start_date: int, + seed: int, + break_drop: float, +) -> Tuple[np.ndarray, np.ndarray]: + """ + Build two (time, y, x) stacks: + - stack_break: monitoring period includes a spatially-varying break (break scenario) + - stack_stable: stable signal designed to yield <5% detections with defaults + + Goals: + - Make the spatial fields (magnitude + break timing) visually interesting (not uniform). + - Keep the *stable* scenario clean enough under default parameters. + - Avoid external data dependencies; everything is synthetic. + """ + rng = np.random.default_rng(seed) + t_frac = _frac_years_from_yyyymmdd(dates_int) + + # Spatial coordinate grids in [-1, 1] for smooth fields. + yy, xx = np.mgrid[0:height, 0:width] + yy = (yy / max(1, height - 1)) * 2.0 - 1.0 + xx = (xx / max(1, width - 1)) * 2.0 - 1.0 + + # Stable base signal (seasonal) with low noise. + # Add a *spatially varying* offset and phase so pixels are not perfectly correlated. + stable_noise = rng.normal(0.0, 0.005, size=t_frac.shape[0]) + spatial_offset = 0.03 * (0.6 * xx + 0.4 * yy) # gentle gradient + spatial_phase = 0.40 * np.sin(2.0 * np.pi * (0.35 * xx + 0.20 * yy)) # radians-ish + spatial_amp = 0.90 + 0.15 * (np.sin(2.0 * np.pi * xx) * np.cos(2.0 * np.pi * yy)) + + # Build time × space stable stack with per-pixel phase shifts. + # This keeps the seasonal shape but makes maps less uniform. + base_cos = np.cos(2.0 * np.pi * t_frac)[:, None, None] + base_sin = np.sin(4.0 * np.pi * t_frac)[:, None, None] + phase_term = np.cos(spatial_phase)[None, :, :] # couples spatial phase into seasonal term + + stack_stable = ( + (0.55 + stable_noise)[:, None, None] + + (0.18 * base_cos) * phase_term + + (0.10 * base_sin) + ) + stack_stable = (stack_stable * spatial_amp[None, :, :] + spatial_offset[None, :, :]).astype(np.float64) + + # --- Break scenario: spatially varying break timing + magnitude --- + stack_break = stack_stable.copy() + + # Spatially varying drop magnitude (kept near break_drop, but not uniform). + drop_field = break_drop * (0.75 + 0.35 * (np.sin(2.0 * np.pi * (0.22 * xx + 0.31 * yy)) + 1.0) / 2.0) + drop_field = drop_field.astype(np.float64) + + # Spatially varying delay (in number of *samples*) after monitor_start. + # This is intended to spread detected break dates across the map. + # + # NOTE: Depending on `h`/`alpha` and the MOSUM windowing, detections may cluster at a + # similar date even when the onset varies. Increasing delay range generally helps. + # + # Range: [0, max_delay] samples. + max_delay = 40 + delay_field = ( + max_delay * (0.5 + 0.5 * np.sin(2.0 * np.pi * (0.18 * xx - 0.27 * yy))) + ).round().astype(int) + + # Find the monitoring start index in the time axis. + monitor_start_idx = int(np.argmax(dates_int >= np.int64(monitor_start_date))) + + # Apply the break with per-pixel onset and magnitude. + for y in range(height): + for x in range(width): + onset = monitor_start_idx + int(delay_field[y, x]) + if onset < stack_break.shape[0]: + stack_break[onset:, y, x] = stack_break[onset:, y, x] - drop_field[y, x] + + # Add modest heteroscedastic noise to the break stack (varies over time) for texture. + break_noise_t = rng.normal(0.0, 0.010, size=stack_break.shape[0]).astype(np.float64) + stack_break = stack_break + break_noise_t[:, None, None] + + # Keep within a plausible range for demo stability. + stack_stable = np.clip(stack_stable, -0.2, 1.2) + stack_break = np.clip(stack_break, -0.2, 1.2) + + return stack_break, stack_stable + + +def _summarize_result(name: str, result: np.ndarray) -> None: + break_dates = result[0] + magnitudes = result[1] + + detected = break_dates > 0.0 + n = detected.size + n_det = int(detected.sum()) + + print(f"\n{name}:") + print(f" result shape: {result.shape} (channels, y, x)") + print(f" detected pixels: {n_det}/{n} ({(n_det / n * 100.0):.1f}%)") + + if n_det > 0: + bd = break_dates[detected] + mag = magnitudes[detected] + print(f" break_date_frac: min={bd.min():.3f}, p50={np.median(bd):.3f}, max={bd.max():.3f}") + print(f" magnitude: min={mag.min():.3f}, p50={np.median(mag):.3f}, max={mag.max():.3f}") + else: + print(" break_date_frac: (none detected)") + print(" magnitude: (none detected)") + + +def _write_pngs(out_dir: Path, *, stack_break: np.ndarray, dates_int: np.ndarray, result_break: np.ndarray) -> None: + """ + Write a few diagnostic PNGs for demonstration; requires matplotlib. + + Includes debug prints so you can confirm the numeric detection stats match + what is being written to the PNGs. + """ + try: + import matplotlib.pyplot as plt # type: ignore + except Exception as e: # pragma: no cover + raise SystemExit( + "PNG output requires matplotlib. Install it and re-run with --png.\n" + f"Import error: {e}" + ) from e + + out_dir.mkdir(parents=True, exist_ok=True) + + break_dates = result_break[0] + magnitudes = result_break[1] + detected = break_dates > 0.0 + + # Debug: confirm the exact arrays used to generate PNGs match the printed summary. + # This helps catch cases where you are viewing stale PNGs or results are different + # from what you think is being plotted. + det_ratio = float(detected.mean()) + bd_min = float(break_dates.min()) + bd_max = float(break_dates.max()) + mag_min = float(magnitudes.min()) + mag_max = float(magnitudes.max()) + print( + "\nPNG debug (from result_break used for images):\n" + f" detected_ratio={det_ratio:.6f} (detected pixels={int(detected.sum())}/{detected.size})\n" + f" break_date_frac min/max={bd_min:.6f}/{bd_max:.6f}\n" + f" magnitude min/max={mag_min:.6f}/{mag_max:.6f}\n" + f" output_dir={out_dir}" + ) + + # 1) Detected mask + # + # NOTE: Some viewers (and some matplotlib backends) can make a 0/1 uint8 image + # appear “all black” due to autoscaling / interpolation / display heuristics. + # Scale to 0/255 and force vmin/vmax so white pixels are unmistakably white. + mask_img = (detected.astype(np.uint8) * 255) + plt.figure(figsize=(6, 5)) + plt.imshow(mask_img, cmap="gray", vmin=0, vmax=255, interpolation="nearest") + plt.title("BFAST Monitor: detected break mask (white=detected)") + plt.axis("off") + plt.tight_layout() + plt.savefig(out_dir / "bfast_detected_mask.png", dpi=150) + plt.close() + + # 1b) Magnitude-based "confidence-like" visualization + # + # This is intended purely for demonstrations: higher magnitudes are rendered as + # higher confidence of change. It does not represent a calibrated probability. + # + # We normalize magnitudes robustly using percentiles among detected pixels so + # outliers don't dominate the colormap. + conf = np.zeros_like(magnitudes, dtype=np.float64) + if detected.any(): + mags = magnitudes[detected] + lo = float(np.percentile(mags, 5)) + hi = float(np.percentile(mags, 95)) + if hi <= lo: + hi = lo + 1e-12 + conf_detected = (mags - lo) / (hi - lo) + conf_detected = np.clip(conf_detected, 0.0, 1.0) + conf[detected] = conf_detected + + plt.figure(figsize=(6, 5)) + plt.imshow(conf, cmap="inferno", vmin=0.0, vmax=1.0, interpolation="nearest") + plt.title("BFAST Monitor: magnitude-based confidence (normalized)") + plt.colorbar(fraction=0.046, pad=0.04) + plt.axis("off") + plt.tight_layout() + plt.savefig(out_dir / "bfast_confidence.png", dpi=150) + plt.close() + + # 2) Magnitude heatmap + plt.figure(figsize=(6, 5)) + plt.imshow(magnitudes, cmap="magma") + plt.title("BFAST Monitor: break magnitude") + plt.colorbar(fraction=0.046, pad=0.04) + plt.axis("off") + plt.tight_layout() + plt.savefig(out_dir / "bfast_magnitude.png", dpi=150) + plt.close() + + # 3) Break date map (fractional years; zeros where none) + plt.figure(figsize=(6, 5)) + plt.imshow(break_dates, cmap="viridis") + plt.title("BFAST Monitor: break date (fractional years; 0=none)") + plt.colorbar(fraction=0.046, pad=0.04) + plt.axis("off") + plt.tight_layout() + plt.savefig(out_dir / "bfast_break_date_frac.png", dpi=150) + plt.close() + + # 4) A couple of pixel time series plots (one expected break, one stable-ish) + # Pick a pixel near center and a pixel with a strong amplitude modulation. + h, w = break_dates.shape + pixels = [(h // 2, w // 2), (h // 4, 3 * w // 4)] + t_frac = _frac_years_from_yyyymmdd(dates_int) + + for (yy, xx) in pixels: + ts = stack_break[:, yy, xx] + bd = break_dates[yy, xx] + mag = magnitudes[yy, xx] + + plt.figure(figsize=(9, 3)) + plt.plot(t_frac, ts, linewidth=1.5) + plt.axvline(_frac_years_from_yyyymmdd(np.array([dates_int[0]], dtype=np.int64))[0], color="none") # noop (keeps style) + if bd > 0.0: + plt.axvline(bd, color="red", linestyle="--", linewidth=1.25, label=f"break ~ {bd:.3f}") + plt.title(f"Pixel ({yy}, {xx}) time series | mag={mag:.3f}") + plt.xlabel("Year (fractional)") + plt.ylabel("Signal") + plt.grid(True, alpha=0.25) + if bd > 0.0: + plt.legend(loc="best") + plt.tight_layout() + plt.savefig(out_dir / f"bfast_timeseries_y{yy}_x{xx}.png", dpi=150) + plt.close() + + print(f"\nWrote PNG outputs to: {out_dir}") + + +def main() -> int: + parser = argparse.ArgumentParser(description="Run a synthetic BFAST Monitor demo.") + parser.add_argument("--height", type=int, default=128, help="Raster height (y).") + parser.add_argument("--width", type=int, default=128, help="Raster width (x).") + parser.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility.") + parser.add_argument("--order", type=int, default=1, help="Harmonic order for BFAST Monitor.") + parser.add_argument("--h", type=float, default=0.35, help="MOSUM window fraction (h).") + parser.add_argument("--alpha", type=float, default=0.001, help="Significance level (alpha).") + parser.add_argument( + "--break-drop", + type=float, + default=0.4, + help="Drop applied to monitoring-period values for the break scenario.", + ) + parser.add_argument( + "--png", + action="store_true", + help="Write demonstration PNG(s) under examples/_out_bfast_monitor/ (requires matplotlib).", + ) + args = parser.parse_args() + + # Date configuration mirrors the unit test pattern: history then monitoring. + history_start_date = 20100101 + monitor_start_date = 20150101 + end_date = 20171231 + + # 16-day cadence date list across full period + dates_int = _date_range_16d_int(history_start_date, end_date) + + print("BFAST Monitor example") + print("--------------------") + print(f"dates: {int(dates_int[0])} .. {int(dates_int[-1])} (n={dates_int.size})") + print(f"stack shape: (time={dates_int.size}, y={args.height}, x={args.width})") + + # Build two synthetic stacks: with a break and without. + stack_break, stack_stable = _make_synthetic_stack( + height=args.height, + width=args.width, + dates_int=dates_int, + history_start_date=history_start_date, + monitor_start_date=monitor_start_date, + seed=args.seed, + break_drop=args.break_drop, + ) + + # Run BFAST Monitor (Rust-backed workflow) + result_break = bfast_monitor( + stack_break, + dates_int.tolist(), + history_start_date=history_start_date, + monitor_start_date=monitor_start_date, + order=args.order, + h=args.h, + alpha=args.alpha, + ) + + result_stable = bfast_monitor( + stack_stable, + dates_int.tolist(), + history_start_date=history_start_date, + monitor_start_date=monitor_start_date, + order=args.order, + h=args.h, + alpha=args.alpha, + ) + + # Basic invariants (smoke-test style) + assert isinstance(result_break, np.ndarray), "Expected numpy ndarray output" + assert result_break.shape == (2, args.height, args.width) + assert result_stable.shape == (2, args.height, args.width) + + _summarize_result("Break scenario", result_break) + _summarize_result("Stable scenario", result_stable) + + # We want a demonstration that is both: + # - a smoke run (exercises the compiled workflow end-to-end) + # - a reasonably interpretable demo (stable scenario should be mostly "no break") + break_detected_ratio = float((result_break[0] > 0.0).mean()) + stable_detected_ratio = float((result_stable[0] > 0.0).mean()) + print("\nSanity checks:") + print(f" break detected ratio: {break_detected_ratio:.3f}") + print(f" stable detected ratio: {stable_detected_ratio:.3f}") + + # The break scenario should generally detect widespread change for this synthetic drop. + # If it doesn't, something is likely wrong with the install / wiring / parameters. + assert break_detected_ratio > 0.05, "Expected some break detections in the break scenario" + + # Stable scenario target: <5% detections with default parameters. + # This is still a demo (not a unit test), but we keep this threshold to catch regressions + # where the algorithm becomes overly sensitive for a clean seasonal signal. + assert stable_detected_ratio < 0.05, ( + "Expected <5% detections in the stable scenario. If this fails, consider tuning " + "`alpha` (smaller is stricter), `h`, or reducing synthetic noise/complexity." + ) + + if args.png: + out_dir = Path("examples") / "_out_bfast_monitor" + _write_pngs(out_dir, stack_break=stack_break, dates_int=dates_int, result_break=result_break) + + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index dbc4765..1c1a1e8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,6 +27,7 @@ dependencies = [ "structlog>=23.1.0", "xarray>=2023.0.0", "dask[array]>=2023.0.0", + "matplotlib>=3.9.4", ] [project.scripts] diff --git a/skills/README.md b/skills/README.md new file mode 100644 index 0000000..8b394ae --- /dev/null +++ b/skills/README.md @@ -0,0 +1,58 @@ +# Agent Skills Index (eo-processor) + +This directory contains **agentic skills** following the Agent Skills open standard (https://agentskills.io/specification). + +Each skill lives in its own folder and includes a required `SKILL.md` file with: +- **Metadata** (`name`, `description`, etc.) used for discovery +- **Instructions** loaded when the skill is activated +- Optional supporting files (e.g., `references/`, `scripts/`, `assets/`) + +## Skills in this workspace + +### `project-intake/` +**Use when:** starting a new task, requirements are unclear, or before multi-file Rust+Python changes. +**Focus:** repo map, acceptance criteria, risks, and a minimal verification plan. + +### `rust-pyo3-function/` +**Use when:** implementing or modifying Rust compute kernels exposed to Python via PyO3. +**Focus:** correctness, shape validation, numerical stability, avoiding unnecessary allocations, safe module registration. + +### `python-api-surface/` +**Use when:** changing anything users import from `eo_processor`. +**Focus:** exports (`__init__.py`), `__all__`, docstrings, and keeping `__init__.pyi` type stubs aligned with runtime behavior and docs. + +### `test-and-quality-gates/` +**Use when:** verifying changes, fixing CI failures, or before committing. +**Focus:** scope-driven gates across Rust (`fmt`, `clippy`, build), Python (lint, types, pytest/tox), integration, and coverage/docs checks. + +### `benchmark-and-perf/` +**Use when:** making performance changes or claims. +**Focus:** repeatable benchmark protocol (pinned settings, warmups, trials), correctness checks against a baseline, and result reporting. + +### `docs-and-release/` +**Use when:** changing public APIs, behavior/semantics, packaging, or preparing a release. +**Focus:** docs/typing/tests alignment, semver version decisions, changelog discipline, and truthful performance documentation. + +### `examples-and-smoke-tests/` +**Use when:** creating or updating examples under `examples/` for onboarding and smoke testing. +**Focus:** runnable scripts, minimal dependencies, predictable outputs, and keeping examples aligned with the public API. + +## Conventions & tips + +- Keep `SKILL.md` bodies concise (progressive disclosure); push deep reference material into `references/` if needed. +- When you add a new public function, assume you’ll update: + - Rust export + module registration + - Python exports and `__init__.pyi` + - tests + - README/docs + - (optionally) examples under `examples/` + +## Adding a new skill + +Create a directory named after the skill: +- lowercase letters, numbers, hyphens +- must match the `name:` field in `SKILL.md` + +Then add `SKILL.md` with frontmatter: +- `name` and `description` are required +- optional: `license`, `compatibility`, `metadata`, `allowed-tools` diff --git a/skills/examples-and-smoke-tests/SKILL.md b/skills/examples-and-smoke-tests/SKILL.md new file mode 100644 index 0000000..acb2ae3 --- /dev/null +++ b/skills/examples-and-smoke-tests/SKILL.md @@ -0,0 +1,266 @@ +--- +name: examples-and-smoke-tests +description: Create and maintain runnable examples under examples/ for onboarding and smoke testing. Use when adding/changing public APIs, when you need a quick “does it work end-to-end?” script, or when updating examples/README.md to match the current eo-processor API. +license: Proprietary. See repository LICENSE +compatibility: Intended for this repository’s examples/ scripts. Assumes a local Python environment with the built eo-processor extension available (e.g., via maturin/uv/tox) and optional xarray/dask for advanced examples. +metadata: + author: eo-processor maintainers + version: "1.0" +--- + +# Examples & smoke tests skill (eo-processor) + +Use this skill to add or update **examples** that serve two purposes: + +1. **User onboarding**: small, readable scripts that demonstrate “how do I use this?” +2. **Smoke testing**: quick, repeatable end-to-end checks that catch integration breakage (Rust ↔ PyO3 ↔ Python API). + +Examples are not a substitute for unit tests. They’re a *second line of defense* and a *first line of comprehension*. + +--- + +## Where this skill applies + +Primary directory: +- `examples/` + +Common example files in this repo: +- `examples/basic_usage.py` +- `examples/xarray_dask_usage.py` +- `examples/spectral_indices_extended.py` +- `examples/temporal_operations.py` +- `examples/zonal_stats_example.py` +- `examples/README.md` + +--- + +## When to activate + +Activate this skill when you: +- Add a new public function or change an existing one +- Modify behavior that examples rely on (dtype/shape rules, NaN handling, epsilon rules) +- Need a quick confirmation that the compiled extension, Python exports, and runtime behavior line up +- Want to provide a minimal “copy/paste runnable” onboarding path +- Need to demonstrate a workflow from `WORKFLOWS.md` in executable form + +Do not activate when: +- You’re only refactoring internals with no user-visible API impact (unless it might break runtime wiring) + +--- + +## Design goals (what “good” looks like) + +A good example is: +- **Runnable**: `python examples/.py` works in the repo’s standard dev environment +- **Small and focused**: demonstrates one concept (or a tightly-related set), not the entire library +- **Deterministic enough**: uses fixed seeds for random data and avoids flaky assertions +- **Honest**: no claims about features that don’t exist; no placeholder TODOs +- **Aligned with public API**: imports from `eo_processor` as users would +- **Light on dependencies**: uses only core deps unless the example explicitly targets an optional stack (xarray/dask) + +A bad example is: +- Too big to read +- Depends on local data files without telling the user +- Requires niche libraries without documenting them +- Prints pages of output without meaning +- Quietly passes while doing the wrong thing + +--- + +## Example types to create (pick the smallest one that fits) + +### Type A: “Hello world” onboarding script +Use when introducing a new user-facing function. + +Characteristics: +- Small arrays (1D or 2D) +- Clear printed output (min/max/mean, a small preview) +- A short explanation in comments +- No complex dependencies + +Example topics: +- Spectral indices (NDVI/NDWI/…) +- Masking utilities +- Simple temporal aggregations + +### Type B: Smoke test script for integration +Use when you need a quick end-to-end check that users can run. + +Characteristics: +- Imports the public API exactly as users do: `from eo_processor import ...` +- Exercises the main code path (compiled extension) +- Validates invariants: + - shape preserved + - dtype as expected (or at least float) + - finite results (or NaN behavior is explicitly expected) +- Exits non-zero on failure (use `assert` or explicit checks) + +Important: +- Keep it fast (seconds, not minutes). +- Avoid huge arrays unless specifically testing performance. + +### Type C: “Workflow” example script +Use when demonstrating multi-step pipelines (e.g., temporal compositing + index + morphology). + +Characteristics: +- A few logical steps, each with a comment header +- Prints intermediate summaries (shape/dtype/min/max/percentiles) +- Avoids large IO; uses synthetic data unless the repo explicitly includes sample data + +### Type D: Optional-stack example (xarray/dask) +Use only when: +- the feature is about `xr.apply_ufunc`, dask parallelism, or chunk behavior +- the dependency is documented clearly at the top of the example + +Characteristics: +- A small chunked array to keep runtime short +- Emphasizes correct usage patterns (`xr.apply_ufunc`, `dask="parallelized"`, etc.) +- Avoids requiring a distributed cluster (local threads is enough) + +--- + +## Step-by-step workflow + +### Step 1: Decide the example’s purpose and audience +Write down, in one sentence: +- “This example is for ____ and demonstrates ____.” + +Also decide: +- Does it target beginners (Type A) or is it a smoke/integration check (Type B)? + +### Step 2: Choose file naming and placement +Rules: +- Put examples in `examples/`. +- Prefer descriptive names (e.g., `ndmi_example.py`, `masking_example.py`). +- If updating, prefer editing an existing related example rather than creating duplicates. + +### Step 3: Write the script with a consistent structure + +Recommended structure: + +1. Header comment: + - what it demonstrates + - how to run it + - optional dependencies (if any) + +2. Imports: + - `numpy` first (almost always) + - `eo_processor` imports next + - optional packages last + +3. Deterministic input: + - use `np.random.default_rng(seed)` if randomness is needed + - keep sizes modest (e.g., 256x256 or similar) + +4. Compute: + - call the function(s) under test + +5. Validate invariants: + - `assert out.shape == in.shape` + - `assert np.isfinite(out).all()` where appropriate + - if NaNs are expected: assert their presence and explain why + +6. Print a human-readable summary: + - dtype, shape + - min/max/mean + - small preview slice if helpful (`out[:3, :3]`) + +7. Exit cleanly: + - if using asserts, Python will raise on failure + +### Step 4: Keep outputs stable +Guidelines: +- Prefer summaries over full arrays. +- If printing numeric summaries, consider rounding for readability. +- Seed randomness so results don’t change unexpectedly. + +### Step 5: Update `examples/README.md` if appropriate +If you add a new example or make a meaningful change: +- Add a short bullet: + - what it demonstrates + - how to run it + - notes about optional deps + +--- + +## Assertions and correctness guidance + +Examples can include lightweight checks, but avoid heavy logic. + +Recommended checks: +- Shape preservation +- Basic finiteness (when contract expects it) +- Known-value sanity for tiny hand-constructed arrays (best for onboarding) + +Avoid in examples: +- Tight tolerance comparisons against complex baselines (put those in `tests/`) +- Large exhaustive test matrices (again, `tests/`) + +If you need stronger correctness validation: +- Add/extend a `tests/test_*.py` unit test, and keep the example focused on usability. + +--- + +## Dependency discipline + +### Default dependency set for most examples +- `numpy` +- `eo_processor` + +### Optional dependencies (only when needed) +- `xarray`, `dask[array]` for xarray/dask examples +- Any ML libs only for ML-specific demos (keep optional and documented) + +Rules: +- If an example needs optional deps, say so at the top with install hints. +- Don’t introduce new dependencies solely for an example unless the repo already supports them. + +--- + +## Common pitfalls (avoid) + +- Importing private/internal modules instead of the public API +- Using huge arrays that make examples slow or memory-heavy +- Relying on local files without documenting where to get them +- Silent failures (no asserts, no meaningful output) +- Flaky results due to unseeded randomness +- Examples drifting out of sync with `README.md` and stubs + +--- + +## “Definition of done” for a new/updated example + +You’re done when: +- [ ] The example runs from the repo root with the standard dev environment +- [ ] It imports from `eo_processor` (public API) rather than internals +- [ ] It includes small but meaningful invariant checks (shape/dtype/finite as appropriate) +- [ ] Output is readable and stable (seeded randomness if used) +- [ ] `examples/README.md` is updated if a new example was added or behavior changed +- [ ] If the example reflects a new/changed public API, docs and stubs are also aligned (see `docs-and-release` and `python-api-surface` skills) + +--- + +## Suggested cookbook patterns (choose one) + +### Pattern 1: Minimal onboarding +- Tiny inputs (hand-coded arrays) +- Known outputs or easy-to-interpret summaries + +### Pattern 2: Small realistic raster +- Synthetic 2D arrays (e.g., 256x256 reflectance in [0, 1]) +- Print min/max/mean and a tiny window + +### Pattern 3: Smoke test mode +- Minimal runtime +- Assertions + short summary +- Clear failure signal + +--- + +## Local references (repo) +- Examples directory: `examples/` +- Example index: `examples/README.md` +- User docs: `README.md`, `QUICKSTART.md`, `WORKFLOWS.md` +- Engineering rules: `AGENTS.md` +- Public API surface: `python/eo_processor/__init__.py`, `python/eo_processor/__init__.pyi` +- Tests: `tests/` diff --git a/src/workflows.rs b/src/workflows.rs index 251b87d..370da3d 100644 --- a/src/workflows.rs +++ b/src/workflows.rs @@ -1,12 +1,16 @@ use crate::CoreError; use nalgebra::{DMatrix, DVector}; -use ndarray::{Axis, IxDyn, Zip}; +use ndarray::{Axis, IxDyn}; use numpy::{IntoPyArray, PyArrayDyn, PyReadonlyArrayDyn}; use pyo3::prelude::*; use rayon::prelude::*; const TWO_PI: f64 = 2.0 * std::f64::consts::PI; +// Chunk size (in pixels) for parallel work units in bfast_monitor. +// Larger chunks reduce scheduling overhead and enable safe disjoint mutable writes. +const BFAST_PIXELS_PER_CHUNK: usize = 1024; + // --- 1. BFAST Monitor Workflow --- /// Represents the fitted harmonic model. @@ -159,55 +163,31 @@ fn dates_to_frac_years(dates: &[i64]) -> Vec { } // This is the main logic function that runs for each pixel. -fn run_bfast_monitor_per_pixel( - pixel_ts: &[f64], - dates: &[f64], - history_start: f64, - monitor_start: f64, - order: usize, - h: f64, // h parameter for MOSUM window size - alpha: f64, // Significance level -) -> (f64, f64) { - // 1. Find the indices for the history and monitoring periods - let history_indices: Vec = dates - .iter() - .enumerate() - .filter(|(_, &d)| d >= history_start && d < monitor_start) - .map(|(i, _)| i) - .collect(); - - let monitor_indices: Vec = dates - .iter() - .enumerate() - .filter(|(_, &d)| d >= monitor_start) - .map(|(i, _)| i) - .collect(); - - if history_indices.is_empty() || monitor_indices.is_empty() { - return (0.0, 0.0); - } - // 2. Extract the data for these periods - let history_ts: Vec = history_indices.iter().map(|&i| pixel_ts[i]).collect(); - let history_dates: Vec = history_indices.iter().map(|&i| dates[i]).collect(); - let monitor_ts: Vec = monitor_indices.iter().map(|&i| pixel_ts[i]).collect(); - let monitor_dates: Vec = monitor_indices.iter().map(|&i| dates[i]).collect(); - // 3. Fit model on the historical period - let model_result = fit_harmonic_model(&history_ts, &history_dates, order); - let model = match model_result { +fn run_bfast_monitor_per_pixel_windows( + history_ts: &[f64], + history_dates: &[f64], + monitor_ts: &[f64], + monitor_dates: &[f64], + order: usize, + h: f64, + alpha: f64, +) -> (f64, f64) { + // Fit model on the historical period + let model = match fit_harmonic_model(history_ts, history_dates, order) { Ok(m) => m, - Err(_) => return (0.0, 0.0), // Return no-break if model fails + Err(_) => return (0.0, 0.0), }; - // 4. Predict for the monitoring period - let predicted_ts = predict_harmonic_model(&model, &monitor_dates, order); + // Predict for the monitoring period + let predicted_ts = predict_harmonic_model(&model, monitor_dates, order); - // 5. Detect break using MOSUM process on residuals + // Detect break using MOSUM process on residuals detect_mosum_break( - &monitor_ts, + monitor_ts, &predicted_ts, - &monitor_dates, + monitor_dates, history_ts.len(), model.sigma, h, @@ -259,37 +239,120 @@ pub fn bfast_monitor( let mut out_array = ndarray::ArrayD::::zeros(IxDyn(&[2, height, width])); // Flatten spatial dimensions for parallel processing + // + // IMPORTANT: In the input layout (time, y, x), each pixel's time series is strided + // along the time axis. After reshaping to (time, num_pixels), iterating over Axis(1) + // yields 1D views that are typically *not* contiguous, so `as_slice()` can return None. + // + // To avoid per-pixel allocations (and avoid panics), we instead fetch each time sample + // by indexing the (time, num_pixels) array. let num_pixels = height * width; let stack_flat = stack_arr .into_shape((time_len, num_pixels)) .map_err(|e| CoreError::ComputationError(e.to_string()))?; + // Precompute the (time) indices for history/monitor windows once (they are the same + // for all pixels), which avoids collecting per-pixel vectors in the hot loop. + let history_indices: Vec = frac_dates + .iter() + .enumerate() + .filter(|(_, &d)| d >= history_start_frac && d < monitor_start_frac) + .map(|(i, _)| i) + .collect(); + + let monitor_indices: Vec = frac_dates + .iter() + .enumerate() + .filter(|(_, &d)| d >= monitor_start_frac) + .map(|(i, _)| i) + .collect(); + + if history_indices.is_empty() || monitor_indices.is_empty() { + // No valid windows: output stays zeros (no break, no magnitude) + return Ok(out_array.into_pyarray(py).to_owned()); + } + let mut out_flat = out_array .view_mut() .into_shape((2, num_pixels)) .map_err(|e| CoreError::ComputationError(e.to_string()))?; - // Get mutable 1D views for each output channel + // Get mutable 1D views for each output channel (avoid panics; return Python-friendly errors) let mut out_slices = out_flat.axis_iter_mut(Axis(0)); - let mut break_dates = out_slices.next().unwrap(); - let mut magnitudes = out_slices.next().unwrap(); - - // Iterate over each pixel's time series in parallel - Zip::from(&mut break_dates) - .and(&mut magnitudes) - .and(stack_flat.axis_iter(Axis(1))) - .par_for_each(|break_date, magnitude, pixel_ts| { - let (bk_date, mag) = run_bfast_monitor_per_pixel( - pixel_ts.as_slice().unwrap(), - &frac_dates, - history_start_frac, - monitor_start_frac, - order, - h, - alpha, - ); - *break_date = bk_date; - *magnitude = mag; + + let mut break_dates = out_slices.next().ok_or_else(|| { + CoreError::ComputationError( + "Internal error: failed to create break_dates output view (missing channel 0)".to_string(), + ) + })?; + + let mut magnitudes = out_slices.next().ok_or_else(|| { + CoreError::ComputationError( + "Internal error: failed to create magnitudes output view (missing channel 1)".to_string(), + ) + })?; + + // NOTE: Pixel time series for a (time, y, x) input are strided, so we avoid relying on + // `pixel_ts.as_slice()` entirely. Instead, we index into `stack_flat[(t, pix)]`. + // + // To write outputs in parallel safely, we: + // 1) ensure each output channel is a contiguous 1D slice + // 2) split each output slice into disjoint chunks + // 3) process chunks in parallel, writing only within the current chunk + let break_dates_slice = break_dates + .as_slice_mut() + .ok_or_else(|| CoreError::ComputationError("break_dates output buffer is not contiguous".to_string()))?; + let magnitudes_slice = magnitudes + .as_slice_mut() + .ok_or_else(|| CoreError::ComputationError("magnitudes output buffer is not contiguous".to_string()))?; + + // Parallelize over disjoint mutable chunks for both outputs. + break_dates_slice + .par_chunks_mut(BFAST_PIXELS_PER_CHUNK) + .zip(magnitudes_slice.par_chunks_mut(BFAST_PIXELS_PER_CHUNK)) + .enumerate() + .for_each(|(chunk_idx, (break_chunk, mag_chunk))| { + let start = chunk_idx * BFAST_PIXELS_PER_CHUNK; + let end = start + break_chunk.len(); // last chunk may be shorter + + // Reusable buffers for this worker/chunk. + let mut history_ts: Vec = Vec::with_capacity(history_indices.len()); + let mut history_dates: Vec = Vec::with_capacity(history_indices.len()); + let mut monitor_ts: Vec = Vec::with_capacity(monitor_indices.len()); + let mut monitor_dates: Vec = Vec::with_capacity(monitor_indices.len()); + + for pix in start..end { + history_ts.clear(); + history_dates.clear(); + monitor_ts.clear(); + monitor_dates.clear(); + + // Fill history buffers + for &ti in &history_indices { + history_ts.push(stack_flat[(ti, pix)]); + history_dates.push(frac_dates[ti]); + } + + // Fill monitoring buffers + for &ti in &monitor_indices { + monitor_ts.push(stack_flat[(ti, pix)]); + monitor_dates.push(frac_dates[ti]); + } + + let (bk_date, mag) = run_bfast_monitor_per_pixel_windows( + &history_ts, + &history_dates, + &monitor_ts, + &monitor_dates, + order, + h, + alpha, + ); + + let local = pix - start; + break_chunk[local] = bk_date; + mag_chunk[local] = mag; + } }); Ok(out_array.into_pyarray(py).to_owned()) diff --git a/uv.lock b/uv.lock index 763e636..ca15806 100644 --- a/uv.lock +++ b/uv.lock @@ -233,6 +233,249 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "contourpy" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, +] +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.12'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +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 = "dask" version = "2024.8.0" @@ -315,6 +558,8 @@ source = { editable = "." } dependencies = [ { name = "dask", version = "2024.8.0", source = { registry = "https://pypi.org/simple" }, extra = ["array"], marker = "python_full_version < '3.10'" }, { name = "dask", version = "2025.11.0", source = { registry = "https://pypi.org/simple" }, extra = ["array"], marker = "python_full_version >= '3.10'" }, + { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "matplotlib", version = "3.10.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, { name = "maturin" }, { name = "numpy", version = "2.0.2", 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.*'" }, @@ -372,6 +617,7 @@ requires-dist = [ { name = "dask", extras = ["array"], specifier = ">=2023.0.0" }, { name = "furo", marker = "extra == 'docs'", specifier = ">=2024.1.0" }, { name = "linkify-it-py", marker = "extra == 'docs'", specifier = ">=2.0.0" }, + { name = "matplotlib", specifier = ">=3.9.4" }, { name = "maturin", specifier = ">=1.9.6" }, { name = "myst-parser", marker = "extra == 'docs'", specifier = ">=2.0.0" }, { name = "numpy", specifier = ">=1.20.0" }, @@ -435,6 +681,136 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" }, ] +[[package]] +name = "fonttools" +version = "4.60.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +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.61.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/ec/ca/cf17b88a8df95691275a3d77dc0a5ad9907f328ae53acbe6795da1b2f5ed/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69", size = 3565756, upload-time = "2025-12-12T17:31:24.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/94/8a28707adb00bed1bf22dac16ccafe60faf2ade353dcb32c3617ee917307/fonttools-4.61.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c7db70d57e5e1089a274cbb2b1fd635c9a24de809a231b154965d415d6c6d24", size = 2854799, upload-time = "2025-12-12T17:29:27.5Z" }, + { url = "https://files.pythonhosted.org/packages/94/93/c2e682faaa5ee92034818d8f8a8145ae73eb83619600495dcf8503fa7771/fonttools-4.61.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5fe9fd43882620017add5eabb781ebfbc6998ee49b35bd7f8f79af1f9f99a958", size = 2403032, upload-time = "2025-12-12T17:29:30.115Z" }, + { url = "https://files.pythonhosted.org/packages/f1/62/1748f7e7e1ee41aa52279fd2e3a6d0733dc42a673b16932bad8e5d0c8b28/fonttools-4.61.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8db08051fc9e7d8bc622f2112511b8107d8f27cd89e2f64ec45e9825e8288da", size = 4897863, upload-time = "2025-12-12T17:29:32.535Z" }, + { url = "https://files.pythonhosted.org/packages/69/69/4ca02ee367d2c98edcaeb83fc278d20972502ee071214ad9d8ca85e06080/fonttools-4.61.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a76d4cb80f41ba94a6691264be76435e5f72f2cb3cab0b092a6212855f71c2f6", size = 4859076, upload-time = "2025-12-12T17:29:34.907Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f5/660f9e3cefa078861a7f099107c6d203b568a6227eef163dd173bfc56bdc/fonttools-4.61.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a13fc8aeb24bad755eea8f7f9d409438eb94e82cf86b08fe77a03fbc8f6a96b1", size = 4875623, upload-time = "2025-12-12T17:29:37.33Z" }, + { url = "https://files.pythonhosted.org/packages/63/d1/9d7c5091d2276ed47795c131c1bf9316c3c1ab2789c22e2f59e0572ccd38/fonttools-4.61.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b846a1fcf8beadeb9ea4f44ec5bdde393e2f1569e17d700bfc49cd69bde75881", size = 4993327, upload-time = "2025-12-12T17:29:39.781Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2d/28def73837885ae32260d07660a052b99f0aa00454867d33745dfe49dbf0/fonttools-4.61.1-cp310-cp310-win32.whl", hash = "sha256:78a7d3ab09dc47ac1a363a493e6112d8cabed7ba7caad5f54dbe2f08676d1b47", size = 1502180, upload-time = "2025-12-12T17:29:42.217Z" }, + { url = "https://files.pythonhosted.org/packages/63/fa/bfdc98abb4dd2bd491033e85e3ba69a2313c850e759a6daa014bc9433b0f/fonttools-4.61.1-cp310-cp310-win_amd64.whl", hash = "sha256:eff1ac3cc66c2ac7cda1e64b4e2f3ffef474b7335f92fc3833fc632d595fcee6", size = 1550654, upload-time = "2025-12-12T17:29:44.564Z" }, + { url = "https://files.pythonhosted.org/packages/69/12/bf9f4eaa2fad039356cc627587e30ed008c03f1cebd3034376b5ee8d1d44/fonttools-4.61.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c6604b735bb12fef8e0efd5578c9fb5d3d8532d5001ea13a19cddf295673ee09", size = 2852213, upload-time = "2025-12-12T17:29:46.675Z" }, + { url = "https://files.pythonhosted.org/packages/ac/49/4138d1acb6261499bedde1c07f8c2605d1d8f9d77a151e5507fd3ef084b6/fonttools-4.61.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ce02f38a754f207f2f06557523cd39a06438ba3aafc0639c477ac409fc64e37", size = 2401689, upload-time = "2025-12-12T17:29:48.769Z" }, + { url = "https://files.pythonhosted.org/packages/e5/fe/e6ce0fe20a40e03aef906af60aa87668696f9e4802fa283627d0b5ed777f/fonttools-4.61.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77efb033d8d7ff233385f30c62c7c79271c8885d5c9657d967ede124671bbdfb", size = 5058809, upload-time = "2025-12-12T17:29:51.701Z" }, + { url = "https://files.pythonhosted.org/packages/79/61/1ca198af22f7dd22c17ab86e9024ed3c06299cfdb08170640e9996d501a0/fonttools-4.61.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c1a6dfac6abd407634420c93864a1e274ebc1c7531346d9254c0d8f6ca00f9", size = 5036039, upload-time = "2025-12-12T17:29:53.659Z" }, + { url = "https://files.pythonhosted.org/packages/99/cc/fa1801e408586b5fce4da9f5455af8d770f4fc57391cd5da7256bb364d38/fonttools-4.61.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0de30bfe7745c0d1ffa2b0b7048fb7123ad0d71107e10ee090fa0b16b9452e87", size = 5034714, upload-time = "2025-12-12T17:29:55.592Z" }, + { url = "https://files.pythonhosted.org/packages/bf/aa/b7aeafe65adb1b0a925f8f25725e09f078c635bc22754f3fecb7456955b0/fonttools-4.61.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58b0ee0ab5b1fc9921eccfe11d1435added19d6494dde14e323f25ad2bc30c56", size = 5158648, upload-time = "2025-12-12T17:29:57.861Z" }, + { url = "https://files.pythonhosted.org/packages/99/f9/08ea7a38663328881384c6e7777bbefc46fd7d282adfd87a7d2b84ec9d50/fonttools-4.61.1-cp311-cp311-win32.whl", hash = "sha256:f79b168428351d11e10c5aeb61a74e1851ec221081299f4cf56036a95431c43a", size = 2280681, upload-time = "2025-12-12T17:29:59.943Z" }, + { url = "https://files.pythonhosted.org/packages/07/ad/37dd1ae5fa6e01612a1fbb954f0927681f282925a86e86198ccd7b15d515/fonttools-4.61.1-cp311-cp311-win_amd64.whl", hash = "sha256:fe2efccb324948a11dd09d22136fe2ac8a97d6c1347cf0b58a911dcd529f66b7", size = 2331951, upload-time = "2025-12-12T17:30:02.254Z" }, + { url = "https://files.pythonhosted.org/packages/6f/16/7decaa24a1bd3a70c607b2e29f0adc6159f36a7e40eaba59846414765fd4/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e", size = 2851593, upload-time = "2025-12-12T17:30:04.225Z" }, + { url = "https://files.pythonhosted.org/packages/94/98/3c4cb97c64713a8cf499b3245c3bf9a2b8fd16a3e375feff2aed78f96259/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2", size = 2400231, upload-time = "2025-12-12T17:30:06.47Z" }, + { url = "https://files.pythonhosted.org/packages/b7/37/82dbef0f6342eb01f54bca073ac1498433d6ce71e50c3c3282b655733b31/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796", size = 4954103, upload-time = "2025-12-12T17:30:08.432Z" }, + { url = "https://files.pythonhosted.org/packages/6c/44/f3aeac0fa98e7ad527f479e161aca6c3a1e47bb6996b053d45226fe37bf2/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d", size = 5004295, upload-time = "2025-12-12T17:30:10.56Z" }, + { url = "https://files.pythonhosted.org/packages/14/e8/7424ced75473983b964d09f6747fa09f054a6d656f60e9ac9324cf40c743/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8", size = 4944109, upload-time = "2025-12-12T17:30:12.874Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8b/6391b257fa3d0b553d73e778f953a2f0154292a7a7a085e2374b111e5410/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0", size = 5093598, upload-time = "2025-12-12T17:30:15.79Z" }, + { url = "https://files.pythonhosted.org/packages/d9/71/fd2ea96cdc512d92da5678a1c98c267ddd4d8c5130b76d0f7a80f9a9fde8/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261", size = 2269060, upload-time = "2025-12-12T17:30:18.058Z" }, + { url = "https://files.pythonhosted.org/packages/80/3b/a3e81b71aed5a688e89dfe0e2694b26b78c7d7f39a5ffd8a7d75f54a12a8/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9", size = 2319078, upload-time = "2025-12-12T17:30:22.862Z" }, + { url = "https://files.pythonhosted.org/packages/4b/cf/00ba28b0990982530addb8dc3e9e6f2fa9cb5c20df2abdda7baa755e8fe1/fonttools-4.61.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c56c488ab471628ff3bfa80964372fc13504ece601e0d97a78ee74126b2045c", size = 2846454, upload-time = "2025-12-12T17:30:24.938Z" }, + { url = "https://files.pythonhosted.org/packages/5a/ca/468c9a8446a2103ae645d14fee3f610567b7042aba85031c1c65e3ef7471/fonttools-4.61.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc492779501fa723b04d0ab1f5be046797fee17d27700476edc7ee9ae535a61e", size = 2398191, upload-time = "2025-12-12T17:30:27.343Z" }, + { url = "https://files.pythonhosted.org/packages/a3/4b/d67eedaed19def5967fade3297fed8161b25ba94699efc124b14fb68cdbc/fonttools-4.61.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:64102ca87e84261419c3747a0d20f396eb024bdbeb04c2bfb37e2891f5fadcb5", size = 4928410, upload-time = "2025-12-12T17:30:29.771Z" }, + { url = "https://files.pythonhosted.org/packages/b0/8d/6fb3494dfe61a46258cd93d979cf4725ded4eb46c2a4ca35e4490d84daea/fonttools-4.61.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c1b526c8d3f615a7b1867f38a9410849c8f4aef078535742198e942fba0e9bd", size = 4984460, upload-time = "2025-12-12T17:30:32.073Z" }, + { url = "https://files.pythonhosted.org/packages/f7/f1/a47f1d30b3dc00d75e7af762652d4cbc3dff5c2697a0dbd5203c81afd9c3/fonttools-4.61.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41ed4b5ec103bd306bb68f81dc166e77409e5209443e5773cb4ed837bcc9b0d3", size = 4925800, upload-time = "2025-12-12T17:30:34.339Z" }, + { url = "https://files.pythonhosted.org/packages/a7/01/e6ae64a0981076e8a66906fab01539799546181e32a37a0257b77e4aa88b/fonttools-4.61.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b501c862d4901792adaec7c25b1ecc749e2662543f68bb194c42ba18d6eec98d", size = 5067859, upload-time = "2025-12-12T17:30:36.593Z" }, + { url = "https://files.pythonhosted.org/packages/73/aa/28e40b8d6809a9b5075350a86779163f074d2b617c15d22343fce81918db/fonttools-4.61.1-cp313-cp313-win32.whl", hash = "sha256:4d7092bb38c53bbc78e9255a59158b150bcdc115a1e3b3ce0b5f267dc35dd63c", size = 2267821, upload-time = "2025-12-12T17:30:38.478Z" }, + { url = "https://files.pythonhosted.org/packages/1a/59/453c06d1d83dc0951b69ef692d6b9f1846680342927df54e9a1ca91c6f90/fonttools-4.61.1-cp313-cp313-win_amd64.whl", hash = "sha256:21e7c8d76f62ab13c9472ccf74515ca5b9a761d1bde3265152a6dc58700d895b", size = 2318169, upload-time = "2025-12-12T17:30:40.951Z" }, + { url = "https://files.pythonhosted.org/packages/32/8f/4e7bf82c0cbb738d3c2206c920ca34ca74ef9dabde779030145d28665104/fonttools-4.61.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fff4f534200a04b4a36e7ae3cb74493afe807b517a09e99cb4faa89a34ed6ecd", size = 2846094, upload-time = "2025-12-12T17:30:43.511Z" }, + { url = "https://files.pythonhosted.org/packages/71/09/d44e45d0a4f3a651f23a1e9d42de43bc643cce2971b19e784cc67d823676/fonttools-4.61.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d9203500f7c63545b4ce3799319fe4d9feb1a1b89b28d3cb5abd11b9dd64147e", size = 2396589, upload-time = "2025-12-12T17:30:45.681Z" }, + { url = "https://files.pythonhosted.org/packages/89/18/58c64cafcf8eb677a99ef593121f719e6dcbdb7d1c594ae5a10d4997ca8a/fonttools-4.61.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fa646ecec9528bef693415c79a86e733c70a4965dd938e9a226b0fc64c9d2e6c", size = 4877892, upload-time = "2025-12-12T17:30:47.709Z" }, + { url = "https://files.pythonhosted.org/packages/8a/ec/9e6b38c7ba1e09eb51db849d5450f4c05b7e78481f662c3b79dbde6f3d04/fonttools-4.61.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11f35ad7805edba3aac1a3710d104592df59f4b957e30108ae0ba6c10b11dd75", size = 4972884, upload-time = "2025-12-12T17:30:49.656Z" }, + { url = "https://files.pythonhosted.org/packages/5e/87/b5339da8e0256734ba0dbbf5b6cdebb1dd79b01dc8c270989b7bcd465541/fonttools-4.61.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b931ae8f62db78861b0ff1ac017851764602288575d65b8e8ff1963fed419063", size = 4924405, upload-time = "2025-12-12T17:30:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/0b/47/e3409f1e1e69c073a3a6fd8cb886eb18c0bae0ee13db2c8d5e7f8495e8b7/fonttools-4.61.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b148b56f5de675ee16d45e769e69f87623a4944f7443850bf9a9376e628a89d2", size = 5035553, upload-time = "2025-12-12T17:30:54.823Z" }, + { url = "https://files.pythonhosted.org/packages/bf/b6/1f6600161b1073a984294c6c031e1a56ebf95b6164249eecf30012bb2e38/fonttools-4.61.1-cp314-cp314-win32.whl", hash = "sha256:9b666a475a65f4e839d3d10473fad6d47e0a9db14a2f4a224029c5bfde58ad2c", size = 2271915, upload-time = "2025-12-12T17:30:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/52/7b/91e7b01e37cc8eb0e1f770d08305b3655e4f002fc160fb82b3390eabacf5/fonttools-4.61.1-cp314-cp314-win_amd64.whl", hash = "sha256:4f5686e1fe5fce75d82d93c47a438a25bf0d1319d2843a926f741140b2b16e0c", size = 2323487, upload-time = "2025-12-12T17:30:59.804Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/908ad78e46c61c3e3ed70c3b58ff82ab48437faf84ec84f109592cabbd9f/fonttools-4.61.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e76ce097e3c57c4bcb67c5aa24a0ecdbd9f74ea9219997a707a4061fbe2707aa", size = 2929571, upload-time = "2025-12-12T17:31:02.574Z" }, + { url = "https://files.pythonhosted.org/packages/bd/41/975804132c6dea64cdbfbaa59f3518a21c137a10cccf962805b301ac6ab2/fonttools-4.61.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9cfef3ab326780c04d6646f68d4b4742aae222e8b8ea1d627c74e38afcbc9d91", size = 2435317, upload-time = "2025-12-12T17:31:04.974Z" }, + { url = "https://files.pythonhosted.org/packages/b0/5a/aef2a0a8daf1ebaae4cfd83f84186d4a72ee08fd6a8451289fcd03ffa8a4/fonttools-4.61.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a75c301f96db737e1c5ed5fd7d77d9c34466de16095a266509e13da09751bd19", size = 4882124, upload-time = "2025-12-12T17:31:07.456Z" }, + { url = "https://files.pythonhosted.org/packages/80/33/d6db3485b645b81cea538c9d1c9219d5805f0877fda18777add4671c5240/fonttools-4.61.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91669ccac46bbc1d09e9273546181919064e8df73488ea087dcac3e2968df9ba", size = 5100391, upload-time = "2025-12-12T17:31:09.732Z" }, + { url = "https://files.pythonhosted.org/packages/6c/d6/675ba631454043c75fcf76f0ca5463eac8eb0666ea1d7badae5fea001155/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c33ab3ca9d3ccd581d58e989d67554e42d8d4ded94ab3ade3508455fe70e65f7", size = 4978800, upload-time = "2025-12-12T17:31:11.681Z" }, + { url = "https://files.pythonhosted.org/packages/7f/33/d3ec753d547a8d2bdaedd390d4a814e8d5b45a093d558f025c6b990b554c/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:664c5a68ec406f6b1547946683008576ef8b38275608e1cee6c061828171c118", size = 5006426, upload-time = "2025-12-12T17:31:13.764Z" }, + { url = "https://files.pythonhosted.org/packages/b4/40/cc11f378b561a67bea850ab50063366a0d1dd3f6d0a30ce0f874b0ad5664/fonttools-4.61.1-cp314-cp314t-win32.whl", hash = "sha256:aed04cabe26f30c1647ef0e8fbb207516fd40fe9472e9439695f5c6998e60ac5", size = 2335377, upload-time = "2025-12-12T17:31:16.49Z" }, + { url = "https://files.pythonhosted.org/packages/e4/ff/c9a2b66b39f8628531ea58b320d66d951267c98c6a38684daa8f50fb02f8/fonttools-4.61.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2180f14c141d2f0f3da43f3a81bc8aa4684860f6b0e6f9e165a4831f24e6a23b", size = 2400613, upload-time = "2025-12-12T17:31:18.769Z" }, + { url = "https://files.pythonhosted.org/packages/c7/4e/ce75a57ff3aebf6fc1f4e9d508b8e5810618a33d900ad6c19eb30b290b97/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371", size = 1148996, upload-time = "2025-12-12T17:31:21.03Z" }, +] + [[package]] name = "fsspec" version = "2025.10.0" @@ -506,6 +882,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" }, ] +[[package]] +name = "importlib-resources" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp", marker = "python_full_version < '3.10'" }, +] +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]] name = "iniconfig" version = "2.1.0" @@ -553,6 +941,222 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1e/e8/685f47e0d754320684db4425a0967f7d3fa70126bffd76110b7009a0090f/joblib-1.5.2-py3-none-any.whl", hash = "sha256:4e1f0bdbb987e6d843c70cf43714cb276623def372df3c22fe5266b2670bc241", size = 308396, upload-time = "2025-08-27T12:15:45.188Z" }, ] +[[package]] +name = "kiwisolver" +version = "1.4.7" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +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/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/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/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.4.9" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564, upload-time = "2025-08-10T21:27:49.279Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/5d/8ce64e36d4e3aac5ca96996457dcf33e34e6051492399a3f1fec5657f30b/kiwisolver-1.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b4b4d74bda2b8ebf4da5bd42af11d02d04428b2c32846e4c2c93219df8a7987b", size = 124159, upload-time = "2025-08-10T21:25:35.472Z" }, + { url = "https://files.pythonhosted.org/packages/96/1e/22f63ec454874378175a5f435d6ea1363dd33fb2af832c6643e4ccea0dc8/kiwisolver-1.4.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fb3b8132019ea572f4611d770991000d7f58127560c4889729248eb5852a102f", size = 66578, upload-time = "2025-08-10T21:25:36.73Z" }, + { url = "https://files.pythonhosted.org/packages/41/4c/1925dcfff47a02d465121967b95151c82d11027d5ec5242771e580e731bd/kiwisolver-1.4.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84fd60810829c27ae375114cd379da1fa65e6918e1da405f356a775d49a62bcf", size = 65312, upload-time = "2025-08-10T21:25:37.658Z" }, + { url = "https://files.pythonhosted.org/packages/d4/42/0f333164e6307a0687d1eb9ad256215aae2f4bd5d28f4653d6cd319a3ba3/kiwisolver-1.4.9-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b78efa4c6e804ecdf727e580dbb9cba85624d2e1c6b5cb059c66290063bd99a9", size = 1628458, upload-time = "2025-08-10T21:25:39.067Z" }, + { url = "https://files.pythonhosted.org/packages/86/b6/2dccb977d651943995a90bfe3495c2ab2ba5cd77093d9f2318a20c9a6f59/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4efec7bcf21671db6a3294ff301d2fc861c31faa3c8740d1a94689234d1b415", size = 1225640, upload-time = "2025-08-10T21:25:40.489Z" }, + { url = "https://files.pythonhosted.org/packages/50/2b/362ebd3eec46c850ccf2bfe3e30f2fc4c008750011f38a850f088c56a1c6/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:90f47e70293fc3688b71271100a1a5453aa9944a81d27ff779c108372cf5567b", size = 1244074, upload-time = "2025-08-10T21:25:42.221Z" }, + { url = "https://files.pythonhosted.org/packages/6f/bb/f09a1e66dab8984773d13184a10a29fe67125337649d26bdef547024ed6b/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fdca1def57a2e88ef339de1737a1449d6dbf5fab184c54a1fca01d541317154", size = 1293036, upload-time = "2025-08-10T21:25:43.801Z" }, + { url = "https://files.pythonhosted.org/packages/ea/01/11ecf892f201cafda0f68fa59212edaea93e96c37884b747c181303fccd1/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9cf554f21be770f5111a1690d42313e140355e687e05cf82cb23d0a721a64a48", size = 2175310, upload-time = "2025-08-10T21:25:45.045Z" }, + { url = "https://files.pythonhosted.org/packages/7f/5f/bfe11d5b934f500cc004314819ea92427e6e5462706a498c1d4fc052e08f/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1795ac5cd0510207482c3d1d3ed781143383b8cfd36f5c645f3897ce066220", size = 2270943, upload-time = "2025-08-10T21:25:46.393Z" }, + { url = "https://files.pythonhosted.org/packages/3d/de/259f786bf71f1e03e73d87e2db1a9a3bcab64d7b4fd780167123161630ad/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ccd09f20ccdbbd341b21a67ab50a119b64a403b09288c27481575105283c1586", size = 2440488, upload-time = "2025-08-10T21:25:48.074Z" }, + { url = "https://files.pythonhosted.org/packages/1b/76/c989c278faf037c4d3421ec07a5c452cd3e09545d6dae7f87c15f54e4edf/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:540c7c72324d864406a009d72f5d6856f49693db95d1fbb46cf86febef873634", size = 2246787, upload-time = "2025-08-10T21:25:49.442Z" }, + { url = "https://files.pythonhosted.org/packages/a2/55/c2898d84ca440852e560ca9f2a0d28e6e931ac0849b896d77231929900e7/kiwisolver-1.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:ede8c6d533bc6601a47ad4046080d36b8fc99f81e6f1c17b0ac3c2dc91ac7611", size = 73730, upload-time = "2025-08-10T21:25:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/e8/09/486d6ac523dd33b80b368247f238125d027964cfacb45c654841e88fb2ae/kiwisolver-1.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:7b4da0d01ac866a57dd61ac258c5607b4cd677f63abaec7b148354d2b2cdd536", size = 65036, upload-time = "2025-08-10T21:25:52.063Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ab/c80b0d5a9d8a1a65f4f815f2afff9798b12c3b9f31f1d304dd233dd920e2/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16", size = 124167, upload-time = "2025-08-10T21:25:53.403Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c0/27fe1a68a39cf62472a300e2879ffc13c0538546c359b86f149cc19f6ac3/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089", size = 66579, upload-time = "2025-08-10T21:25:54.79Z" }, + { url = "https://files.pythonhosted.org/packages/31/a2/a12a503ac1fd4943c50f9822678e8015a790a13b5490354c68afb8489814/kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543", size = 65309, upload-time = "2025-08-10T21:25:55.76Z" }, + { url = "https://files.pythonhosted.org/packages/66/e1/e533435c0be77c3f64040d68d7a657771194a63c279f55573188161e81ca/kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61", size = 1435596, upload-time = "2025-08-10T21:25:56.861Z" }, + { url = "https://files.pythonhosted.org/packages/67/1e/51b73c7347f9aabdc7215aa79e8b15299097dc2f8e67dee2b095faca9cb0/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1", size = 1246548, upload-time = "2025-08-10T21:25:58.246Z" }, + { url = "https://files.pythonhosted.org/packages/21/aa/72a1c5d1e430294f2d32adb9542719cfb441b5da368d09d268c7757af46c/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872", size = 1263618, upload-time = "2025-08-10T21:25:59.857Z" }, + { url = "https://files.pythonhosted.org/packages/a3/af/db1509a9e79dbf4c260ce0cfa3903ea8945f6240e9e59d1e4deb731b1a40/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26", size = 1317437, upload-time = "2025-08-10T21:26:01.105Z" }, + { url = "https://files.pythonhosted.org/packages/e0/f2/3ea5ee5d52abacdd12013a94130436e19969fa183faa1e7c7fbc89e9a42f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028", size = 2195742, upload-time = "2025-08-10T21:26:02.675Z" }, + { url = "https://files.pythonhosted.org/packages/6f/9b/1efdd3013c2d9a2566aa6a337e9923a00590c516add9a1e89a768a3eb2fc/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771", size = 2290810, upload-time = "2025-08-10T21:26:04.009Z" }, + { url = "https://files.pythonhosted.org/packages/fb/e5/cfdc36109ae4e67361f9bc5b41323648cb24a01b9ade18784657e022e65f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a", size = 2461579, upload-time = "2025-08-10T21:26:05.317Z" }, + { url = "https://files.pythonhosted.org/packages/62/86/b589e5e86c7610842213994cdea5add00960076bef4ae290c5fa68589cac/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464", size = 2268071, upload-time = "2025-08-10T21:26:06.686Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c6/f8df8509fd1eee6c622febe54384a96cfaf4d43bf2ccec7a0cc17e4715c9/kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2", size = 73840, upload-time = "2025-08-10T21:26:07.94Z" }, + { url = "https://files.pythonhosted.org/packages/e2/2d/16e0581daafd147bc11ac53f032a2b45eabac897f42a338d0a13c1e5c436/kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7", size = 65159, upload-time = "2025-08-10T21:26:09.048Z" }, + { url = "https://files.pythonhosted.org/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686, upload-time = "2025-08-10T21:26:10.034Z" }, + { url = "https://files.pythonhosted.org/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460, upload-time = "2025-08-10T21:26:11.083Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952, upload-time = "2025-08-10T21:26:12.058Z" }, + { url = "https://files.pythonhosted.org/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756, upload-time = "2025-08-10T21:26:13.096Z" }, + { url = "https://files.pythonhosted.org/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404, upload-time = "2025-08-10T21:26:14.457Z" }, + { url = "https://files.pythonhosted.org/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410, upload-time = "2025-08-10T21:26:15.73Z" }, + { url = "https://files.pythonhosted.org/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631, upload-time = "2025-08-10T21:26:17.045Z" }, + { url = "https://files.pythonhosted.org/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963, upload-time = "2025-08-10T21:26:18.737Z" }, + { url = "https://files.pythonhosted.org/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295, upload-time = "2025-08-10T21:26:20.11Z" }, + { url = "https://files.pythonhosted.org/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987, upload-time = "2025-08-10T21:26:21.49Z" }, + { url = "https://files.pythonhosted.org/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817, upload-time = "2025-08-10T21:26:22.812Z" }, + { url = "https://files.pythonhosted.org/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895, upload-time = "2025-08-10T21:26:24.37Z" }, + { url = "https://files.pythonhosted.org/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992, upload-time = "2025-08-10T21:26:25.732Z" }, + { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681, upload-time = "2025-08-10T21:26:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464, upload-time = "2025-08-10T21:26:27.733Z" }, + { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961, upload-time = "2025-08-10T21:26:28.729Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607, upload-time = "2025-08-10T21:26:29.798Z" }, + { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546, upload-time = "2025-08-10T21:26:31.401Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482, upload-time = "2025-08-10T21:26:32.721Z" }, + { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720, upload-time = "2025-08-10T21:26:34.032Z" }, + { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907, upload-time = "2025-08-10T21:26:35.824Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334, upload-time = "2025-08-10T21:26:37.534Z" }, + { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313, upload-time = "2025-08-10T21:26:39.191Z" }, + { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970, upload-time = "2025-08-10T21:26:40.828Z" }, + { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894, upload-time = "2025-08-10T21:26:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995, upload-time = "2025-08-10T21:26:43.889Z" }, + { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510, upload-time = "2025-08-10T21:26:44.915Z" }, + { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903, upload-time = "2025-08-10T21:26:45.934Z" }, + { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402, upload-time = "2025-08-10T21:26:47.101Z" }, + { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135, upload-time = "2025-08-10T21:26:48.665Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409, upload-time = "2025-08-10T21:26:50.335Z" }, + { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763, upload-time = "2025-08-10T21:26:51.867Z" }, + { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643, upload-time = "2025-08-10T21:26:53.592Z" }, + { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818, upload-time = "2025-08-10T21:26:55.051Z" }, + { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963, upload-time = "2025-08-10T21:26:56.421Z" }, + { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639, upload-time = "2025-08-10T21:26:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741, upload-time = "2025-08-10T21:26:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646, upload-time = "2025-08-10T21:27:00.52Z" }, + { url = "https://files.pythonhosted.org/packages/6b/32/6cc0fbc9c54d06c2969faa9c1d29f5751a2e51809dd55c69055e62d9b426/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386", size = 123806, upload-time = "2025-08-10T21:27:01.537Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/2bfb1d4a4823d92e8cbb420fe024b8d2167f72079b3bb941207c42570bdf/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552", size = 66605, upload-time = "2025-08-10T21:27:03.335Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/00aafdb4e4509c2ca6064646cba9cd4b37933898f426756adb2cb92ebbed/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3", size = 64925, upload-time = "2025-08-10T21:27:04.339Z" }, + { url = "https://files.pythonhosted.org/packages/43/dc/51acc6791aa14e5cb6d8a2e28cefb0dc2886d8862795449d021334c0df20/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58", size = 1472414, upload-time = "2025-08-10T21:27:05.437Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/93fa64a81db304ac8a246f834d5094fae4b13baf53c839d6bb6e81177129/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4", size = 1281272, upload-time = "2025-08-10T21:27:07.063Z" }, + { url = "https://files.pythonhosted.org/packages/70/e6/6df102916960fb8d05069d4bd92d6d9a8202d5a3e2444494e7cd50f65b7a/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df", size = 1298578, upload-time = "2025-08-10T21:27:08.452Z" }, + { url = "https://files.pythonhosted.org/packages/7c/47/e142aaa612f5343736b087864dbaebc53ea8831453fb47e7521fa8658f30/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6", size = 1345607, upload-time = "2025-08-10T21:27:10.125Z" }, + { url = "https://files.pythonhosted.org/packages/54/89/d641a746194a0f4d1a3670fb900d0dbaa786fb98341056814bc3f058fa52/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5", size = 2230150, upload-time = "2025-08-10T21:27:11.484Z" }, + { url = "https://files.pythonhosted.org/packages/aa/6b/5ee1207198febdf16ac11f78c5ae40861b809cbe0e6d2a8d5b0b3044b199/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf", size = 2325979, upload-time = "2025-08-10T21:27:12.917Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ff/b269eefd90f4ae14dcc74973d5a0f6d28d3b9bb1afd8c0340513afe6b39a/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5", size = 2491456, upload-time = "2025-08-10T21:27:14.353Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d4/10303190bd4d30de547534601e259a4fbf014eed94aae3e5521129215086/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce", size = 2294621, upload-time = "2025-08-10T21:27:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/28/e0/a9a90416fce5c0be25742729c2ea52105d62eda6c4be4d803c2a7be1fa50/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7", size = 75417, upload-time = "2025-08-10T21:27:17.436Z" }, + { url = "https://files.pythonhosted.org/packages/1f/10/6949958215b7a9a264299a7db195564e87900f709db9245e4ebdd3c70779/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c", size = 66582, upload-time = "2025-08-10T21:27:18.436Z" }, + { url = "https://files.pythonhosted.org/packages/ec/79/60e53067903d3bc5469b369fe0dfc6b3482e2133e85dae9daa9527535991/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548", size = 126514, upload-time = "2025-08-10T21:27:19.465Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/4843d3e8d46b072c12a38c97c57fab4608d36e13fe47d47ee96b4d61ba6f/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d", size = 67905, upload-time = "2025-08-10T21:27:20.51Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ae/29ffcbd239aea8b93108de1278271ae764dfc0d803a5693914975f200596/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c", size = 66399, upload-time = "2025-08-10T21:27:21.496Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ae/d7ba902aa604152c2ceba5d352d7b62106bedbccc8e95c3934d94472bfa3/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122", size = 1582197, upload-time = "2025-08-10T21:27:22.604Z" }, + { url = "https://files.pythonhosted.org/packages/f2/41/27c70d427eddb8bc7e4f16420a20fefc6f480312122a59a959fdfe0445ad/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64", size = 1390125, upload-time = "2025-08-10T21:27:24.036Z" }, + { url = "https://files.pythonhosted.org/packages/41/42/b3799a12bafc76d962ad69083f8b43b12bf4fe78b097b12e105d75c9b8f1/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134", size = 1402612, upload-time = "2025-08-10T21:27:25.773Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b5/a210ea073ea1cfaca1bb5c55a62307d8252f531beb364e18aa1e0888b5a0/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370", size = 1453990, upload-time = "2025-08-10T21:27:27.089Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ce/a829eb8c033e977d7ea03ed32fb3c1781b4fa0433fbadfff29e39c676f32/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21", size = 2331601, upload-time = "2025-08-10T21:27:29.343Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4b/b5e97eb142eb9cd0072dacfcdcd31b1c66dc7352b0f7c7255d339c0edf00/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a", size = 2422041, upload-time = "2025-08-10T21:27:30.754Z" }, + { url = "https://files.pythonhosted.org/packages/40/be/8eb4cd53e1b85ba4edc3a9321666f12b83113a178845593307a3e7891f44/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f", size = 2594897, upload-time = "2025-08-10T21:27:32.803Z" }, + { url = "https://files.pythonhosted.org/packages/99/dd/841e9a66c4715477ea0abc78da039832fbb09dac5c35c58dc4c41a407b8a/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369", size = 2391835, upload-time = "2025-08-10T21:27:34.23Z" }, + { url = "https://files.pythonhosted.org/packages/0c/28/4b2e5c47a0da96896fdfdb006340ade064afa1e63675d01ea5ac222b6d52/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891", size = 79988, upload-time = "2025-08-10T21:27:35.587Z" }, + { url = "https://files.pythonhosted.org/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260, upload-time = "2025-08-10T21:27:36.606Z" }, + { url = "https://files.pythonhosted.org/packages/a2/63/fde392691690f55b38d5dd7b3710f5353bf7a8e52de93a22968801ab8978/kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4d1d9e582ad4d63062d34077a9a1e9f3c34088a2ec5135b1f7190c07cf366527", size = 60183, upload-time = "2025-08-10T21:27:37.669Z" }, + { url = "https://files.pythonhosted.org/packages/27/b1/6aad34edfdb7cced27f371866f211332bba215bfd918ad3322a58f480d8b/kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:deed0c7258ceb4c44ad5ec7d9918f9f14fd05b2be86378d86cf50e63d1e7b771", size = 58675, upload-time = "2025-08-10T21:27:39.031Z" }, + { url = "https://files.pythonhosted.org/packages/9d/1a/23d855a702bb35a76faed5ae2ba3de57d323f48b1f6b17ee2176c4849463/kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a590506f303f512dff6b7f75fd2fd18e16943efee932008fe7140e5fa91d80e", size = 80277, upload-time = "2025-08-10T21:27:40.129Z" }, + { url = "https://files.pythonhosted.org/packages/5a/5b/5239e3c2b8fb5afa1e8508f721bb77325f740ab6994d963e61b2b7abcc1e/kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e09c2279a4d01f099f52d5c4b3d9e208e91edcbd1a175c9662a8b16e000fece9", size = 77994, upload-time = "2025-08-10T21:27:41.181Z" }, + { url = "https://files.pythonhosted.org/packages/f9/1c/5d4d468fb16f8410e596ed0eac02d2c68752aa7dc92997fe9d60a7147665/kiwisolver-1.4.9-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c9e7cdf45d594ee04d5be1b24dd9d49f3d1590959b2271fb30b5ca2b262c00fb", size = 73744, upload-time = "2025-08-10T21:27:42.254Z" }, + { url = "https://files.pythonhosted.org/packages/a3/0f/36d89194b5a32c054ce93e586d4049b6c2c22887b0eb229c61c68afd3078/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5", size = 60104, upload-time = "2025-08-10T21:27:43.287Z" }, + { url = "https://files.pythonhosted.org/packages/52/ba/4ed75f59e4658fd21fe7dde1fee0ac397c678ec3befba3fe6482d987af87/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa", size = 58592, upload-time = "2025-08-10T21:27:44.314Z" }, + { url = "https://files.pythonhosted.org/packages/33/01/a8ea7c5ea32a9b45ceeaee051a04c8ed4320f5add3c51bfa20879b765b70/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2", size = 80281, upload-time = "2025-08-10T21:27:45.369Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/dbd2ecdce306f1d07a1aaf324817ee993aab7aee9db47ceac757deabafbe/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f", size = 78009, upload-time = "2025-08-10T21:27:46.376Z" }, + { url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload-time = "2025-08-10T21:27:48.236Z" }, +] + [[package]] name = "lazy-loader" version = "0.4" @@ -694,6 +1298,149 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4e/d3/fe08482b5cd995033556d45041a4f4e76e7f0521112a9c9991d40d39825f/markupsafe-3.0.3-cp39-cp39-win_arm64.whl", hash = "sha256:38664109c14ffc9e7437e86b4dceb442b0096dfe3541d7864d9cbe1da4cf36c8", size = 13928, upload-time = "2025-09-27T18:37:39.037Z" }, ] +[[package]] +name = "matplotlib" +version = "3.9.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "contourpy", version = "1.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "cycler", marker = "python_full_version < '3.10'" }, + { name = "fonttools", version = "4.60.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "importlib-resources", marker = "python_full_version < '3.10'" }, + { name = "kiwisolver", version = "1.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "packaging", marker = "python_full_version < '3.10'" }, + { name = "pillow", version = "11.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "pyparsing", marker = "python_full_version < '3.10'" }, + { name = "python-dateutil", marker = "python_full_version < '3.10'" }, +] +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.8" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "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 = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "cycler", marker = "python_full_version >= '3.10'" }, + { name = "fonttools", version = "4.61.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "kiwisolver", version = "1.4.9", 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 = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging", marker = "python_full_version >= '3.10'" }, + { name = "pillow", version = "12.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "pyparsing", marker = "python_full_version >= '3.10'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/be/a30bd917018ad220c400169fba298f2bb7003c8ccbc0c3e24ae2aacad1e8/matplotlib-3.10.8-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:00270d217d6b20d14b584c521f810d60c5c78406dc289859776550df837dcda7", size = 8239828, upload-time = "2025-12-10T22:55:02.313Z" }, + { url = "https://files.pythonhosted.org/packages/58/27/ca01e043c4841078e82cf6e80a6993dfecd315c3d79f5f3153afbb8e1ec6/matplotlib-3.10.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:37b3c1cc42aa184b3f738cfa18c1c1d72fd496d85467a6cf7b807936d39aa656", size = 8128050, upload-time = "2025-12-10T22:55:04.997Z" }, + { url = "https://files.pythonhosted.org/packages/cb/aa/7ab67f2b729ae6a91bcf9dcac0affb95fb8c56f7fd2b2af894ae0b0cf6fa/matplotlib-3.10.8-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee40c27c795bda6a5292e9cff9890189d32f7e3a0bf04e0e3c9430c4a00c37df", size = 8700452, upload-time = "2025-12-10T22:55:07.47Z" }, + { url = "https://files.pythonhosted.org/packages/73/ae/2d5817b0acee3c49b7e7ccfbf5b273f284957cc8e270adf36375db353190/matplotlib-3.10.8-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a48f2b74020919552ea25d222d5cc6af9ca3f4eb43a93e14d068457f545c2a17", size = 9534928, upload-time = "2025-12-10T22:55:10.566Z" }, + { url = "https://files.pythonhosted.org/packages/c9/5b/8e66653e9f7c39cb2e5cab25fce4810daffa2bff02cbf5f3077cea9e942c/matplotlib-3.10.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f254d118d14a7f99d616271d6c3c27922c092dac11112670b157798b89bf4933", size = 9586377, upload-time = "2025-12-10T22:55:12.362Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/fd0bbadf837f81edb0d208ba8f8cb552874c3b16e27cb91a31977d90875d/matplotlib-3.10.8-cp310-cp310-win_amd64.whl", hash = "sha256:f9b587c9c7274c1613a30afabf65a272114cd6cdbe67b3406f818c79d7ab2e2a", size = 8128127, upload-time = "2025-12-10T22:55:14.436Z" }, + { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" }, + { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" }, + { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" }, + { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" }, + { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" }, + { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" }, + { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" }, + { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" }, + { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" }, + { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b9/15fd5541ef4f5b9a17eefd379356cf12175fe577424e7b1d80676516031a/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6", size = 8261076, upload-time = "2025-12-10T22:55:44.648Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a0/2ba3473c1b66b9c74dc7107c67e9008cb1782edbe896d4c899d39ae9cf78/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1", size = 8148794, upload-time = "2025-12-10T22:55:46.252Z" }, + { url = "https://files.pythonhosted.org/packages/75/97/a471f1c3eb1fd6f6c24a31a5858f443891d5127e63a7788678d14e249aea/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486", size = 8718474, upload-time = "2025-12-10T22:55:47.864Z" }, + { url = "https://files.pythonhosted.org/packages/01/be/cd478f4b66f48256f42927d0acbcd63a26a893136456cd079c0cc24fbabf/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce", size = 9549637, upload-time = "2025-12-10T22:55:50.048Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7c/8dc289776eae5109e268c4fb92baf870678dc048a25d4ac903683b86d5bf/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6", size = 9613678, upload-time = "2025-12-10T22:55:52.21Z" }, + { url = "https://files.pythonhosted.org/packages/64/40/37612487cc8a437d4dd261b32ca21fe2d79510fe74af74e1f42becb1bdb8/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149", size = 8142686, upload-time = "2025-12-10T22:55:54.253Z" }, + { url = "https://files.pythonhosted.org/packages/66/52/8d8a8730e968185514680c2a6625943f70269509c3dcfc0dcf7d75928cb8/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645", size = 8012917, upload-time = "2025-12-10T22:55:56.268Z" }, + { url = "https://files.pythonhosted.org/packages/b5/27/51fe26e1062f298af5ef66343d8ef460e090a27fea73036c76c35821df04/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077", size = 8305679, upload-time = "2025-12-10T22:55:57.856Z" }, + { url = "https://files.pythonhosted.org/packages/2c/1e/4de865bc591ac8e3062e835f42dd7fe7a93168d519557837f0e37513f629/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22", size = 8198336, upload-time = "2025-12-10T22:55:59.371Z" }, + { url = "https://files.pythonhosted.org/packages/c6/cb/2f7b6e75fb4dce87ef91f60cac4f6e34f4c145ab036a22318ec837971300/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39", size = 8731653, upload-time = "2025-12-10T22:56:01.032Z" }, + { url = "https://files.pythonhosted.org/packages/46/b3/bd9c57d6ba670a37ab31fb87ec3e8691b947134b201f881665b28cc039ff/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565", size = 9561356, upload-time = "2025-12-10T22:56:02.95Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3d/8b94a481456dfc9dfe6e39e93b5ab376e50998cddfd23f4ae3b431708f16/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a", size = 9614000, upload-time = "2025-12-10T22:56:05.411Z" }, + { url = "https://files.pythonhosted.org/packages/bd/cd/bc06149fe5585ba800b189a6a654a75f1f127e8aab02fd2be10df7fa500c/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958", size = 8220043, upload-time = "2025-12-10T22:56:07.551Z" }, + { url = "https://files.pythonhosted.org/packages/e3/de/b22cf255abec916562cc04eef457c13e58a1990048de0c0c3604d082355e/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5", size = 8062075, upload-time = "2025-12-10T22:56:09.178Z" }, + { url = "https://files.pythonhosted.org/packages/3c/43/9c0ff7a2f11615e516c3b058e1e6e8f9614ddeca53faca06da267c48345d/matplotlib-3.10.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b53285e65d4fa4c86399979e956235deb900be5baa7fc1218ea67fbfaeaadd6f", size = 8262481, upload-time = "2025-12-10T22:56:10.885Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ca/e8ae28649fcdf039fda5ef554b40a95f50592a3c47e6f7270c9561c12b07/matplotlib-3.10.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32f8dce744be5569bebe789e46727946041199030db8aeb2954d26013a0eb26b", size = 8151473, upload-time = "2025-12-10T22:56:12.377Z" }, + { url = "https://files.pythonhosted.org/packages/f1/6f/009d129ae70b75e88cbe7e503a12a4c0670e08ed748a902c2568909e9eb5/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cf267add95b1c88300d96ca837833d4112756045364f5c734a2276038dae27d", size = 9553896, upload-time = "2025-12-10T22:56:14.432Z" }, + { url = "https://files.pythonhosted.org/packages/f5/26/4221a741eb97967bc1fd5e4c52b9aa5a91b2f4ec05b59f6def4d820f9df9/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2cf5bd12cecf46908f286d7838b2abc6c91cda506c0445b8223a7c19a00df008", size = 9824193, upload-time = "2025-12-10T22:56:16.29Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/3abf75f38605772cf48a9daf5821cd4f563472f38b4b828c6fba6fa6d06e/matplotlib-3.10.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:41703cc95688f2516b480f7f339d8851a6035f18e100ee6a32bc0b8536a12a9c", size = 9615444, upload-time = "2025-12-10T22:56:18.155Z" }, + { url = "https://files.pythonhosted.org/packages/93/a5/de89ac80f10b8dc615807ee1133cd99ac74082581196d4d9590bea10690d/matplotlib-3.10.8-cp314-cp314-win_amd64.whl", hash = "sha256:83d282364ea9f3e52363da262ce32a09dfe241e4080dcedda3c0db059d3c1f11", size = 8272719, upload-time = "2025-12-10T22:56:20.366Z" }, + { url = "https://files.pythonhosted.org/packages/69/ce/b006495c19ccc0a137b48083168a37bd056392dee02f87dba0472f2797fe/matplotlib-3.10.8-cp314-cp314-win_arm64.whl", hash = "sha256:2c1998e92cd5999e295a731bcb2911c75f597d937341f3030cc24ef2733d78a8", size = 8144205, upload-time = "2025-12-10T22:56:22.239Z" }, + { url = "https://files.pythonhosted.org/packages/68/d9/b31116a3a855bd313c6fcdb7226926d59b041f26061c6c5b1be66a08c826/matplotlib-3.10.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b5a2b97dbdc7d4f353ebf343744f1d1f1cca8aa8bfddb4262fcf4306c3761d50", size = 8305785, upload-time = "2025-12-10T22:56:24.218Z" }, + { url = "https://files.pythonhosted.org/packages/1e/90/6effe8103f0272685767ba5f094f453784057072f49b393e3ea178fe70a5/matplotlib-3.10.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3f5c3e4da343bba819f0234186b9004faba952cc420fbc522dc4e103c1985908", size = 8198361, upload-time = "2025-12-10T22:56:26.787Z" }, + { url = "https://files.pythonhosted.org/packages/d7/65/a73188711bea603615fc0baecca1061429ac16940e2385433cc778a9d8e7/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f62550b9a30afde8c1c3ae450e5eb547d579dd69b25c2fc7a1c67f934c1717a", size = 9561357, upload-time = "2025-12-10T22:56:28.953Z" }, + { url = "https://files.pythonhosted.org/packages/f4/3d/b5c5d5d5be8ce63292567f0e2c43dde9953d3ed86ac2de0a72e93c8f07a1/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:495672de149445ec1b772ff2c9ede9b769e3cb4f0d0aa7fa730d7f59e2d4e1c1", size = 9823610, upload-time = "2025-12-10T22:56:31.455Z" }, + { url = "https://files.pythonhosted.org/packages/4d/4b/e7beb6bbd49f6bae727a12b270a2654d13c397576d25bd6786e47033300f/matplotlib-3.10.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:595ba4d8fe983b88f0eec8c26a241e16d6376fe1979086232f481f8f3f67494c", size = 9614011, upload-time = "2025-12-10T22:56:33.85Z" }, + { url = "https://files.pythonhosted.org/packages/7c/e6/76f2813d31f032e65f6f797e3f2f6e4aab95b65015924b1c51370395c28a/matplotlib-3.10.8-cp314-cp314t-win_amd64.whl", hash = "sha256:25d380fe8b1dc32cf8f0b1b448470a77afb195438bafdf1d858bfb876f3edf7b", size = 8362801, upload-time = "2025-12-10T22:56:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/5d/49/d651878698a0b67f23aa28e17f45a6d6dd3d3f933fa29087fa4ce5947b5a/matplotlib-3.10.8-cp314-cp314t-win_arm64.whl", hash = "sha256:113bb52413ea508ce954a02c10ffd0d565f9c3bc7f2eddc27dfe1731e71c7b5f", size = 8192560, upload-time = "2025-12-10T22:56:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/f5/43/31d59500bb950b0d188e149a2e552040528c13d6e3d6e84d0cccac593dcd/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f97aeb209c3d2511443f8797e3e5a569aebb040d4f8bc79aa3ee78a8fb9e3dd8", size = 8237252, upload-time = "2025-12-10T22:56:39.529Z" }, + { url = "https://files.pythonhosted.org/packages/0c/2c/615c09984f3c5f907f51c886538ad785cf72e0e11a3225de2c0f9442aecc/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fb061f596dad3a0f52b60dc6a5dec4a0c300dec41e058a7efe09256188d170b7", size = 8124693, upload-time = "2025-12-10T22:56:41.758Z" }, + { url = "https://files.pythonhosted.org/packages/91/e1/2757277a1c56041e1fc104b51a0f7b9a4afc8eb737865d63cababe30bc61/matplotlib-3.10.8-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:12d90df9183093fcd479f4172ac26b322b1248b15729cb57f42f71f24c7e37a3", size = 8702205, upload-time = "2025-12-10T22:56:43.415Z" }, + { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" }, + { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" }, +] + [[package]] name = "maturin" version = "1.9.6" @@ -1513,6 +2260,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, ] +[[package]] +name = "pyparsing" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/c1/1d9de9aeaa1b89b0186e5fe23294ff6517fce1bc69149185577cd31016b2/pyparsing-3.3.1.tar.gz", hash = "sha256:47fad0f17ac1e2cad3de3b458570fbc9b03560aa029ed5e16ee5554da9a2251c", size = 1550512, upload-time = "2025-12-23T03:14:04.391Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/40/2614036cdd416452f5bf98ec037f38a1afb17f327cb8e6b652d4729e0af8/pyparsing-3.3.1-py3-none-any.whl", hash = "sha256:023b5e7e5520ad96642e2c6db4cb683d3970bd640cdf7115049a6e9c3682df82", size = 121793, upload-time = "2025-12-23T03:14:02.103Z" }, +] + [[package]] name = "pyproject-api" version = "1.9.1"