diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index e4fa6eb..45c5da5 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -36,16 +36,20 @@ jobs: - name: Check code formatting with ruff run: uv run ruff format --check src/ tests/ - - name: Run tests + - name: Run unit tests run: uv run pytest tests/test_correctness.py -v --tb=short + - name: Run integration tests (Redis with testcontainers) + if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' + run: uv run pytest tests/test_integration_redis.py -v --tb=short + - name: Run benchmarks if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' run: uv run python tests/benchmark.py - name: Generate coverage report if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' - run: uv run pytest tests/test_correctness.py --cov=src/advanced_caching --cov-report=xml --cov-report=term + run: uv run pytest tests/test_correctness.py tests/test_integration_redis.py --cov=src/advanced_caching --cov-report=xml --cov-report=term - name: Upload coverage to Codecov if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12' diff --git a/.gitignore b/.gitignore index 33cc7b5..abb950b 100644 --- a/.gitignore +++ b/.gitignore @@ -134,4 +134,6 @@ dmypy.json .uv-venv/ .venv/ venv/ +benchmarks.log +scalene_profile.json diff --git a/CHANGELOG.md b/CHANGELOG.md index 35f0112..929ab39 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Redis cluster support - DynamoDB backend example +## [0.1.4] - 2025-12-12 + +### Changed +- Performance improvements in hot paths: + - Reduced repeated cache initialization/lookups inside decorators. + - Reduced repeated `time.time()` calls by reusing a single timestamp per operation. + - `CacheEntry` is now a slotted dataclass to reduce per-entry memory/attribute overhead. +- SWR background refresh now uses a shared thread pool (avoids spawning a new thread per refresh). + +### Added +- Benchmarking & profiling tooling updates: + - Benchmarks can be configured via environment variables (e.g. `BENCH_WORK_MS`, `BENCH_RUNS`). + - Helper to compare JSON benchmark runs in `benchmarks.log`. + - Tight-loop profiler workload for decorator overhead. + +### Documentation +- README updated to reflect current APIs, uv usage, and storage/Redis examples. +- Added step-by-step benchmarking/profiling guide in `docs/benchmarking-and-profiling.md`. + ## [0.1.3] - 2025-12-10 ### Changed @@ -74,9 +93,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `storage.py` coverage improved to ~74%. - Ensured all tests pass under the documented `pyproject.toml` configuration. -[Unreleased]: https://github.com/namshiv2/advanced_caching/compare/v0.1.3...HEAD -[0.1.3]: https://github.com/namshiv2/advanced_caching/compare/v0.1.2...v0.1.3 -[0.1.2]: https://github.com/namshiv2/advanced_caching/compare/v0.1.1...v0.1.2 +[Unreleased]: https://github.com/agkloop/advanced_caching/compare/v0.1.4...HEAD +[0.1.4]: https://github.com/agkloop/advanced_caching/compare/v0.1.3...v0.1.4 +[0.1.3]: https://github.com/agkloop/advanced_caching/compare/v0.1.2...v0.1.3 +[0.1.2]: https://github.com/agkloop/advanced_caching/compare/v0.1.1...v0.1.2 [0.1.1]: https://github.com/namshiv2/advanced_caching/releases/tag/v0.1.1 ## [0.1.1] - 2025-12-10 diff --git a/README.md b/README.md index c70a19a..55fc4f0 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,7 @@ - [Installation](#installation) – Get started in 30 seconds - [Quick Examples](#quick-start) – Copy-paste ready code - [API Reference](#api-reference) – Full decorator & backend docs +- [Storage & Redis](#storage--redis) – Redis/Hybrid/custom storage examples - [Custom Storage](#custom-storage) – Implement your own backend - [Benchmarks](#benchmarks) – See the performance gains - [Use Cases](#use-cases) – Real-world examples @@ -37,6 +38,8 @@ pip install advanced-caching uv pip install advanced-caching # with Redis support pip install "advanced-caching[redis]" +# with Redis support (uv) +uv pip install "advanced-caching[redis]" ``` ## Quick Start @@ -90,6 +93,10 @@ user = await get_user_async(42) ## Benchmarks Full benchmarks available in `tests/benchmark.py`. +Step-by-step benchmarking + profiling guide: `docs/benchmarking-and-profiling.md`. + +Storage & Redis usage is documented below. + ## API Reference ### Key templates & custom keys @@ -159,7 +166,7 @@ Simple time-based cache with configurable TTL. TTLCache.cached( key: str | Callable[..., str], ttl: int, - cache: CacheStorage | None = None, + cache: CacheStorage | Callable[[], CacheStorage] | None = None, ) -> Callable ``` @@ -172,7 +179,7 @@ TTLCache.cached( Positional key: ```python -@TTLCache.cached("user:{},", ttl=300) +@TTLCache.cached("user:{}", ttl=300) def get_user(user_id: int): return db.fetch(user_id) @@ -206,7 +213,7 @@ SWRCache.cached( key: str | Callable[..., str], ttl: int, stale_ttl: int = 0, - cache: CacheStorage | None = None, + cache: CacheStorage | Callable[[], CacheStorage] | None = None, enable_lock: bool = True, ) -> Callable ``` @@ -262,7 +269,7 @@ BGCache.register_loader( ttl: int | None = None, run_immediately: bool = True, on_error: Callable[[Exception], None] | None = None, - cache: CacheStorage | None = None, + cache: CacheStorage | Callable[[], CacheStorage] | None = None, ) -> Callable ``` @@ -325,6 +332,97 @@ BGCache.shutdown(wait=True) ### Storage Backends +## Storage & Redis + +### Install (uv) + +```bash +uv pip install advanced-caching +uv pip install "advanced-caching[redis]" # for RedisCache / HybridCache +``` + +### How storage is chosen + +- If you don’t pass `cache=...`, each decorated function lazily creates its own `InMemCache` instance. +- You can pass either a cache instance (`cache=my_cache`) or a cache factory (`cache=lambda: my_cache`). + +### Share one storage instance + +```python +from advanced_caching import InMemCache, TTLCache + +shared = InMemCache() + +@TTLCache.cached("user:{}", ttl=60, cache=shared) +def get_user(user_id: int) -> dict: + return {"id": user_id} + +@TTLCache.cached("org:{}", ttl=60, cache=shared) +def get_org(org_id: int) -> dict: + return {"id": org_id} +``` + +### Use RedisCache (distributed) + +`RedisCache` stores values in Redis using `pickle`. + +```python +import redis +from advanced_caching import RedisCache, TTLCache + +client = redis.Redis(host="localhost", port=6379) +cache = RedisCache(client, prefix="app:") + +@TTLCache.cached("user:{}", ttl=300, cache=cache) +def get_user(user_id: int) -> dict: + return {"id": user_id} +``` + +### Use SWRCache with RedisCache (recommended) + +`SWRCache` uses `get_entry`/`set_entry` so it can store freshness metadata. + +```python +import redis +from advanced_caching import RedisCache, SWRCache + +client = redis.Redis(host="localhost", port=6379) +cache = RedisCache(client, prefix="products:") + +@SWRCache.cached("product:{}", ttl=60, stale_ttl=30, cache=cache) +def get_product(product_id: int) -> dict: + return {"id": product_id} +``` + +### Use HybridCache (L1 memory + L2 Redis) + +`HybridCache` is a two-level cache: +- **L1**: fast in-memory (`InMemCache`) +- **L2**: Redis-backed (`RedisCache`) + +Reads go to L1 first; on L1 miss it tries L2; on L2 hit it warms L1. + +```python +import redis +from advanced_caching import HybridCache, InMemCache, RedisCache, TTLCache + +client = redis.Redis(host="localhost", port=6379) + +hybrid = HybridCache( + l1_cache=InMemCache(), + l2_cache=RedisCache(client, prefix="app:"), + l1_ttl=60, +) + +@TTLCache.cached("user:{}", ttl=300, cache=hybrid) +def get_user(user_id: int) -> dict: + return {"id": user_id} +``` + +Notes: +- `ttl` on the decorator controls how long values are considered valid. +- `l1_ttl` controls how long HybridCache keeps values in memory after an L2 hit. + #### InMemCache() Thread-safe in-memory cache with TTL. @@ -386,18 +484,16 @@ if entry and entry.is_fresh(): Implement the `CacheStorage` protocol for custom backends (DynamoDB, file-based, encrypted storage, etc.). -### File-Based Cache Example +### File-based example ```python import json import time from pathlib import Path -from advanced_caching import CacheStorage, TTLCache, validate_cache_storage +from advanced_caching import CacheEntry, CacheStorage, TTLCache, validate_cache_storage class FileCache(CacheStorage): - """File-based cache storage.""" - def __init__(self, directory: str = "/tmp/cache"): self.directory = Path(directory) self.directory.mkdir(parents=True, exist_ok=True) @@ -406,26 +502,45 @@ class FileCache(CacheStorage): safe_key = key.replace("/", "_").replace(":", "_") return self.directory / f"{safe_key}.json" - def get(self, key: str): + def get_entry(self, key: str) -> CacheEntry | None: path = self._get_path(key) if not path.exists(): return None try: with open(path) as f: data = json.load(f) - if data["fresh_until"] < time.time(): - path.unlink() - return None - return data["value"] - except (json.JSONDecodeError, KeyError, OSError): + return CacheEntry( + value=data["value"], + fresh_until=float(data["fresh_until"]), + created_at=float(data["created_at"]), + ) + except Exception: + return None + + def set_entry(self, key: str, entry: CacheEntry, ttl: int | None = None) -> None: + now = time.time() + if ttl is not None: + fresh_until = now + ttl if ttl > 0 else float("inf") + entry = CacheEntry(value=entry.value, fresh_until=fresh_until, created_at=now) + with open(self._get_path(key), "w") as f: + json.dump( + {"value": entry.value, "fresh_until": entry.fresh_until, "created_at": entry.created_at}, + f, + ) + + def get(self, key: str): + entry = self.get_entry(key) + if entry is None: return None + if not entry.is_fresh(): + self.delete(key) + return None + return entry.value def set(self, key: str, value, ttl: int = 0) -> None: now = time.time() fresh_until = now + ttl if ttl > 0 else float("inf") - data = {"value": value, "fresh_until": fresh_until, "created_at": now} - with open(self._get_path(key), "w") as f: - json.dump(data, f) + self.set_entry(key, CacheEntry(value=value, fresh_until=fresh_until, created_at=now)) def delete(self, key: str) -> None: self._get_path(key).unlink(missing_ok=True) @@ -440,15 +555,12 @@ class FileCache(CacheStorage): return True -# Use it cache = FileCache("/tmp/app_cache") assert validate_cache_storage(cache) @TTLCache.cached("user:{}", ttl=300, cache=cache) def get_user(user_id: int): - return {"id": user_id, "name": f"User {user_id}"} - -user = get_user(42) # Stores in /tmp/app_cache/user_42.json + return {"id": user_id} ``` ### Best Practices @@ -463,12 +575,12 @@ user = get_user(42) # Stores in /tmp/app_cache/user_42.json ### Run Tests ```bash -pytest tests/test_correctness.py -v +uv run pytest tests/test_correctness.py -v ``` ### Run Benchmarks ```bash -python tests/benchmark.py +uv run python tests/benchmark.py ``` @@ -564,7 +676,7 @@ Contributions welcome! Please: 1. Fork the repository 2. Create a feature branch (`git checkout -b feature/my-feature`) 3. Add tests for new functionality -4. Ensure all tests pass (`pytest`) +4. Ensure all tests pass (`uv run pytest`) 5. Submit a pull request --- @@ -572,31 +684,3 @@ Contributions welcome! Please: ## License MIT License – See [LICENSE](LICENSE) for details. - ---- - -## Changelog - -### 0.1.0 (Initial Release) -- ✅ TTL Cache decorator -- ✅ SWR Cache decorator -- ✅ Background Cache with APScheduler -- ✅ InMemCache, RedisCache, HybridCache storage backends -- ✅ Full async/sync support -- ✅ Custom storage protocol -- ✅ Comprehensive test suite -- ✅ Benchmark suite - ---- - -## Roadmap - -- [ ] Distributed tracing/observability -- [ ] Metrics export (Prometheus) -- [ ] Cache warming strategies -- [ ] Serialization plugins (msgpack, protobuf) -- [ ] Redis cluster support -- [ ] DynamoDB backend example - ---- - diff --git a/docs/benchmarking-and-profiling.md b/docs/benchmarking-and-profiling.md new file mode 100644 index 0000000..fe58e2a --- /dev/null +++ b/docs/benchmarking-and-profiling.md @@ -0,0 +1,196 @@ +# Benchmarking & Profiling + +This repo includes a small, reproducible benchmark harness and a profiler-friendly workload script. + +- Benchmark runner: `tests/benchmark.py` +- Profiler workload: `tests/profile_decorators.py` +- Benchmark log (append-only JSON-lines): `benchmarks.log` +- Run comparison helper: `tests/compare_benchmarks.py` + +## 1) Benchmarking (step-by-step) + +### Step 0 — Ensure the environment is ready (uv) + +This repo uses `uv`. From the repo root: + +```bash +uv sync +``` + +### Step 1 — Run the default benchmark + +```bash +uv run python tests/benchmark.py +``` + +What you get: +- A printed table for **cold** (always miss), **hot** (always hit), and **mixed** (hits + misses). +- A new JSON entry appended to `benchmarks.log` with the config + median/mean/stdev per strategy. + +### Step 2 — Tune benchmark parameters (optional) + +`tests/benchmark.py` reads these environment variables: + +- `BENCH_SEED` (default `12345`) +- `BENCH_WORK_MS` (default `5.0`) — simulated I/O latency (sleep) +- `BENCH_WARMUP` (default `10`) +- `BENCH_RUNS` (default `300`) +- `BENCH_MIXED_KEY_SPACE` (default `100`) +- `BENCH_MIXED_RUNS` (default `500`) + +Examples: + +```bash +BENCH_RUNS=1000 BENCH_MIXED_RUNS=2000 uv run python tests/benchmark.py +``` + +```bash +# Focus on decorator overhead (no artificial sleep) +BENCH_WORK_MS=0 BENCH_RUNS=200000 BENCH_MIXED_RUNS=300000 uv run python tests/benchmark.py +``` + +### Step 3 — Compare two runs + +There are two ways to select runs: + +- Relative: `last` / `last-N` +- Explicit: integer indices (0-based; negatives allowed) + +List run indices quickly: + +```bash +uv run python - <<'PY' +import json +from pathlib import Path +runs=[] +for line in Path('benchmarks.log').read_text(encoding='utf-8', errors='replace').splitlines(): + line=line.strip() + if not line.startswith('{'): + continue + try: + obj=json.loads(line) + except Exception: + continue + if isinstance(obj,dict) and 'results' in obj: + runs.append(obj) +print('count',len(runs)) +for i,r in enumerate(runs): + print(i,r.get('ts')) +PY +``` + +Compare (example: index 2 vs index 11): + +```bash +uv run python tests/compare_benchmarks.py --a 2 --b 11 +``` + +What to look at: +- **Hot TTL/SWR** medians: these are the pure “cache-hit overhead” numbers. +- **Mixed** medians: reflect a real-ish distribution; watch for regressions here. +- Ignore small (<5–10%) deltas unless they repeat across multiple clean runs. + +### Step 4 — Make results stable (recommended practice) + +- Run each benchmark **multiple times** and compare trends, not a single result. +- Prefer a quiet machine (close CPU-heavy apps). +- Compare runs with identical config (same `BENCH_*` values). + +## 2) Profiling with Scalene (step-by-step) + +### Step 0 — Install Scalene into the uv env + +If Scalene isn’t already available in your uv environment: + +```bash +uv pip install scalene +``` + +Scalene is useful to answer: “where is the CPU time going?” + +### Step 1 — Profile the benchmark itself (realistic) + +This includes the simulated `sleep` and will mostly show “time in system / sleeping”. +It’s useful for end-to-end sanity, but not for micro-optimizing the decorators. + +```bash +uv run python -m scalene --cli --reduced-profile --outfile scalene_benchmark.txt tests/benchmark.py +``` + +### Step 2 — Profile decorator overhead (recommended) + +Run the benchmark with no artificial sleep and more iterations: + +```bash +BENCH_WORK_MS=0 BENCH_RUNS=200000 BENCH_WARMUP=2000 BENCH_MIXED_RUNS=300000 \ + uv run python \ + -m scalene --cli --reduced-profile --profile-all --cpu --outfile scalene_overhead.txt \ + tests/benchmark.py +``` + +Notes: +- `--profile-all` includes imported modules (e.g., `src/advanced_caching/*.py`). +- `--reduced-profile` keeps output small and focused. + +### Step 3 — Profile tight loops (best for line-level hotspots) + +`tests/profile_decorators.py` is designed for profilers: +- It runs tight loops calling cached functions. +- It shuts down the BG scheduler at the end to reduce background-thread noise. + +```bash +PROFILE_N=5000000 \ + uv run python \ + -m scalene --cli --reduced-profile --profile-all --cpu --outfile scalene_profile.txt \ + tests/profile_decorators.py +``` + +Optional JSON output (handy for scripting): + +```bash +PROFILE_N=5000000 \ + uv run python \ + -m scalene --cli --json --outfile scalene_profile.json \ + tests/profile_decorators.py +``` + +## 3) What to look at (a practical checklist) + +### A) Benchmark output + +- **Hot path** + - `TTLCache` hot: overhead of key generation + `get()` + return. + - `SWRCache` hot: overhead of key generation + `get_entry()` + freshness checks. + - `BGCache` hot: overhead of key lookup + `get()` + return. + +- **Mixed path** + - A high mean + low median typically indicates occasional slow misses/refreshes. + +### B) Scalene output + +Look for time concentrated in: +- `src/advanced_caching/decorators.py` + - key building (template formatting) + - repeated `get_cache()` calls (should be minimized) + - SWR “fresh vs stale” checks +- `src/advanced_caching/storage.py` + - lock contention (`with self._lock:`) + - `time.time()` calls + - dict lookups (`self._data.get(key)`) + +Signals that often matter: +- Lots of time in `threading.py` / `Condition.wait` / `Thread.run` usually means background threads are running and being sampled. Prefer the tight-loop profiler script and/or make sure background work is shut down. + +## 4) Common pitfalls + +- Comparing benchmark runs with different configs (different `BENCH_*` values). +- Profiling with `BENCH_WORK_MS=5` and expecting line-level decorator hotspots (sleep dominates). +- Treating single-run noise as a regression (always repeat). + +## 5) Typical workflow + +1. Run `tests/benchmark.py` (default) a few times. +2. If you change code, re-run and compare with `tests/compare_benchmarks.py`. +3. If you need to optimize, profile with: + - `BENCH_WORK_MS=0` + `--profile-all` for imported modules + - `tests/profile_decorators.py` for clean line-level hotspots diff --git a/docs/benchmarking.md b/docs/benchmarking.md new file mode 100644 index 0000000..d6c5f7f --- /dev/null +++ b/docs/benchmarking.md @@ -0,0 +1,260 @@ +# Benchmarking Guide + +This guide explains how to run benchmarks and compare performance between different versions of advanced-caching. + +## Running Benchmarks + +### Full Benchmark Suite + +Run all benchmarks and save results to `benchmarks.log`: + +```bash +uv run python tests/benchmark.py +``` + +The script will run multiple benchmark scenarios: +- **Cold Cache**: Initial cache misses with storage overhead +- **Hot Cache**: Repeated cache hits (best-case performance) +- **Varying Keys**: Realistic mixed workload with 100+ different keys + +Results are saved in JSON format to `benchmarks.log` for later comparison. + +## Comparing Benchmark Results + +### View Baseline vs Current Performance + +Compare the last two benchmark runs: + +```bash +uv run python tests/compare_benchmarks.py +``` + +### Compare Specific Runs + +Compare specific runs using selectors: + +```bash +# Compare second-to-last run vs latest +uv run python tests/compare_benchmarks.py --a last-1 --b last + +# Compare run index 0 vs run index 2 +uv run python tests/compare_benchmarks.py --a 0 --b 2 + +# Compare run at index -3 (third from last) vs latest +uv run python tests/compare_benchmarks.py --a -3 --b last +``` + +### Custom Log File + +If benchmarks are saved to a different file: + +```bash +uv run python tests/compare_benchmarks.py --log my_benchmarks.log +``` + +## Understanding the Output + +### Example Comparison Report + +``` +==================================================================================================== +BENCHMARK COMPARISON REPORT +==================================================================================================== + +Run A (baseline): 2025-12-12T10:30:00 + Config: {'runs': 1000, 'warmup': 100} + +Run B (current): 2025-12-12T10:45:30 + Config: {'runs': 1000, 'warmup': 100} + +---------------------------------------------------------------------------------------------------- + +📊 COLD CACHE +---------------------------------------------------------------------------------------------------- +Strategy A (ms) B (ms) Change % Status +---------------------------------------------------------------------------------------------------- +TTLCache 15.3250 14.8900 -0.4350 -2.84% ✓ FASTER (2.84%) +SWRCache 18.5100 18.2300 -0.2800 -1.51% ✓ SAME +No Cache (baseline) 13.1000 13.0900 -0.0100 -0.08% ✓ SAME + +📊 HOT CACHE +---------------------------------------------------------------------------------------------------- +Strategy A (ms) B (ms) Change % Status +---------------------------------------------------------------------------------------------------- +TTLCache 0.0012 0.0011 -0.0001 -8.33% ✓ FASTER (8.33%) +SWRCache 0.0014 0.0015 +0.0001 7.14% ✗ SLOWER (7.14%) +BGCache 0.0003 0.0003 +0.0000 0.00% ✓ SAME + +==================================================================================================== +SUMMARY +==================================================================================================== + +✓ 3 IMPROVEMENT(S): + • TTLCache in cold cache → 2.84% faster + • TTLCache in hot cache → 8.33% faster + • SWRCache in cold cache → 1.51% faster + +✗ 1 REGRESSION(S): + • SWRCache in hot cache → 7.14% slower + +---------------------------------------------------------------------------------------------------- + +🎯 VERDICT: ✓ OVERALL IMPROVEMENT (avg +5.89% faster) + +==================================================================================================== +``` + +### Key Sections Explained + +#### 1. Header +- **Run A (baseline)**: Previous benchmark results with timestamp +- **Run B (current)**: Latest benchmark results for comparison +- Shows configuration parameters used for both runs + +#### 2. Per-Section Comparison +Groups results by benchmark scenario: +- **Strategy**: Name of the caching approach (e.g., TTLCache, SWRCache) +- **A (ms)**: Median time in baseline run (milliseconds) +- **B (ms)**: Median time in current run +- **Change**: Absolute difference (B - A) in milliseconds +- **%**: Percentage change relative to baseline +- **Status**: Visual indicator with emoji: + - ✓ FASTER: Performance improved + - ✓ SAME: Within 2% threshold (no significant change) + - ✗ SLOWER: Performance regressed + +#### 3. Summary +- **IMPROVEMENTS**: Strategies that got faster + - Shows top 5 improvements + - Sorted by percentage gain (largest first) +- **REGRESSIONS**: Strategies that got slower + - Shows top 5 regressions + - Sorted by percentage loss (largest first) + +#### 4. Verdict +Overall performance assessment: +- **STABLE**: No significant changes (< 2% difference) +- **IMPROVEMENT**: More improvements than regressions + - Shows average speedup percentage +- **REGRESSION**: More regressions than improvements + - Shows average slowdown percentage + +## Interpreting Results + +### Performance Thresholds + +- **< 2%**: Considered **same** (normal measurement noise) +- **2-5%**: **Notable** change (worth investigating) +- **> 5%**: **Significant** change (code optimization or regression) + +### What to Look For + +✓ **Good signs**: +- Hot cache times remain stable (< 5% change) +- Cold cache shows improvements (refactoring benefits) +- No regressions in any benchmark + +✗ **Warning signs**: +- Hot cache performance degrades (potential code path regression) +- New dependencies add overhead to all runs +- Asymmetric changes (cache hits slow, misses fast) + +## Benchmark Scenarios + +### 1. Cold Cache +**What it tests**: Cache miss handling and data storage overhead + +Measures: +- Function execution time +- Cache miss detection +- Storage backend write performance +- Different cache backends side-by-side + +Use this to: +- Verify caching decorators don't add significant overhead +- Detect regression in cache backends +- Compare storage implementation performance + +### 2. Hot Cache +**What it tests**: Pure cache hit speed (best case) + +Measures: +- Cache lookup time +- Data deserialization +- Decorator wrapper overhead +- Hit on same key repeated 1000+ times + +Use this to: +- Ensure caching is providing speed benefit +- Detect memory/performance issues +- Compare backend performance under load + +### 3. Varying Keys +**What it tests**: Mixed realistic workload + +Measures: +- Performance with 100+ unique keys +- Mix of hits and misses +- Cache eviction/aging behavior +- Real-world usage patterns + +Use this to: +- Understand performance with realistic data +- Detect memory issues under load +- Test cache aging and refresh behavior + +## Workflow Tips + +### Before Making Code Changes + +Save baseline benchmarks: + +```bash +uv run python tests/benchmark.py +git add benchmarks.log +git commit -m "baseline: benchmark before optimization" +``` + +### After Code Changes + +Run new benchmarks: + +```bash +uv run python tests/benchmark.py +uv run python tests/compare_benchmarks.py +``` + +Review the comparison report and decide: +- ✓ Changes are good → commit +- ✗ Regression detected → revert or optimize further + +### Benchmarking in CI/CD + +GitHub Actions runs benchmarks on every push to `main`: + +```yaml +- name: Run benchmarks + run: uv run python tests/benchmark.py +``` + +Results are stored as artifacts for later comparison. + +## Troubleshooting + +### "Need at least 2 JSON runs" + +You need at least 2 benchmark results to compare. Run benchmarks twice: + +```bash +uv run python tests/benchmark.py # Creates first run +uv run python tests/benchmark.py # Creates second run +uv run python tests/compare_benchmarks.py # Now you can compare +``` + +### "Unsupported selector" + +Valid selectors are: +- `last` - most recent run +- `last-N` - N runs ago (e.g., `last-1`, `last-5`) +- `0`, `1`, `2` - absolute index from start +- `-1`, `-2` - absolute index from end diff --git a/pyproject.toml b/pyproject.toml index 23ee191..f48998c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,13 +4,13 @@ build-backend = "hatchling.build" [project] name = "advanced-caching" -version = "0.1.3" +version = "0.1.4" description = "Production-ready composable caching with TTL, SWR, and background refresh patterns for Python." readme = "README.md" requires-python = ">=3.10" license = { text = "MIT" } maintainers = [ - { name = "ahmed", email = "ahmed99kamal@gmail.com"}, + { name = "ahmed", email = "ahmed99kamal@gmail.com" }, ] keywords = ["cache", "ttl", "redis", "scheduler", "apscheduler", "python", "swr", "stale-while-revalidate"] classifiers = [ @@ -28,7 +28,7 @@ classifiers = [ "Typing :: Typed", ] dependencies = [ - "apscheduler>=3.10", + "apscheduler>=3.10" ] [project.optional-dependencies] @@ -49,6 +49,8 @@ dev = [ "pytest>=8.2", "pytest-cov>=4.0", "ruff>=0.14.8", + "scalene>=1.5.55", + "testcontainers[redis]>=4.0.0", ] [tool.pytest.ini_options] diff --git a/src/advanced_caching/decorators.py b/src/advanced_caching/decorators.py index de8065e..86ce871 100644 --- a/src/advanced_caching/decorators.py +++ b/src/advanced_caching/decorators.py @@ -10,9 +10,12 @@ from __future__ import annotations import asyncio +import atexit import logging +import os import threading import time +from concurrent.futures import ThreadPoolExecutor from typing import Callable, TypeVar, ClassVar from apscheduler.schedulers.background import BackgroundScheduler @@ -26,6 +29,30 @@ logger = logging.getLogger(__name__) +_SWR_EXECUTOR: ThreadPoolExecutor | None = None +_SWR_EXECUTOR_LOCK = threading.Lock() + + +def _get_swr_executor() -> ThreadPoolExecutor: + global _SWR_EXECUTOR + if _SWR_EXECUTOR is None: + with _SWR_EXECUTOR_LOCK: + if _SWR_EXECUTOR is None: + max_workers = min(32, (os.cpu_count() or 1) * 4) + _SWR_EXECUTOR = ThreadPoolExecutor( + max_workers=max_workers, thread_name_prefix="advanced_caching_swr" + ) + + def _shutdown() -> None: + try: + _SWR_EXECUTOR.shutdown(wait=False, cancel_futures=True) # type: ignore[union-attr] + except Exception: + pass + + atexit.register(_shutdown) + return _SWR_EXECUTOR + + # ============================================================================ # TTLCache - Simple TTL-based caching decorator # ============================================================================ @@ -57,7 +84,10 @@ def load_i18n(lang: str = "en"): @classmethod def cached( - cls, key: str | Callable[..., str], ttl: int, cache: CacheStorage | None = None + cls, + key: str | Callable[..., str], + ttl: int, + cache: CacheStorage | Callable[[], CacheStorage] | None = None, ) -> Callable[[Callable[..., T]], Callable[..., T]]: """ Cache decorator with TTL. @@ -78,45 +108,101 @@ def calculate(x): return x * 2 """ # Each decorated function gets its own cache instance - function_cache = cache if cache is not None else InMemCache() + cache_factory: Callable[[], CacheStorage] + if cache is None: + cache_factory = InMemCache + elif callable(cache): + cache_factory = cache # type: ignore[assignment] + else: + cache_instance = cache + + def cache_factory() -> CacheStorage: + return cache_instance + + function_cache: CacheStorage | None = None + cache_lock = threading.Lock() + + def get_cache() -> CacheStorage: + nonlocal function_cache + if function_cache is None: + with cache_lock: + if function_cache is None: + function_cache = cache_factory() + return function_cache + + # Precompute key builder to reduce per-call branching + if callable(key): + key_fn: Callable[..., str] = key # type: ignore[assignment] + else: + template = key + + # Fast path for common templates like "prefix:{}" (single positional placeholder). + if "{" not in template: + + def key_fn(*args, **kwargs) -> str: + return template + + elif ( + template.count("{}") == 1 + and template.count("{") == 1 + and template.count("}") == 1 + ): + prefix, suffix = template.split("{}", 1) + + def key_fn(*args, **kwargs) -> str: + if args: + return prefix + str(args[0]) + suffix + if kwargs: + if len(kwargs) == 1: + return prefix + str(next(iter(kwargs.values()))) + suffix + return template + return template + + else: + + def key_fn(*args, **kwargs) -> str: + if args: + try: + return template.format(args[0]) + except Exception: + return template + if kwargs: + try: + return template.format(**kwargs) + except Exception: + # Attempt single-kwarg positional fallback + if len(kwargs) == 1: + try: + return template.format(next(iter(kwargs.values()))) + except Exception: + return template + return template + return template def decorator(func: Callable[..., T]) -> Callable[..., T]: def wrapper(*args, **kwargs) -> T: # If ttl is 0 or negative, disable caching and call through if ttl <= 0: return func(*args, **kwargs) - # Generate cache key - if callable(key): - cache_key = key(*args, **kwargs) - else: - if "{" in key: - if args: - cache_key = key.format(args[0]) - elif kwargs: - try: - cache_key = key.format(**kwargs) - except (KeyError, IndexError): - cache_key = key - else: - cache_key = key - else: - cache_key = key + cache_key = key_fn(*args, **kwargs) + + cache_obj = get_cache() # Try cache first - cached_value = function_cache.get(cache_key) + cached_value = cache_obj.get(cache_key) if cached_value is not None: return cached_value # Cache miss - call function result = func(*args, **kwargs) - function_cache.set(cache_key, result, ttl) + cache_obj.set(cache_key, result, ttl) return result # Store cache reference for testing/debugging wrapper.__wrapped__ = func # type: ignore wrapper.__name__ = func.__name__ # type: ignore wrapper.__doc__ = func.__doc__ # type: ignore - wrapper._cache = function_cache # type: ignore + wrapper._cache = get_cache() # type: ignore return wrapper @@ -154,7 +240,7 @@ def cached( key: str | Callable[..., str], ttl: int, stale_ttl: int = 0, - cache: CacheStorage | None = None, + cache: CacheStorage | Callable[[], CacheStorage] | None = None, enable_lock: bool = True, ) -> Callable[[Callable[..., T]], Callable[..., T]]: """ @@ -178,74 +264,116 @@ def get_user(user_id: int): return db.query("SELECT * FROM users WHERE id = ?", user_id) """ # Each decorated function gets its own cache instance - function_cache = cache if cache is not None else InMemCache() + cache_factory: Callable[[], CacheStorage] + if cache is None: + cache_factory = InMemCache + elif callable(cache): + cache_factory = cache # type: ignore[assignment] + else: + cache_instance = cache + + def cache_factory() -> CacheStorage: + return cache_instance + + function_cache: CacheStorage | None = None + cache_lock = threading.Lock() + + def get_cache() -> CacheStorage: + nonlocal function_cache + if function_cache is None: + with cache_lock: + if function_cache is None: + function_cache = cache_factory() + return function_cache + + # Precompute key builder to reduce per-call branching + if callable(key): + key_fn: Callable[..., str] = key # type: ignore[assignment] + else: + template = key + + # Fast path for common templates like "prefix:{}" (single positional placeholder). + if "{" not in template: + + def key_fn(*args, **kwargs) -> str: + return template + + elif ( + template.count("{}") == 1 + and template.count("{") == 1 + and template.count("}") == 1 + ): + prefix, suffix = template.split("{}", 1) + + def key_fn(*args, **kwargs) -> str: + if args: + return prefix + str(args[0]) + suffix + if kwargs: + if len(kwargs) == 1: + return prefix + str(next(iter(kwargs.values()))) + suffix + return template + return template + + else: + + def key_fn(*args, **kwargs) -> str: + if args: + try: + return template.format(args[0]) + except Exception: + return template + if kwargs: + try: + return template.format(**kwargs) + except Exception: + if len(kwargs) == 1: + try: + return template.format(next(iter(kwargs.values()))) + except Exception: + return template + return template + return template def decorator(func: Callable[..., T]) -> Callable[..., T]: def wrapper(*args, **kwargs) -> T: # If ttl is 0 or negative, disable caching and SWR behavior if ttl <= 0: return func(*args, **kwargs) - # Generate cache key - if callable(key): - # Key function is responsible for handling args/defaults - cache_key = key(*args, **kwargs) - else: - if "{" in key: - if args: - # Use first positional arg for simple templates like "i18n:{}" - cache_key = key.format(args[0]) - elif kwargs: - # Prefer named formatting for templates like "i18n:{lang}" - try: - cache_key = key.format(**kwargs) - except (KeyError, IndexError): - # Fallback: if there is a single kwarg and template uses '{}' - if len(kwargs) == 1: - only_value = next(iter(kwargs.values())) - try: - cache_key = key.format(only_value) - except Exception: - cache_key = key - else: - cache_key = key - else: - # No args/kwargs: fall back to raw key - cache_key = key - else: - cache_key = key + cache_key = key_fn(*args, **kwargs) + + cache_obj = get_cache() + now = time.time() # Try to get from cache - entry = function_cache.get_entry(cache_key) + entry = cache_obj.get_entry(cache_key) if entry is None: # Cache miss - fetch now result = func(*args, **kwargs) - now = time.time() cache_entry = CacheEntry( value=result, fresh_until=now + ttl, created_at=now ) - function_cache.set_entry(cache_key, cache_entry) + cache_obj.set_entry(cache_key, cache_entry) return result - if entry.is_fresh(): + if now < entry.fresh_until: return entry.value - age = entry.age() + age = now - entry.created_at if age > (ttl + stale_ttl): # Too stale, fetch now result = func(*args, **kwargs) - now = time.time() cache_entry = CacheEntry( value=result, fresh_until=now + ttl, created_at=now ) - function_cache.set_entry(cache_key, cache_entry) + cache_obj.set_entry(cache_key, cache_entry) return result # Stale but within grace period - return stale and refresh in background # Try to acquire refresh lock lock_key = f"{cache_key}:refresh_lock" if enable_lock: - acquired = function_cache.set_if_not_exists( + acquired = cache_obj.set_if_not_exists( lock_key, "1", stale_ttl or 10 ) if not acquired: @@ -259,22 +387,22 @@ def refresh_job(): cache_entry = CacheEntry( value=new_value, fresh_until=now + ttl, created_at=now ) - function_cache.set_entry(cache_key, cache_entry) + cache_obj.set_entry(cache_key, cache_entry) except Exception: # Log background refresh failures but never raise logger.exception( "SWR background refresh failed for key %r", cache_key ) - thread = threading.Thread(target=refresh_job, daemon=True) - thread.start() + # Use a shared executor to avoid per-refresh thread creation overhead. + _get_swr_executor().submit(refresh_job) return entry.value wrapper.__wrapped__ = func # type: ignore wrapper.__name__ = func.__name__ # type: ignore wrapper.__doc__ = func.__doc__ # type: ignore - wrapper._cache = function_cache # type: ignore + wrapper._cache = get_cache() # type: ignore return wrapper return decorator @@ -372,7 +500,7 @@ def register_loader( ttl: int | None = None, run_immediately: bool = True, on_error: Callable[[Exception], None] | None = None, - cache: CacheStorage | None = None, + cache: CacheStorage | Callable[[], CacheStorage] | None = None, ) -> Callable[[Callable[[], T]], Callable[[], T]]: """Register a background data loader. @@ -397,11 +525,33 @@ def register_loader( ttl = 0 # Create a dedicated cache instance for this loader - loader_cache = cache if cache is not None else InMemCache() + cache_factory: Callable[[], CacheStorage] + if cache is None: + cache_factory = InMemCache + elif callable(cache): + cache_factory = cache # type: ignore[assignment] + else: + cache_instance = cache + + def cache_factory() -> CacheStorage: + return cache_instance + + loader_cache: CacheStorage | None = None + cache_init_lock = threading.Lock() + + def get_cache() -> CacheStorage: + nonlocal loader_cache + if loader_cache is None: + with cache_init_lock: + if loader_cache is None: + loader_cache = cache_factory() + return loader_cache def decorator(loader_func: Callable[[], T]) -> Callable[[], T]: # Detect if function is async is_async = asyncio.iscoroutinefunction(loader_func) + # Single-flight lock to avoid duplicate initial loads under concurrency + loader_lock = asyncio.Lock() if is_async else threading.Lock() # If no scheduling/caching is desired, just wrap the function and call through if interval_seconds <= 0 or ttl <= 0: @@ -434,6 +584,7 @@ def sync_wrapper() -> T: def refresh_job(): """Job that runs periodically to refresh the cache.""" try: + cache_obj = get_cache() if is_async: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) @@ -444,7 +595,7 @@ def refresh_job(): else: data = loader_func() - loader_cache.set(cache_key, data, ttl) + cache_obj.set(cache_key, data, ttl) except Exception as e: # User-provided error handler gets first chance if on_error: @@ -484,16 +635,22 @@ def refresh_job(): async def async_wrapper() -> T: """Get cached data or call loader if not available.""" - value = loader_cache.get(cache_key) + cache_obj = get_cache() + value = cache_obj.get(cache_key) if value is not None: return value - # If not in cache yet, call loader directly - return await loader_func() + async with loader_lock: # type: ignore[arg-type] + value = cache_obj.get(cache_key) + if value is not None: + return value + result = await loader_func() + cache_obj.set(cache_key, result, ttl) + return result async_wrapper.__wrapped__ = loader_func # type: ignore async_wrapper.__name__ = loader_func.__name__ # type: ignore async_wrapper.__doc__ = loader_func.__doc__ # type: ignore - async_wrapper._cache = loader_cache # type: ignore + async_wrapper._cache = get_cache() # type: ignore async_wrapper._cache_key = cache_key # type: ignore return async_wrapper # type: ignore @@ -501,16 +658,22 @@ async def async_wrapper() -> T: def sync_wrapper() -> T: """Get cached data or call loader if not available.""" - value = loader_cache.get(cache_key) + cache_obj = get_cache() + value = cache_obj.get(cache_key) if value is not None: return value - # If not in cache yet, call loader directly - return loader_func() + with loader_lock: # type: ignore[arg-type] + value = cache_obj.get(cache_key) + if value is not None: + return value + result = loader_func() + cache_obj.set(cache_key, result, ttl) + return result sync_wrapper.__wrapped__ = loader_func # type: ignore sync_wrapper.__name__ = loader_func.__name__ # type: ignore sync_wrapper.__doc__ = loader_func.__doc__ # type: ignore - sync_wrapper._cache = loader_cache # type: ignore + sync_wrapper._cache = get_cache() # type: ignore sync_wrapper._cache_key = cache_key # type: ignore return sync_wrapper # type: ignore diff --git a/src/advanced_caching/storage.py b/src/advanced_caching/storage.py index e34aa8e..0f968a9 100644 --- a/src/advanced_caching/storage.py +++ b/src/advanced_caching/storage.py @@ -7,6 +7,7 @@ from __future__ import annotations +import math import pickle import threading import time @@ -24,7 +25,7 @@ # ============================================================================ -@dataclass +@dataclass(slots=True) class CacheEntry: """Internal cache entry with TTL support.""" @@ -32,13 +33,17 @@ class CacheEntry: fresh_until: float # Unix timestamp created_at: float - def is_fresh(self) -> bool: + def is_fresh(self, now: float | None = None) -> bool: """Check if entry is still fresh.""" - return time.time() < self.fresh_until + if now is None: + now = time.time() + return now < self.fresh_until - def age(self) -> float: + def age(self, now: float | None = None) -> float: """Get age of entry in seconds.""" - return time.time() - self.created_at + if now is None: + now = time.time() + return now - self.created_at # ============================================================================ @@ -80,6 +85,14 @@ def exists(self, key: str) -> bool: """Check if key exists and is not expired.""" ... + def get_entry(self, key: str) -> "CacheEntry | None": + """Get raw cache entry (may be stale).""" + ... + + def set_entry(self, key: str, entry: "CacheEntry", ttl: int | None = None) -> None: + """Store raw cache entry, optionally overriding TTL.""" + ... + def set_if_not_exists(self, key: str, value: Any, ttl: int) -> bool: """ Atomic set if not exists. Returns True if set, False if already exists. @@ -96,7 +109,15 @@ def validate_cache_storage(cache: Any) -> bool: Returns: True if valid, False otherwise """ - required_methods = ["get", "set", "delete", "exists", "set_if_not_exists"] + required_methods = [ + "get", + "set", + "delete", + "exists", + "set_if_not_exists", + "get_entry", + "set_entry", + ] return all( hasattr(cache, method) and callable(getattr(cache, method)) for method in required_methods @@ -121,6 +142,12 @@ def __init__(self): self._data: dict[str, CacheEntry] = {} self._lock = threading.RLock() + def _make_entry(self, value: Any, ttl: int) -> CacheEntry: + """Create a cache entry with computed freshness window.""" + now = time.time() + fresh_until = now + ttl if ttl > 0 else float("inf") + return CacheEntry(value=value, fresh_until=fresh_until, created_at=now) + def get(self, key: str) -> Any | None: """Return value if key still fresh, otherwise drop it.""" with self._lock: @@ -128,7 +155,8 @@ def get(self, key: str) -> Any | None: if entry is None: return None - if not entry.is_fresh(): + now = time.time() + if not entry.is_fresh(now): del self._data[key] return None @@ -136,10 +164,7 @@ def get(self, key: str) -> Any | None: def set(self, key: str, value: Any, ttl: int = 0) -> None: """Store value for ttl seconds (0=forever).""" - now = time.time() - fresh_until = now + ttl if ttl > 0 else float("inf") - - entry = CacheEntry(value=value, fresh_until=fresh_until, created_at=now) + entry = self._make_entry(value, ttl) with self._lock: self._data[key] = entry @@ -154,21 +179,25 @@ def exists(self, key: str) -> bool: return self.get(key) is not None def get_entry(self, key: str) -> CacheEntry | None: - """Get raw entry (for advanced usage like SWR).""" + """Get raw entry (can be stale).""" with self._lock: return self._data.get(key) - def set_entry(self, key: str, entry: CacheEntry) -> None: - """Set raw entry (for advanced usage like SWR).""" + def set_entry(self, key: str, entry: CacheEntry, ttl: int | None = None) -> None: + """Set raw entry; optional ttl overrides entry freshness.""" + if ttl is not None: + entry = self._make_entry(entry.value, ttl) with self._lock: self._data[key] = entry def set_if_not_exists(self, key: str, value: Any, ttl: int) -> bool: """Atomic set if not exists. Returns True if set, False if exists.""" with self._lock: - if key in self._data and self._data[key].is_fresh(): + now = time.time() + if key in self._data and self._data[key].is_fresh(now): return False - self.set(key, value, ttl) + entry = self._make_entry(value, ttl) + self._data[key] = entry return True def clear(self) -> None: @@ -233,7 +262,10 @@ def get(self, key: str) -> Any | None: data = self.client.get(self._make_key(key)) if data is None: return None - return pickle.loads(data) + value = pickle.loads(data) + if isinstance(value, CacheEntry): + return value.value if value.is_fresh() else None + return value except Exception: return None @@ -242,7 +274,8 @@ def set(self, key: str, value: Any, ttl: int = 0) -> None: try: data = pickle.dumps(value) if ttl > 0: - self.client.setex(self._make_key(key), ttl, data) + expires = max(1, int(math.ceil(ttl))) + self.client.setex(self._make_key(key), expires, data) else: self.client.set(self._make_key(key), data) except Exception as e: @@ -258,17 +291,50 @@ def delete(self, key: str) -> None: def exists(self, key: str) -> bool: """Check if key exists.""" try: - return bool(self.client.exists(self._make_key(key))) + entry = self.get_entry(key) + if entry is None: + return False + return entry.is_fresh() except Exception: return False + def get_entry(self, key: str) -> CacheEntry | None: + """Get raw entry without enforcing freshness (used by SWR).""" + try: + data = self.client.get(self._make_key(key)) + if data is None: + return None + value = pickle.loads(data) + if isinstance(value, CacheEntry): + return value + # Legacy plain values: wrap to allow SWR-style access + now = time.time() + return CacheEntry(value=value, fresh_until=float("inf"), created_at=now) + except Exception: + return None + + def set_entry(self, key: str, entry: CacheEntry, ttl: int | None = None) -> None: + """Store CacheEntry, optionally with explicit TTL.""" + try: + data = pickle.dumps(entry) + expires = None + if ttl is not None and ttl > 0: + expires = max(1, int(math.ceil(ttl))) + if expires: + self.client.setex(self._make_key(key), expires, data) + else: + self.client.set(self._make_key(key), data) + except Exception as e: + raise RuntimeError(f"Redis set_entry failed: {e}") + def set_if_not_exists(self, key: str, value: Any, ttl: int) -> bool: """Atomic set if not exists.""" try: data = pickle.dumps(value) - result = self.client.set( - self._make_key(key), data, ex=ttl if ttl > 0 else None, nx=True - ) + expires = None + if ttl > 0: + expires = max(1, int(math.ceil(ttl))) + result = self.client.set(self._make_key(key), data, ex=expires, nx=True) return bool(result) except Exception: return False @@ -334,6 +400,37 @@ def set(self, key: str, value: Any, ttl: int = 0) -> None: self.l1.set(key, value, min(ttl, self.l1_ttl) if ttl > 0 else self.l1_ttl) self.l2.set(key, value, ttl) + def get_entry(self, key: str) -> CacheEntry | None: + """Get raw entry preferring L1, falling back to L2 and repopulating L1.""" + entry: CacheEntry | None = None + + if hasattr(self.l1, "get_entry"): + entry = self.l1.get_entry(key) # type: ignore[attr-defined] + if entry is not None: + return entry + + # Attempt L2 entry retrieval first + if hasattr(self.l2, "get_entry"): + entry = self.l2.get_entry(key) # type: ignore[attr-defined] + if entry is not None: + # Populate L1 with limited TTL to avoid stale accumulation + self.l1.set_entry(key, entry, ttl=self.l1_ttl) + return entry + + # Fall back to plain value fetch + value = self.l2.get(key) + if value is None: + return None + + now = time.time() + entry = CacheEntry( + value=value, + fresh_until=now + self.l1_ttl if self.l1_ttl > 0 else float("inf"), + created_at=now, + ) + self.l1.set_entry(key, entry, ttl=self.l1_ttl) + return entry + def delete(self, key: str) -> None: """Delete from both caches.""" self.l1.delete(key) @@ -349,3 +446,15 @@ def set_if_not_exists(self, key: str, value: Any, ttl: int) -> bool: if success: self.l1.set(key, value, min(ttl, self.l1_ttl) if ttl > 0 else self.l1_ttl) return success + + def set_entry(self, key: str, entry: CacheEntry, ttl: int | None = None) -> None: + """Store raw entry in both layers, respecting L1 TTL.""" + ttl = ttl if ttl is not None else max(int(entry.fresh_until - time.time()), 0) + + l1_ttl = min(ttl, self.l1_ttl) if ttl > 0 else self.l1_ttl + self.l1.set_entry(key, entry, ttl=l1_ttl) + + if hasattr(self.l2, "set_entry"): + self.l2.set_entry(key, entry, ttl=ttl) # type: ignore[attr-defined] + else: + self.l2.set(key, entry.value, ttl) diff --git a/tests/benchmark.py b/tests/benchmark.py index 8b2a10e..e12f764 100644 --- a/tests/benchmark.py +++ b/tests/benchmark.py @@ -1,545 +1,337 @@ -""" -Comprehensive benchmark comparing caching strategies. - -Compares: -- No cache (baseline) -- functools.lru_cache (built-in memoization) -- advanced_caching.TTLCache (with TTL support) -- advanced_caching.SWRCache (stale-while-revalidate) -- advanced_caching.BGCache (background scheduler loading) -- InMemCache (direct usage) - -Scenarios: -1. Cold cache (cache miss) -2. Hot cache (repeated access) -3. Mixed workload (varying keys) -4. Background loading -""" +from __future__ import annotations +import json +import os import random +import sys import time -from functools import lru_cache +from dataclasses import dataclass +from datetime import datetime +from pathlib import Path from statistics import mean, median, stdev -from typing import Callable, List +from typing import Callable, Iterable -from advanced_caching import BGCache, InMemCache, SWRCache, TTLCache +_REPO_ROOT = Path(__file__).resolve().parents[1] +_SRC_DIR = _REPO_ROOT / "src" +if _SRC_DIR.exists() and str(_SRC_DIR) not in sys.path: + sys.path.insert(0, str(_SRC_DIR)) -# ============================================================================ -# Benchmark Configuration -# ============================================================================ +from advanced_caching import BGCache, SWRCache, TTLCache -WORK_DURATION_MS = 10 # Simulate work taking 10ms +@dataclass(frozen=True) +class Config: + seed: int = 12345 + work_ms: float = 5.0 + warmup: int = 10 + runs: int = 300 + mixed_key_space: int = 100 + mixed_runs: int = 500 -def slow_function(user_id: int) -> dict: - """Simulate a slow operation (database query, API call, etc.).""" - time.sleep(WORK_DURATION_MS / 1000.0) - return { - "id": user_id, - "name": f"User{user_id}", - "email": f"user{user_id}@example.com", - "active": True, - } + +def _env_int(name: str, default: int) -> int: + raw = os.getenv(name) + if raw is None or raw == "": + return default + return int(raw) -# ============================================================================ -# Benchmark Utilities -# ============================================================================ +def _env_float(name: str, default: float) -> float: + raw = os.getenv(name) + if raw is None or raw == "": + return default + return float(raw) -class BenchmarkResult: - """Container for benchmark results.""" +CFG = Config( + seed=_env_int("BENCH_SEED", 12345), + work_ms=_env_float("BENCH_WORK_MS", 5.0), + warmup=_env_int("BENCH_WARMUP", 10), + runs=_env_int("BENCH_RUNS", 300), + mixed_key_space=_env_int("BENCH_MIXED_KEY_SPACE", 100), + mixed_runs=_env_int("BENCH_MIXED_RUNS", 500), +) +RNG = random.Random(CFG.seed) - def __init__(self, name: str, times: List[float], notes: str = ""): - self.name = name - self.times = times - self.notes = notes - @property - def median_ms(self) -> float: - return median(self.times) +@dataclass(frozen=True) +class Stats: + label: str + notes: str + runs: int + median_ms: float + mean_ms: float + stdev_ms: float - @property - def mean_ms(self) -> float: - return mean(self.times) - @property - def stdev_ms(self) -> float: - return stdev(self.times) if len(self.times) > 1 else 0.0 +def io_bound_call(user_id: int) -> dict: + """Simulate a typical small I/O call (db/API).""" + time.sleep(CFG.work_ms / 1000.0) + return {"id": user_id, "name": f"User{user_id}"} - @property - def min_ms(self) -> float: - return min(self.times) - @property - def max_ms(self) -> float: - return max(self.times) +def _timed(fn: Callable[[], object], warmup: int, runs: int) -> list[float]: + for _ in range(warmup): + fn() - def print_header(self): - print(f" {'Strategy':<30} {'Median':<12} {'Mean':<12} {'Stdev':<12} {'Notes'}") - print(f" {'-' * 80}") + times: list[float] = [] + for _ in range(runs): + t0 = time.perf_counter() + fn() + times.append((time.perf_counter() - t0) * 1000.0) + return times + + +def bench( + label: str, fn: Callable[[], object], *, notes: str, warmup: int, runs: int +) -> Stats: + times = _timed(fn, warmup=warmup, runs=runs) + return Stats( + label=label, + notes=notes, + runs=runs, + median_ms=median(times), + mean_ms=mean(times), + stdev_ms=(stdev(times) if len(times) > 1 else 0.0), + ) - def print(self, baseline_ms: float = None): - speedup_str = "" - if baseline_ms and baseline_ms > 0: - speedup = baseline_ms / self.median_ms - if speedup >= 1: - speedup_str = f" {speedup:>6.0f}x faster" - else: - speedup_str = f" {(1 / speedup):>6.1f}x slower" +def print_table(title: str, rows: list[Stats]) -> None: + print("\n" + title) + print("-" * len(title)) + print( + f"{'Strategy':<22} {'Median (ms)':>12} {'Mean (ms)':>12} {'Stdev (ms)':>12} Notes" + ) + for r in rows: print( - f" {self.name:<30} {self.median_ms:>10.4f}ms {self.mean_ms:>10.4f}ms {self.stdev_ms:>10.4f}ms{speedup_str}" + f"{r.label:<22} {r.median_ms:>12.4f} {r.mean_ms:>12.4f} {r.stdev_ms:>12.4f} {r.notes}" ) - if self.notes: - print(f" ↳ {self.notes}") - - -def run_benchmark( - func: Callable[[], None], - warmups: int = 100, - runs: int = 1000, - name: str = "Test", - notes: str = "", -) -> BenchmarkResult: - """Run a benchmark and collect timing statistics.""" - # Warmup phase - for _ in range(warmups): - func() - # Measurement phase - times = [] - for _ in range(runs): - start = time.perf_counter() - func() - elapsed = (time.perf_counter() - start) * 1000 # Convert to ms - times.append(elapsed) - - return BenchmarkResult(name, times, notes) - - -# ============================================================================ -# Benchmark 1: Cold Cache (Cache Miss Performance) -# ============================================================================ +def keys_unique(n: int) -> Iterable[int]: + for i in range(1, n + 1): + yield i -def benchmark_cold_cache(): - """Benchmark: Cold cache - cache miss overhead.""" - print("\n" + "=" * 90) - print("BENCHMARK 1: Cold Cache Performance (Cache Miss + Storage Overhead)") - print("=" * 90) - print("Measures: Function execution + cache miss + storage time\n") +def keys_mixed(n: int, key_space: int) -> list[int]: + return [RNG.randint(1, key_space) for _ in range(n)] - results = [] - # Baseline: No cache - baseline = run_benchmark( - lambda: slow_function(random.randint(1, 10000)), - warmups=5, - runs=100, - name="No Cache (baseline)", - notes="Direct function call", +def scenario_cold() -> list[Stats]: + """Always-miss: new key every call.""" + cold_keys = iter(keys_unique(CFG.runs + CFG.warmup)) + baseline = bench( + "baseline", + lambda: io_bound_call(next(cold_keys)), + notes="no cache", + warmup=CFG.warmup, + runs=CFG.runs, ) - results.append(baseline) - # TTLCache with varying keys (cold hits) - ttl_counter = {"val": 0} + ttl_counter = iter(keys_unique(CFG.runs + CFG.warmup)) @TTLCache.cached("user:{}", ttl=60) - def ttl_uncached(user_id): - return slow_function(user_id) - - ttl_result = run_benchmark( - lambda: ( - ttl_counter.__setitem__("val", ttl_counter["val"] + 1), - ttl_uncached(ttl_counter["val"]), - )[1], - warmups=5, - runs=100, - name="TTLCache", - notes="Different keys each call (always cold)", + def ttl_fn(user_id: int) -> dict: + return io_bound_call(user_id) + + ttl = bench( + "TTLCache", + lambda: ttl_fn(next(ttl_counter)), + notes="miss + store", + warmup=CFG.warmup, + runs=CFG.runs, ) - results.append(ttl_result) - - # LRU Cache with varying keys (cold hits) - lru_counter = {"val": 0} - - @lru_cache(maxsize=10000) - def lru_uncached(user_id): - return slow_function(user_id) - - lru_result = run_benchmark( - lambda: ( - lru_counter.__setitem__("val", lru_counter["val"] + 1), - lru_uncached(lru_counter["val"]), - )[1], - warmups=5, - runs=100, - name="functools.lru_cache", - notes="Different keys each call (always cold)", - ) - results.append(lru_result) - - # InMemCache direct usage - cache = InMemCache() - inmem_counter = {"val": 0} - - def inmem_uncached(): - inmem_counter["val"] += 1 - uid = inmem_counter["val"] - cached = cache.get(f"user:{uid}") - if cached is not None: - return cached - result = slow_function(uid) - cache.set(f"user:{uid}", result, ttl=60) - return result - - inmem_result = run_benchmark( - inmem_uncached, - warmups=5, - runs=100, - name="InMemCache (direct)", - notes="Manual cache management", - ) - results.append(inmem_result) - - # Print results - baseline.print_header() - for result in results: - result.print(baseline.median_ms) - print() - return results - - -# ============================================================================ -# Benchmark 2: Hot Cache (Cache Hit Performance) -# ============================================================================ + swr_counter = iter(keys_unique(CFG.runs + CFG.warmup)) + @SWRCache.cached("user:{}", ttl=60, stale_ttl=30) + def swr_fn(user_id: int) -> dict: + return io_bound_call(user_id) + + swr = bench( + "SWRCache", + lambda: swr_fn(next(swr_counter)), + notes="miss + store", + warmup=CFG.warmup, + runs=CFG.runs, + ) -def benchmark_hot_cache(): - """Benchmark: Hot cache - pure cache hit speed.""" - print("\n" + "=" * 90) - print("BENCHMARK 2: Hot Cache Performance (Repeated Access / Cache Hit)") - print("=" * 90) - print("Measures: Pure cache hit speed (no function execution)\n") + return [baseline, ttl, swr] - results = [] - # Baseline: No cache - baseline = run_benchmark( - lambda: slow_function(1), - warmups=5, - runs=100, - name="No Cache (baseline)", - notes="Direct function call", +def scenario_hot() -> list[Stats]: + """Always-hit: same key every call.""" + baseline = bench( + "baseline", + lambda: io_bound_call(1), + notes="no cache", + warmup=max(2, CFG.warmup // 2), + runs=max(50, CFG.runs), ) - results.append(baseline) - # TTLCache (same key = cache hit) @TTLCache.cached("user:{}", ttl=60) - def ttl_cached(user_id): - return slow_function(user_id) - - ttl_cached(1) # Prime cache - ttl_result = run_benchmark( - lambda: ttl_cached(1), - warmups=100, - runs=5000, - name="TTLCache", - notes="Same key repeated (always hot)", + def ttl_fn(user_id: int) -> dict: + return io_bound_call(user_id) + + ttl_fn(1) + ttl = bench( + "TTLCache", + lambda: ttl_fn(1), + notes="hit", + warmup=CFG.warmup, + runs=CFG.runs, ) - results.append(ttl_result) - # SWRCache (fresh = immediate) @SWRCache.cached("user:{}", ttl=60, stale_ttl=30) - def swr_cached(user_id): - return slow_function(user_id) - - swr_cached(1) # Prime cache - swr_result = run_benchmark( - lambda: swr_cached(1), - warmups=100, - runs=5000, - name="SWRCache", - notes="Fresh cache (immediate return)", - ) - results.append(swr_result) - - # LRU Cache - @lru_cache(maxsize=10000) - def lru_cached(user_id): - return slow_function(user_id) - - lru_cached(1) # Prime cache - lru_result = run_benchmark( - lambda: lru_cached(1), - warmups=100, - runs=5000, - name="functools.lru_cache", - notes="Pure memoization", - ) - results.append(lru_result) - - # InMemCache direct - cache = InMemCache() - result = slow_function(1) - cache.set("user:1", result, ttl=60) - - inmem_result = run_benchmark( - lambda: cache.get("user:1"), - warmups=100, - runs=5000, - name="InMemCache (direct)", - notes="Manual cache.get() calls", - ) - results.append(inmem_result) - - # BGCache (pre-loaded) - @BGCache.register_loader("user_bg", interval_seconds=60, run_immediately=True) - def bg_cached(): - return slow_function(1) - - time.sleep(0.1) # Wait for initial load - bg_result = run_benchmark( - bg_cached, - warmups=100, - runs=5000, - name="BGCache", - notes="Pre-loaded in background", + def swr_fn(user_id: int) -> dict: + return io_bound_call(user_id) + + swr_fn(1) + swr = bench( + "SWRCache", + lambda: swr_fn(1), + notes="fresh hit", + warmup=CFG.warmup, + runs=CFG.runs, ) - results.append(bg_result) - # Print results - baseline.print_header() - for result in results: - result.print(baseline.median_ms) - - BGCache.shutdown(wait=False) - print() - return results - - -# ============================================================================ -# Benchmark 3: Mixed Workload (Varying Keys) -# ============================================================================ - - -def benchmark_mixed_workload(): - """Benchmark: Mixed workload with varying keys.""" - print("\n" + "=" * 90) - print("BENCHMARK 3: Mixed Workload (Varying Keys - Realistic Scenario)") - print("=" * 90) - print("Measures: Mix of cache hits and misses with 100 distinct keys\n") + @BGCache.register_loader("bench_user", interval_seconds=60, run_immediately=True) + def bg_user() -> dict: + return io_bound_call(1) + + time.sleep(0.05) + bg = bench( + "BGCache", + bg_user, + notes="preloaded", + warmup=CFG.warmup, + runs=CFG.runs, + ) - results = [] + return [baseline, ttl, swr, bg] - # Baseline: No cache - keys = [random.randint(1, 100) for _ in range(200 + 2000)] - key_iter = iter(keys) - baseline = run_benchmark( - lambda: slow_function(next(key_iter)), - warmups=0, - runs=2000, - name="No Cache (baseline)", - notes="Direct function call", +def scenario_mixed() -> list[Stats]: + """Fixed key space: mix of hits/misses.""" + keys = keys_mixed(CFG.mixed_runs + CFG.warmup, CFG.mixed_key_space) + it = iter(keys) + baseline = bench( + "baseline", + lambda: io_bound_call(next(it)), + notes=f"no cache (key_space={CFG.mixed_key_space})", + warmup=CFG.warmup, + runs=CFG.mixed_runs, ) - results.append(baseline) - # TTLCache (mixed hits/misses) - keys = [random.randint(1, 100) for _ in range(200 + 2000)] - key_iter = iter(keys) + keys = keys_mixed(CFG.mixed_runs + CFG.warmup, CFG.mixed_key_space) + it = iter(keys) @TTLCache.cached("user:{}", ttl=60) - def ttl_mixed(user_id): - return slow_function(user_id) - - ttl_result = run_benchmark( - lambda: ttl_mixed(next(key_iter)), - warmups=0, - runs=2000, - name="TTLCache", - notes="~50% hit rate (100 keys, ~2000 accesses)", + def ttl_fn(user_id: int) -> dict: + return io_bound_call(user_id) + + ttl = bench( + "TTLCache", + lambda: ttl_fn(next(it)), + notes=f"mixed (key_space={CFG.mixed_key_space})", + warmup=CFG.warmup, + runs=CFG.mixed_runs, ) - results.append(ttl_result) - # SWRCache (mixed hits/misses) - keys = [random.randint(1, 100) for _ in range(200 + 2000)] - key_iter = iter(keys) + keys = keys_mixed(CFG.mixed_runs + CFG.warmup, CFG.mixed_key_space) + it = iter(keys) @SWRCache.cached("user:{}", ttl=60, stale_ttl=30) - def swr_mixed(user_id): - return slow_function(user_id) - - swr_result = run_benchmark( - lambda: swr_mixed(next(key_iter)), - warmups=0, - runs=2000, - name="SWRCache", - notes="~50% hit rate with stale grace", - ) - results.append(swr_result) - - # LRU Cache (mixed hits/misses) - keys = [random.randint(1, 100) for _ in range(200 + 2000)] - key_iter = iter(keys) - - @lru_cache(maxsize=10000) - def lru_mixed(user_id): - return slow_function(user_id) - - lru_result = run_benchmark( - lambda: lru_mixed(next(key_iter)), - warmups=0, - runs=2000, - name="functools.lru_cache", - notes="Pure memoization with ~50% hit rate", + def swr_fn(user_id: int) -> dict: + return io_bound_call(user_id) + + swr = bench( + "SWRCache", + lambda: swr_fn(next(it)), + notes=f"mixed (key_space={CFG.mixed_key_space})", + warmup=CFG.warmup, + runs=CFG.mixed_runs, ) - results.append(lru_result) - # Print results - baseline.print_header() - for result in results: - result.print(baseline.median_ms) - - print() - return results - - -# ============================================================================ -# Benchmark 4: Background Loading -# ============================================================================ - - -def benchmark_background_loading(): - """Benchmark: Background vs on-demand loading.""" - print("\n" + "=" * 90) - print("BENCHMARK 4: Background Loading vs On-Demand") - print("=" * 90) - print("Measures: BGCache (pre-loaded) vs TTLCache (on-demand refresh)\n") - - results = [] - - # Baseline: No cache (simulating 50ms heavy operation) - def heavy_load(): - time.sleep(0.05) # Simulate 50ms heavy work - return {"data": "heavy"} + return [baseline, ttl, swr] + + +def append_json_log( + status: str, error: str | None, sections: dict[str, list[Stats]] +) -> None: + payload = { + "ts": datetime.now().isoformat(timespec="seconds"), + "status": status, + "error": error, + "command": "python " + " ".join(sys.argv), + "python": sys.version.split()[0], + "config": { + "seed": CFG.seed, + "work_ms": CFG.work_ms, + "warmup": CFG.warmup, + "runs": CFG.runs, + "mixed_key_space": CFG.mixed_key_space, + "mixed_runs": CFG.mixed_runs, + }, + "results": { + name: [ + { + "label": s.label, + "notes": s.notes, + "runs": s.runs, + "median_ms": round(s.median_ms, 6), + "mean_ms": round(s.mean_ms, 6), + "stdev_ms": round(s.stdev_ms, 6), + } + for s in rows + ] + for name, rows in sections.items() + }, + } - baseline = run_benchmark( - heavy_load, - warmups=2, - runs=50, - name="No Cache (baseline)", - notes="Direct heavy call (50ms each)", - ) - results.append(baseline) - - # BGCache (pre-loaded, always ready) - @BGCache.register_loader("heavy_data", interval_seconds=60, run_immediately=True) - def bg_heavy(): - return heavy_load() - - time.sleep(0.1) # Wait for initial load - bg_result = run_benchmark( - bg_heavy, - warmups=100, - runs=5000, - name="BGCache", - notes="Background pre-loaded (no delay)", - ) - results.append(bg_result) - - # TTLCache on-demand (after first call, subsequent are fast) - @TTLCache.cached("heavy", ttl=60) - def ttl_heavy(): - return heavy_load() - - ttl_heavy() # Prime cache - ttl_result = run_benchmark( - ttl_heavy, - warmups=100, - runs=5000, - name="TTLCache", - notes="On-demand with hot cache", + try: + log_path = Path(__file__).resolve().parent.parent / "benchmarks.log" + log_path.parent.mkdir(parents=True, exist_ok=True) + with log_path.open("a", encoding="utf-8") as fh: + fh.write(json.dumps(payload, ensure_ascii=False) + "\n") + except Exception: + pass + + +def main() -> None: + status = "ok" + error: str | None = None + sections: dict[str, list[Stats]] = {} + + print("advanced_caching benchmark (minimal)") + print( + f"work_ms={CFG.work_ms} seed={CFG.seed} warmup={CFG.warmup} runs={CFG.runs} mixed_runs={CFG.mixed_runs}" ) - results.append(ttl_result) - - # Print results - baseline.print_header() - for result in results: - result.print(baseline.median_ms) - - BGCache.shutdown(wait=False) - print() - return results - -# ============================================================================ -# Summary & Main -# ============================================================================ - - -def print_summary(all_results): - """Print a summary of all benchmarks.""" - print("\n" + "=" * 90) - print("SUMMARY: Recommended Cache Strategy by Use Case") - print("=" * 90) - print(""" -✓ For repeated access to same key: - → Use TTLCache or BGCache (best performance, simplest code) - → functools.lru_cache is also very fast but no TTL support - -✓ For serving stale data while refreshing: - → Use SWRCache (returns stale immediately, refreshes in background) - -✓ For pre-loading expensive data: - → Use BGCache (loads in background, always ready when called) - -✓ For large distributed systems: - → Use RedisCache or HybridCache (distributed state across services) - -✓ For custom storage (DynamoDB, file-backed, etc.): - → Implement CacheStorage protocol and use with decorators - -Key findings: -• TTLCache overhead: ~0.04-0.06ms per lookup (mostly key formatting) -• lru_cache overhead: ~0.02-0.04ms per lookup (slightly faster, no TTL) -• BGCache: Near-zero overhead (~0.001ms) for pre-loaded data -• SWRCache: Same as TTLCache for fresh hits, background refresh keeps data current -""") - - -def main(): - """Run all benchmarks.""" - print("\n" + "=" * 90) - print("ADVANCED CACHING BENCHMARK SUITE") - print("=" * 90) - print(f"Work duration simulated: {WORK_DURATION_MS}ms per function call\n") - - all_results = [] - - # Run all benchmarks try: - all_results.extend(benchmark_cold_cache()) - all_results.extend(benchmark_hot_cache()) - all_results.extend(benchmark_mixed_workload()) - all_results.extend(benchmark_background_loading()) + sections["cold"] = scenario_cold() + print_table("Cold (always miss)", sections["cold"]) - # Print summary - print_summary(all_results) + sections["hot"] = scenario_hot() + print_table("Hot (always hit)", sections["hot"]) + sections["mixed"] = scenario_mixed() + print_table("Mixed (hits + misses)", sections["mixed"]) + + except KeyboardInterrupt: + status = "interrupted" + error = "KeyboardInterrupt" + raise except Exception as e: - print(f"Error during benchmarking: {e}") + status = "error" + error = f"{type(e).__name__}: {e}" raise finally: try: BGCache.shutdown(wait=False) - except: + except Exception: pass - - print("\n✅ Benchmark complete!\n") + append_json_log(status=status, error=error, sections=sections) if __name__ == "__main__": diff --git a/tests/benchmark_decorators.py b/tests/benchmark_decorators.py deleted file mode 100644 index 90a2b64..0000000 --- a/tests/benchmark_decorators.py +++ /dev/null @@ -1,491 +0,0 @@ -""" -Comprehensive benchmark comparing advanced caching decorators vs the most used caching decorator like cachedtools.cached. - -Tests various scenarios: -- Cold cache (first access) -- Hot cache (repeated access) -- Cache with different key patterns -- Concurrent access patterns -- TTL expiry behavior -""" - -import time -import random -import statistics -from typing import Callable - -from advanced_caching import BGCache -from src.advanced_caching import TTLCache - - -# ============================================================================ -# Simple Benchmark Utilities -# ============================================================================ - - -def benchmark_function(func: Callable, runs: int = 1000, warmup: int = 100) -> dict: - """ - Simple benchmark utility without external dependencies. - - Returns dict with timing statistics. - """ - # Warmup - for _ in range(warmup): - func() - - # Actual timing - times = [] - for _ in range(runs): - start = time.perf_counter() - func() - end = time.perf_counter() - times.append((end - start) * 1000) # Convert to ms - - return { - "min": min(times), - "max": max(times), - "mean": statistics.mean(times), - "median": statistics.median(times), - "stdev": statistics.stdev(times) if len(times) > 1 else 0, - "runs": runs, - } - - -def print_result(name: str, result: dict, baseline: float = None): - """Print benchmark result in a nice format.""" - median = result["median"] - mean = result["mean"] - stdev = result["stdev"] - - print( - f" {name:25} {median:8.4f}ms (mean: {mean:7.4f}ms, σ: {stdev:6.4f}ms)", end="" - ) - - if baseline and baseline > 0: - speedup = baseline / median - if speedup > 1: - print(f" [{speedup:>6,.1f}x faster]", end="") - else: - overhead = (median / baseline - 1) * 100 - print(f" [{overhead:>6.1f}% overhead]", end="") - - print() - - -# ============================================================================ -# Test Functions - Simulate various workloads -# ============================================================================ - - -def expensive_computation(x: int) -> dict: - """Simulate 5ms expensive computation.""" - time.sleep(0.005) - return {"input": x, "result": x * x, "computed_at": time.time()} - - -def database_query(user_id: int) -> dict: - """Simulate 10ms database query.""" - time.sleep(0.01) - return { - "id": user_id, - "name": f"User{user_id}", - "email": f"user{user_id}@example.com", - "active": True, - } - - -def api_call(endpoint: str) -> dict: - """Simulate 20ms external API call.""" - time.sleep(0.02) - return { - "endpoint": endpoint, - "status": 200, - "data": {"message": f"Response from {endpoint}"}, - } - - -# ============================================================================ -# Benchmark Scenarios -# ============================================================================ - - -def benchmark_cold_cache(): - """Benchmark 1: Cold cache (first access) - measures cache miss + storage.""" - print("\n" + "=" * 80) - print("BENCHMARK 1: Cold Cache Performance (First Access)") - print("=" * 80) - print("Measures: Cache miss + function execution + cache storage\n") - - # Baseline: No cache - def run_no_cache(): - expensive_computation(42) - - print("Running benchmarks...") - baseline_result = benchmark_function(run_no_cache, runs=500, warmup=10) - baseline = baseline_result["median"] - - # TTLCache - @TTLCache.cached("comp:{}", ttl=1) - def with_ttl(x): - return expensive_computation(x) - - counter = {"val": 0} - - def run_ttl(): - counter["val"] += 1 - with_ttl(counter["val"]) # Different key each time = cold cache - - ttl_result = benchmark_function(run_ttl, runs=500, warmup=10) - - # miscutil.cached - @miscutil.cached(ttl=1) - def with_miscutil(x): - return expensive_computation(x) - - counter2 = {"val": 0} - - def run_miscutil(): - counter2["val"] += 1 - with_miscutil(counter2["val"]) - - misc_result = benchmark_function(run_miscutil, runs=500, warmup=10) - - # Print results - print("\nResults:") - print_result("No Cache (baseline)", baseline_result) - print_result("TTLCache (cold)", ttl_result, baseline) - print_result("miscutil.cached (cold)", misc_result, baseline) - - print(f"\n📊 Cold Cache Overhead:") - print(f" Baseline: {baseline:.3f}ms") - print( - f" TTLCache: {ttl_result['median']:.3f}ms (+{ttl_result['median'] - baseline:.3f}ms, {(ttl_result['median'] / baseline - 1) * 100:.1f}% overhead)" - ) - print( - f" miscutil.cached: {misc_result['median']:.3f}ms (+{misc_result['median'] - baseline:.3f}ms, {(misc_result['median'] / baseline - 1) * 100:.1f}% overhead)" - ) - - -def benchmark_hot_cache(): - """Benchmark 2: Hot cache (repeated access) - measures pure cache hit speed.""" - print("\n" + "=" * 80) - print("BENCHMARK 2: Hot Cache Performance (Repeated Access)") - print("=" * 80) - print("Measures: Pure cache hit speed (best case scenario)\n") - - # Baseline for reference - def run_baseline(): - database_query(123) - - print("Running benchmarks...") - baseline_result = benchmark_function(run_baseline, runs=100, warmup=5) - baseline = baseline_result["median"] - - # TTLCache - @TTLCache.cached("user:{}", ttl=1) - def get_user_ttl(user_id): - return database_query(user_id) - - get_user_ttl(123) # Prime cache - - def run_ttl(): - get_user_ttl(123) # Same key = cache hit - - ttl_result = benchmark_function(run_ttl, runs=50000, warmup=1000) - - # SWRCache - @SWRCache.cached("user:{}", ttl=1, stale_ttl=30) - def get_user_swr(user_id): - return database_query(user_id) - - get_user_swr(123) # Prime cache - - def run_swr(): - get_user_swr(123) - - swr_result = benchmark_function(run_swr, runs=50000, warmup=1000) - - # miscutil.cached - @miscutil.cached(ttl=1) - def get_user_misc(): - return database_query(123) - - get_user_misc() # Prime cache - - def run_misc(): - get_user_misc() - - misc_result = benchmark_function(run_misc, runs=50000, warmup=1000) - - # Print results - print("\nResults:") - print_result("No Cache (reference)", baseline_result) - print_result("TTLCache (hot)", ttl_result, baseline) - print_result("SWRCache (hot)", swr_result, baseline) - print_result("miscutil.cached (hot)", misc_result, baseline) - - print(f"\n🚀 Hot Cache Speedup:") - print( - f" TTLCache: {ttl_result['median']:.4f}ms ({baseline / ttl_result['median']:>8,.0f}x faster)" - ) - print( - f" SWRCache: {swr_result['median']:.4f}ms ({baseline / swr_result['median']:>8,.0f}x faster)" - ) - print( - f" miscutil.cached: {misc_result['median']:.4f}ms ({baseline / misc_result['median']:>8,.0f}x faster)" - ) - - # Find winner - times = [ - ("TTLCache", ttl_result["median"]), - ("SWRCache", swr_result["median"]), - ("miscutil.cached", misc_result["median"]), - ] - times.sort(key=lambda x: x[1]) - print(f"\n🏆 Fastest: {times[0][0]} ({times[0][1]:.4f}ms)") - - -def benchmark_varying_keys(): - """Benchmark 3: Varying keys - realistic workload with mix of hits/misses.""" - print("\n" + "=" * 80) - print("BENCHMARK 3: Varying Keys (Realistic Workload)") - print("=" * 80) - print("Measures: Mixed cache hits/misses with 100 different keys\n") - - # Baseline - def run_baseline(): - api_call(f"endpoint_{random.randint(1, 100)}") - - print("Running benchmarks...") - baseline_result = benchmark_function(run_baseline, runs=500, warmup=10) - baseline = baseline_result["median"] - - # TTLCache - @TTLCache.cached("api:{}", ttl=1) - def call_api_ttl(endpoint): - return api_call(endpoint) - - # Prime with some keys - for i in range(1, 51): - call_api_ttl(f"endpoint_{i}") - - def run_ttl(): - call_api_ttl(f"endpoint_{random.randint(1, 100)}") # 50% hit rate - - ttl_result = benchmark_function(run_ttl, runs=5000, warmup=100) - - # miscutil.cached - @miscutil.cached(ttl=1) - def call_api_misc(endpoint): - return api_call(endpoint) - - # Prime with some keys - for i in range(1, 51): - call_api_misc(f"endpoint_{i}") - - def run_misc(): - call_api_misc(f"endpoint_{random.randint(1, 100)}") - - misc_result = benchmark_function(run_misc, runs=5000, warmup=100) - - # Print results - print("\nResults:") - print_result("No Cache", baseline_result) - print_result("TTLCache (50% hit)", ttl_result, baseline) - print_result("miscutil.cached (50% hit)", misc_result, baseline) - - print(f"\n📈 Varying Keys Performance:") - print(f" Baseline: {baseline:.2f}ms") - print( - f" TTLCache: {ttl_result['median']:.2f}ms ({baseline / ttl_result['median']:.1f}x faster)" - ) - print( - f" miscutil.cached: {misc_result['median']:.2f}ms ({baseline / misc_result['median']:.1f}x faster)" - ) - - -def benchmark_background_loading(): - """Benchmark 4: Background loading vs on-demand caching.""" - print("\n" + "=" * 80) - print("BENCHMARK 4: Background Loading vs On-Demand") - print("=" * 80) - print("Measures: BGCache (pre-loaded) vs TTLCache (on-demand)\n") - - def heavy_load(): - """Simulate 50ms heavy operation.""" - time.sleep(0.05) - return {"data": "heavy_result", "timestamp": time.time()} - - # Baseline - def run_baseline(): - heavy_load() - - print("Running benchmarks...") - baseline_result = benchmark_function(run_baseline, runs=100, warmup=5) - baseline = baseline_result["median"] - - # BGCache (pre-loaded, always ready) - @BGCache.register_loader("heavy_data", interval_seconds=10, run_immediately=True) - def load_heavy_bg(): - return heavy_load() - - time.sleep(0.1) # Wait for initial load - - def run_bg(): - load_heavy_bg() # Always from cache - - bg_result = benchmark_function(run_bg, runs=50000, warmup=1000) - - # TTLCache (on-demand) - @TTLCache.cached("heavy", ttl=10) - def load_heavy_ttl(): - return heavy_load() - - load_heavy_ttl() # Prime - - def run_ttl(): - load_heavy_ttl() - - ttl_result = benchmark_function(run_ttl, runs=50000, warmup=1000) - - # miscutil.cached - @miscutil.cached(ttl=10) - def load_heavy_misc(): - return heavy_load() - - load_heavy_misc() # Prime - - def run_misc(): - load_heavy_misc() - - misc_result = benchmark_function(run_misc, runs=50000, warmup=1000) - - # Print results - print("\nResults:") - print_result("No Cache", baseline_result) - print_result("BGCache", bg_result, baseline) - print_result("TTLCache", ttl_result, baseline) - print_result("miscutil.cached", misc_result, baseline) - - print(f"\n⚡ Background vs On-Demand:") - print(f" Baseline: {baseline:.2f}ms") - print( - f" BGCache: {bg_result['median']:.4f}ms ({baseline / bg_result['median']:>8,.0f}x faster) 🏆 Pre-loaded!" - ) - print( - f" TTLCache: {ttl_result['median']:.4f}ms ({baseline / ttl_result['median']:>8,.0f}x faster)" - ) - print( - f" miscutil.cached: {misc_result['median']:.4f}ms ({baseline / misc_result['median']:>8,.0f}x faster)" - ) - - BGCache.shutdown() - - -def benchmark_memory_usage(): - """Benchmark 5: Memory efficiency comparison.""" - print("\n" + "=" * 80) - print("BENCHMARK 5: Memory Efficiency") - print("=" * 80) - print("Measures: Cache with custom backend vs default\n") - - # Custom lightweight cache - custom_cache = FastCache() - - @TTLCache.cached("item:{}", ttl=1, cache=custom_cache) - def get_item_custom(item_id): - time.sleep(0.001) - return {"id": item_id} - - # Prime with 1000 items - print("Priming caches with 1000 items...") - for i in range(1000): - get_item_custom(i) - - def run_custom(): - get_item_custom(random.randint(0, 999)) - - custom_result = benchmark_function(run_custom, runs=10000, warmup=100) - - # Default TTLCache - @TTLCache.cached("item:{}", ttl=1) - def get_item_default(item_id): - time.sleep(0.001) - return {"id": item_id} - - for i in range(1000): - get_item_default(i) - - def run_default(): - get_item_default(random.randint(0, 999)) - - default_result = benchmark_function(run_default, runs=10000, warmup=100) - - # miscutil.cached - @miscutil.cached(ttl=1) - def get_item_misc(item_id): - time.sleep(0.001) - return {"id": item_id} - - for i in range(1000): - get_item_misc(i) - - def run_misc(): - get_item_misc(random.randint(0, 999)) - - misc_result = benchmark_function(run_misc, runs=10000, warmup=100) - - # Print results - print("\nResults:") - print_result("TTLCache + FastCache", custom_result) - print_result("TTLCache (default)", default_result) - print_result("miscutil.cached", misc_result) - - print(f"\n💾 Memory Efficiency (1000 items):") - print(f" TTLCache + FastCache: {custom_result['median']:.4f}ms") - print(f" TTLCache (default): {default_result['median']:.4f}ms") - print(f" miscutil.cached: {misc_result['median']:.4f}ms") - - -# ============================================================================ -# Main -# ============================================================================ - - -def main(): - """Run all benchmarks.""" - print("\n" + "█" * 80) - print("█" + " " * 78 + "█") - print("█" + " COMPREHENSIVE DECORATOR BENCHMARK SUITE".center(78) + "█") - print("█" + " TTLCache vs SWRCache vs BGCache vs miscutil.cached".center(78) + "█") - print("█" + " " * 78 + "█") - print("█" * 80) - - # Run all benchmarks - benchmark_cold_cache() - benchmark_hot_cache() - benchmark_varying_keys() - benchmark_background_loading() - benchmark_memory_usage() - - # Final summary - print("\n" + "█" * 80) - print("█" + " " * 78 + "█") - print("█" + " BENCHMARK SUMMARY".center(78) + "█") - print("█" + " " * 78 + "█") - print("█" * 80) - - print("\n" + "█" * 80) - print("█" + " " * 78 + "█") - print("█" + " ✅ BENCHMARK COMPLETE".center(78) + "█") - print("█" + " " * 78 + "█") - print("█" * 80 + "\n") - - -def test_benchmark(): - """Pytest wrapper.""" - main() - - -if __name__ == "__main__": - main() diff --git a/tests/compare_benchmarks.py b/tests/compare_benchmarks.py new file mode 100644 index 0000000..2d41df3 --- /dev/null +++ b/tests/compare_benchmarks.py @@ -0,0 +1,248 @@ +from __future__ import annotations + +import argparse +import json +from pathlib import Path +from typing import Any + + +def _load_json_runs(log_path: Path) -> list[dict[str, Any]]: + runs: list[dict[str, Any]] = [] + for line in log_path.read_text(encoding="utf-8", errors="replace").splitlines(): + line = line.strip() + if not line.startswith("{"): + continue + try: + obj = json.loads(line) + except Exception: + continue + if ( + isinstance(obj, dict) + and "results" in obj + and isinstance(obj["results"], dict) + ): + runs.append(obj) + return runs + + +def _parse_selector(spec: str) -> int: + """Return a list index from a selector. + + Supported: + - "last" => -1 + - "last-N" => -(N+1) + - integer (0-based): "0", "2" ... + - negative integer: "-1", "-2" ... + """ + if spec == "last": + return -1 + if spec.startswith("last-"): + n = int(spec.split("-", 1)[1]) + return -(n + 1) + try: + return int(spec) + except ValueError as e: + raise ValueError( + f"Unsupported selector: {spec!r}. Use 'last', 'last-N', or an integer index." + ) from e + + +def _median_map(run: dict[str, Any]) -> dict[tuple[str, str], float]: + out: dict[tuple[str, str], float] = {} + results = run.get("results", {}) + for section, rows in results.items(): + if not isinstance(rows, list): + continue + for row in rows: + if not isinstance(row, dict): + continue + label = str(row.get("label", "")) + med = row.get("median_ms") + if not label or not isinstance(med, (int, float)): + continue + out[(str(section), label)] = float(med) + return out + + +def _print_compare(a: dict[str, Any], b: dict[str, Any]) -> None: + a_ts = a.get("ts", "?") + b_ts = b.get("ts", "?") + a_cfg = a.get("config", {}) + b_cfg = b.get("config", {}) + + # Header + print("\n" + "=" * 100) + print("BENCHMARK COMPARISON REPORT") + print("=" * 100 + "\n") + + print(f"Run A (baseline): {a_ts}") + print(f" Config: {a_cfg}") + print() + print(f"Run B (current): {b_ts}") + print(f" Config: {b_cfg}") + print("\n" + "-" * 100 + "\n") + + a_m = _median_map(a) + b_m = _median_map(b) + keys = sorted(set(a_m) | set(b_m)) + + # Group by section + sections = {} + for section, label in keys: + if section not in sections: + sections[section] = [] + sections[section].append(label) + + # Calculate summary statistics + improvements = [] + regressions = [] + + for section in sorted(sections.keys()): + print(f"\n📊 {section.upper()}") + print("-" * 100) + print( + f"{'Strategy':<25} {'A (ms)':>12} {'B (ms)':>12} {'Change':>12} {'%':>8} {'Status':>12}" + ) + print("-" * 100) + + for label in sorted(sections[section]): + a_med = a_m.get((section, label)) + b_med = b_m.get((section, label)) + if a_med is None or b_med is None: + continue + + delta = b_med - a_med + pct = (delta / a_med * 100.0) if a_med > 0 else 0.0 + + # Determine status + if abs(pct) < 2: + status = "✓ SAME" + elif pct < 0: + status = f"✓ FASTER ({abs(pct):.1f}%)" + improvements.append((section, label, abs(pct))) + else: + status = f"✗ SLOWER ({pct:.1f}%)" + regressions.append((section, label, pct)) + + delta_str = f"{delta:+.4f}" + print( + f"{label:<25} {a_med:>12.4f} {b_med:>12.4f} {delta_str:>12} {pct:>7.1f}% {status:>12}" + ) + + # Summary section + print("\n" + "=" * 100) + print("SUMMARY") + print("=" * 100) + + if improvements: + print(f"\n✓ {len(improvements)} IMPROVEMENT(S):") + for section, label, pct in sorted(improvements, key=lambda x: -x[2])[:5]: + print(f" • {label:<30} in {section:<15} → {pct:>6.2f}% faster") + else: + print("\n✓ No improvements detected") + + if regressions: + print(f"\n✗ {len(regressions)} REGRESSION(S):") + for section, label, pct in sorted(regressions, key=lambda x: -x[2])[:5]: + print(f" • {label:<30} in {section:<15} → {pct:>6.2f}% slower") + else: + print("\n✓ No regressions detected") + + # Overall verdict + print("\n" + "-" * 100) + total_changes = len(improvements) + len(regressions) + if total_changes == 0: + verdict = "✓ PERFORMANCE STABLE (no significant changes)" + elif len(improvements) > len(regressions): + avg_improvement = sum(x[2] for x in improvements) / len(improvements) + verdict = f"✓ OVERALL IMPROVEMENT (avg +{avg_improvement:.2f}% faster)" + else: + avg_regression = sum(x[2] for x in regressions) / len(regressions) + verdict = f"✗ OVERALL REGRESSION (avg +{avg_regression:.2f}% slower)" + + # Detailed analysis by section + print("\n" + "=" * 100) + print("DETAILED ANALYSIS BY SCENARIO") + print("=" * 100) + + for section in sorted(sections.keys()): + section_improvements = [x for x in improvements if x[0] == section] + section_regressions = [x for x in regressions if x[0] == section] + + if not section_improvements and not section_regressions: + continue + + print(f"\n🔍 {section.upper()}") + + if section_improvements: + avg_improvement = sum(x[2] for x in section_improvements) / len( + section_improvements + ) + print(f" ✓ Average improvement: {avg_improvement:.2f}%") + + if section_regressions: + avg_regression = sum(x[2] for x in section_regressions) / len( + section_regressions + ) + print(f" ✗ Average regression: {avg_regression:.2f}%") + + if not section_improvements and section_regressions: + print(f" ⚠️ Watch: Only regressions detected in this scenario") + + # Recommendations + print("\n" + "=" * 100) + print("RECOMMENDATIONS") + print("=" * 100) + + if total_changes == 0: + print("\n✓ No action needed. Performance is stable.") + recommendation = "continue with current changes" + elif len(regressions) > 0 and sum(x[2] for x in regressions) / len(regressions) > 5: + print("\n⚠️ SIGNIFICANT REGRESSIONS DETECTED") + print(" Consider:") + print(" • Profiling the affected code paths") + print(" • Reviewing recent changes for optimization issues") + print(" • Checking for new dependencies or imports") + recommendation = "investigate and optimize" + elif len(improvements) > 0: + print("\n✓ Performance improvements detected!") + print(" Recommendation: Merge and deploy") + recommendation = "good to merge" + else: + print("\n✓ No significant regressions detected") + recommendation = "safe to merge" + + print("\n" + "=" * 100) + print(f"\n📋 STATUS: {recommendation.upper()}\n") + print("=" * 100 + "\n") + + +def main() -> None: + p = argparse.ArgumentParser( + description="Compare two JSON benchmark runs in benchmarks.log" + ) + p.add_argument("--log", default="benchmarks.log", help="Path to benchmarks.log") + p.add_argument( + "--a", + default="last-1", + help="Run selector: last, last-N, or integer index (0-based; negatives allowed)", + ) + p.add_argument( + "--b", + default="last", + help="Run selector: last, last-N, or integer index (0-based; negatives allowed)", + ) + args = p.parse_args() + + log_path = Path(args.log) + runs = _load_json_runs(log_path) + if len(runs) < 2: + raise SystemExit(f"Need at least 2 JSON runs in {log_path}") + + a = runs[_parse_selector(args.a)] + b = runs[_parse_selector(args.b)] + _print_compare(a, b) + + +if __name__ == "__main__": + main() diff --git a/tests/profile_decorators.py b/tests/profile_decorators.py new file mode 100644 index 0000000..86340e7 --- /dev/null +++ b/tests/profile_decorators.py @@ -0,0 +1,72 @@ +from __future__ import annotations + +import os +import sys +import time +from pathlib import Path + +_REPO_ROOT = Path(__file__).resolve().parents[1] +_SRC_DIR = _REPO_ROOT / "src" +if _SRC_DIR.exists() and str(_SRC_DIR) not in sys.path: + sys.path.insert(0, str(_SRC_DIR)) + +from advanced_caching import BGCache, SWRCache, TTLCache + + +def _env_int(name: str, default: int) -> int: + raw = os.getenv(name) + if raw is None or raw == "": + return default + return int(raw) + + +def main() -> None: + # This script is designed for profilers (e.g., Scalene): + # - No per-iteration timing + # - Minimal I/O / printing + n = _env_int("PROFILE_N", 2_000_000) + + def cheap_work(x: int) -> int: + return x + 1 + + @TTLCache.cached("ttl:{}", ttl=60) + def ttl_fn(x: int) -> int: + return cheap_work(x) + + @SWRCache.cached("swr:{}", ttl=60, stale_ttl=30) + def swr_fn(x: int) -> int: + return cheap_work(x) + + @BGCache.register_loader("bg", interval_seconds=60) + def bg_loader() -> int: + return cheap_work(1) + + # Warm caches. + ttl_fn(1) + swr_fn(1) + bg_loader() + + # Hot-path loops. + for _ in range(n): + ttl_fn(1) + for _ in range(n): + swr_fn(1) + for _ in range(n): + bg_loader() + + # Miss-path loops (smaller: avoid excessive memory growth). + miss_n = max(10_000, n // 100) + for i in range(miss_n): + ttl_fn(i) + for i in range(miss_n): + swr_fn(i) + + # Give any background work a moment to settle. + time.sleep(0.05) + + # Stop background scheduler thread to avoid profiler noise. + BGCache.shutdown(wait=False) + + +if __name__ == "__main__": + main() diff --git a/tests/test.py b/tests/test.py new file mode 100644 index 0000000..c070f6f --- /dev/null +++ b/tests/test.py @@ -0,0 +1,32 @@ +from advanced_caching import BGCache +import inspect + + +is_not_testing = True + + +def get_loader_fn(): + caller_stack_trace = inspect.stack() + stack_fn_names_list = [frame.function for frame in caller_stack_trace] + + print("get_loader_fn called, setting up loader...") + + @BGCache.register_loader( + "all_filter_keys_catalog_loader", + interval_seconds=60 * 60 * 1 * is_not_testing, + run_immediately=True, + ) + def get_all_filter_keys_catalog(): + print("Loading all filter keys catalog...", stack_fn_names_list) + return "D" + + return get_all_filter_keys_catalog + + +def call_fn(): + return get_loader_fn() + + +if __name__ == "__main__": + for i in range(10): + print(i, call_fn()()) diff --git a/tests/test_correctness.py b/tests/test_correctness.py index 4dd7143..de930d3 100644 --- a/tests/test_correctness.py +++ b/tests/test_correctness.py @@ -3,6 +3,7 @@ Tests TTLCache, SWRCache, and BGCache functionality. """ +import concurrent.futures import pytest import time @@ -361,6 +362,57 @@ def load_c(): assert load_b()["name"] == "b" assert load_c()["name"] == "c" + def test_concurrent_access_is_thread_safe(self): + """Concurrent callers should read cached data without duplicate loads.""" + call_count = {"count": 0} + + @BGCache.register_loader( + "concurrent_loader", interval_seconds=60, run_immediately=True + ) + def load_data(): + # Simulate work to surface races if present + time.sleep(0.05) + call_count["count"] += 1 + return {"value": call_count["count"]} + + # Wait for initial load triggered by run_immediately + time.sleep(0.1) + + def call_loader(_: int): + return load_data() + + with concurrent.futures.ThreadPoolExecutor(max_workers=12) as executor: + results = list(executor.map(call_loader, range(24))) + + # All callers should see the cached value produced by the first load + assert all(r == {"value": 1} for r in results) + assert call_count["count"] == 1 + + def test_concurrent_initial_load_when_no_immediate(self): + """When run_immediately=False, first concurrent callers should single-flight load.""" + call_count = {"count": 0} + + @BGCache.register_loader( + "concurrent_no_immediate", + interval_seconds=30, + run_immediately=False, + ttl=30, + ) + def load_data(): + time.sleep(0.05) + call_count["count"] += 1 + return {"value": call_count["count"]} + + def call_loader(_: int): + return load_data() + + with concurrent.futures.ThreadPoolExecutor(max_workers=12) as executor: + results = list(executor.map(call_loader, range(24))) + + # Only one load should have happened, all callers get cached value + assert all(r == {"value": 1} for r in results) + assert call_count["count"] == 1 + class TestCachePerformance: """Performance and speed tests.""" diff --git a/tests/test_integration_redis.py b/tests/test_integration_redis.py new file mode 100644 index 0000000..0307a32 --- /dev/null +++ b/tests/test_integration_redis.py @@ -0,0 +1,395 @@ +""" +Integration tests for Redis-backed caching. +Uses testcontainers-python to spin up a real Redis instance for testing. +""" + +import pytest +import time + +try: + import redis + from testcontainers.redis import RedisContainer + + HAS_REDIS = True +except ImportError: + HAS_REDIS = False + +from advanced_caching import ( + CacheEntry, + TTLCache, + SWRCache, + BGCache, + RedisCache, + HybridCache, + InMemCache, +) + + +@pytest.fixture(scope="module") +def redis_container(): + """Fixture to start a Redis container for the entire test module.""" + if not HAS_REDIS: + pytest.skip("testcontainers[redis] not installed") + + container = RedisContainer(image="redis:7-alpine") + container.start() + yield container + container.stop() + + +@pytest.fixture +def redis_client(redis_container): + """Fixture to create a Redis client connected to the container.""" + host = redis_container.get_container_host_ip() + port = redis_container.get_exposed_port(6379) + client = redis.Redis(host=host, port=int(port)) + client.ping() + client.flushdb() + yield client + client.flushdb() + + +class TestRedisCache: + """Test RedisCache backend directly.""" + + def test_redis_cache_basic_set_get(self, redis_client): + """Test basic set and get operations on RedisCache.""" + cache = RedisCache(redis_client, prefix="test:") + + cache.set("key1", {"data": "value1"}, ttl=60) + result = cache.get("key1") + assert result == {"data": "value1"} + + def test_redis_cache_ttl_expiration(self, redis_client): + """Test that Redis cache respects TTL.""" + cache = RedisCache(redis_client, prefix="test:") + + cache.set("expire_me", "value", ttl=1) + assert cache.get("expire_me") == "value" + + time.sleep(1.1) + assert cache.get("expire_me") is None + + def test_redis_cache_delete(self, redis_client): + """Test delete operation on RedisCache.""" + cache = RedisCache(redis_client, prefix="test:") + + cache.set("key", "value", ttl=60) + assert cache.exists("key") + + cache.delete("key") + assert not cache.exists("key") + + def test_redis_cache_entry_roundtrip(self, redis_client): + """Test get_entry/set_entry interoperability for RedisCache.""" + cache = RedisCache(redis_client, prefix="test:") + + entry = CacheEntry( + value={"payload": True}, + fresh_until=time.time() + 5, + created_at=time.time(), + ) + + cache.set_entry("entry_key", entry) + + loaded_entry = cache.get_entry("entry_key") + assert isinstance(loaded_entry, CacheEntry) + assert loaded_entry.value == {"payload": True} + + # Regular get should unwrap value + assert cache.get("entry_key") == {"payload": True} + + def test_redis_cache_set_if_not_exists(self, redis_client): + """Test atomic set_if_not_exists operation.""" + cache = RedisCache(redis_client, prefix="test:") + + result1 = cache.set_if_not_exists("atomic_key", "value1", ttl=60) + assert result1 is True + + result2 = cache.set_if_not_exists("atomic_key", "value2", ttl=60) + assert result2 is False + + assert cache.get("atomic_key") == "value1" + + def test_redis_cache_multiple_types(self, redis_client): + """Test caching different data types in Redis.""" + cache = RedisCache(redis_client, prefix="test:") + + cache.set("str", "hello", ttl=60) + assert cache.get("str") == "hello" + + data_dict = {"name": "test", "count": 42} + cache.set("dict", data_dict, ttl=60) + assert cache.get("dict") == data_dict + + data_list = [1, 2, 3, "four"] + cache.set("list", data_list, ttl=60) + assert cache.get("list") == data_list + + +class TestTTLCacheWithRedis: + """Test TTLCache decorator with Redis backend.""" + + def test_ttlcache_redis_basic(self, redis_client): + """Test TTLCache with Redis backend.""" + calls = {"n": 0} + cache = RedisCache(redis_client, prefix="ttl:") + + @TTLCache.cached("user:{}", ttl=60, cache=cache) + def get_user(user_id: int): + calls["n"] += 1 + return {"id": user_id, "name": f"User{user_id}"} + + result1 = get_user(1) + assert result1 == {"id": 1, "name": "User1"} + assert calls["n"] == 1 + + result2 = get_user(1) + assert result2 == {"id": 1, "name": "User1"} + assert calls["n"] == 1 + + result3 = get_user(2) + assert result3 == {"id": 2, "name": "User2"} + assert calls["n"] == 2 + + def test_ttlcache_redis_expiration(self, redis_client): + """Test TTLCache with Redis respects TTL.""" + calls = {"n": 0} + cache = RedisCache(redis_client, prefix="ttl:") + + @TTLCache.cached("data:{}", ttl=1, cache=cache) + def get_data(key: str): + calls["n"] += 1 + return f"data_{key}" + + result1 = get_data("test") + assert result1 == "data_test" + assert calls["n"] == 1 + + result2 = get_data("test") + assert calls["n"] == 1 + + time.sleep(1.1) + + result3 = get_data("test") + assert result3 == "data_test" + assert calls["n"] == 2 + + def test_ttlcache_redis_named_template(self, redis_client): + """Test TTLCache with Redis using named key template.""" + calls = {"n": 0} + cache = RedisCache(redis_client, prefix="ttl:") + + @TTLCache.cached("product:{product_id}", ttl=60, cache=cache) + def get_product(*, product_id: int): + calls["n"] += 1 + return {"id": product_id, "name": f"Product{product_id}"} + + result1 = get_product(product_id=100) + assert result1 == {"id": 100, "name": "Product100"} + assert calls["n"] == 1 + + result2 = get_product(product_id=100) + assert calls["n"] == 1 + + +class TestSWRCacheWithRedis: + """Test SWRCache with Redis backend.""" + + def test_swrcache_redis_basic(self, redis_client): + """Test SWRCache with Redis backend.""" + calls = {"n": 0} + cache = RedisCache(redis_client, prefix="swr:") + + @SWRCache.cached("product:{}", ttl=1, stale_ttl=1, cache=cache) + def get_product(product_id: int): + calls["n"] += 1 + return {"id": product_id, "count": calls["n"]} + + result1 = get_product(1) + assert result1["count"] == 1 + assert calls["n"] == 1 + + result2 = get_product(1) + assert result2["count"] == 1 + assert calls["n"] == 1 + + def test_swrcache_redis_stale_serve(self, redis_client): + """Test SWRCache serves stale data while refreshing.""" + calls = {"n": 0} + cache = RedisCache(redis_client, prefix="swr:") + + @SWRCache.cached("data:{}", ttl=0.3, stale_ttl=0.5, cache=cache) + def get_data(key: str): + calls["n"] += 1 + return {"key": key, "count": calls["n"]} + + result1 = get_data("test") + assert result1["count"] == 1 + + time.sleep(0.4) + + result2 = get_data("test") + assert result2["count"] == 1 + + # Give background refresh enough time (Redis + thread scheduling) + time.sleep(0.35) + + result3 = get_data("test") + assert result3["count"] >= 2 + + +class TestBGCacheWithRedis: + """Test BGCache with Redis backend.""" + + def test_bgcache_redis_sync_loader(self, redis_client): + """Test BGCache with sync loader and Redis backend.""" + calls = {"n": 0} + cache = RedisCache(redis_client, prefix="bg:") + + @BGCache.register_loader( + key="inventory", + interval_seconds=10, + run_immediately=True, + cache=cache, + ) + def load_inventory(): + calls["n"] += 1 + return {"items": [f"item_{i}" for i in range(3)]} + + time.sleep(0.1) + + result = load_inventory() + assert result == {"items": ["item_0", "item_1", "item_2"]} + assert calls["n"] == 1 + + result2 = load_inventory() + assert result2 == {"items": ["item_0", "item_1", "item_2"]} + assert calls["n"] == 1 + + def test_bgcache_redis_with_error_handler(self, redis_client): + """Test BGCache error handling with Redis.""" + errors = [] + cache = RedisCache(redis_client, prefix="bg:") + + def on_error(exc): + errors.append(exc) + + @BGCache.register_loader( + key="failing_loader", + interval_seconds=10, + run_immediately=True, + on_error=on_error, + cache=cache, + ) + def failing_loader(): + raise ValueError("Simulated failure") + + time.sleep(0.1) + + assert len(errors) == 1 + assert isinstance(errors[0], ValueError) + + +class TestHybridCacheWithRedis: + """Test HybridCache (L1 memory + L2 Redis) backend.""" + + def test_hybridcache_basic_flow(self, redis_client): + """Test HybridCache with L1 (memory) and L2 (Redis).""" + l2 = RedisCache(redis_client, prefix="hybrid:") + cache = HybridCache( + l1_cache=InMemCache(), + l2_cache=l2, + l1_ttl=1, + ) + + cache.set("key", {"data": "value"}, ttl=60) + + result1 = cache.get("key") + assert result1 == {"data": "value"} + + assert cache.exists("key") + + cache.delete("key") + assert not cache.exists("key") + + def test_hybridcache_l1_miss_l2_hit(self, redis_client): + """Test HybridCache L1 miss, L2 hit, and L1 repopulation.""" + l1 = InMemCache() + l2 = RedisCache(redis_client, prefix="hybrid:") + cache = HybridCache(l1_cache=l1, l2_cache=l2, l1_ttl=60) + + l2.set("key", "value_from_l2", 60) + + result = cache.get("key") + assert result == "value_from_l2" + + assert l1.get("key") == "value_from_l2" + + def test_hybridcache_with_ttlcache(self, redis_client): + """Test TTLCache using HybridCache backend.""" + l2 = RedisCache(redis_client, prefix="hybrid_ttl:") + cache = HybridCache( + l1_cache=InMemCache(), + l2_cache=l2, + l1_ttl=60, + ) + + calls = {"n": 0} + + @TTLCache.cached("user:{}", ttl=60, cache=cache) + def get_user(user_id: int): + calls["n"] += 1 + return {"id": user_id} + + result1 = get_user(1) + assert result1 == {"id": 1} + assert calls["n"] == 1 + + result2 = get_user(1) + assert result2 == {"id": 1} + assert calls["n"] == 1 + + +class TestRedisPerformance: + """Performance tests with Redis backend.""" + + def test_redis_cache_hit_performance(self, redis_client): + """Verify Redis cache hits are fast.""" + cache = RedisCache(redis_client, prefix="perf:") + + cache.set("perf_key", {"data": "test"}, ttl=60) + + start = time.perf_counter() + for _ in range(1000): + result = cache.get("perf_key") + duration = time.perf_counter() - start + + avg_time_ms = (duration / 1000) * 1000 + + # Generous for CI environment + assert avg_time_ms < 20, f"Redis cache hit too slow: {avg_time_ms:.3f}ms" + assert result == {"data": "test"} + + def test_ttlcache_with_redis_performance(self, redis_client): + """Test TTLCache performance with Redis backend.""" + cache = RedisCache(redis_client, prefix="perf_ttl:") + + @TTLCache.cached("item:{}", ttl=60, cache=cache) + def get_item(item_id: int): + return {"id": item_id} + + get_item(1) + + start = time.perf_counter() + for _ in range(1000): + get_item(1) + duration = time.perf_counter() - start + + avg_time_ms = (duration / 1000) * 1000 + + assert avg_time_ms < 25, f"TTLCache hit too slow: {avg_time_ms:.3f}ms" + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/uv.lock b/uv.lock index f9ba41f..4ccd87d 100644 --- a/uv.lock +++ b/uv.lock @@ -1,10 +1,14 @@ version = 1 revision = 1 requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.11'", + "python_full_version < '3.11'", +] [[package]] name = "advanced-caching" -version = "0.1.2" +version = "0.1.4" source = { editable = "." } dependencies = [ { name = "apscheduler" }, @@ -24,6 +28,8 @@ dev = [ { name = "pytest" }, { name = "pytest-cov" }, { name = "ruff" }, + { name = "scalene" }, + { name = "testcontainers", extra = ["redis"] }, ] [package.metadata] @@ -40,6 +46,17 @@ dev = [ { name = "pytest", specifier = ">=8.2" }, { name = "pytest-cov", specifier = ">=4.0" }, { name = "ruff", specifier = ">=0.14.8" }, + { name = "scalene", specifier = ">=1.5.55" }, + { name = "testcontainers", extras = ["redis"], specifier = ">=4.0.0" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, ] [[package]] @@ -63,6 +80,113 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233 }, ] +[[package]] +name = "certifi" +version = "2025.11.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438 }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709 }, + { url = "https://files.pythonhosted.org/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814 }, + { url = "https://files.pythonhosted.org/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467 }, + { url = "https://files.pythonhosted.org/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280 }, + { url = "https://files.pythonhosted.org/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454 }, + { url = "https://files.pythonhosted.org/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609 }, + { url = "https://files.pythonhosted.org/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849 }, + { url = "https://files.pythonhosted.org/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586 }, + { url = "https://files.pythonhosted.org/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290 }, + { url = "https://files.pythonhosted.org/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663 }, + { url = "https://files.pythonhosted.org/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964 }, + { url = "https://files.pythonhosted.org/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064 }, + { url = "https://files.pythonhosted.org/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015 }, + { url = "https://files.pythonhosted.org/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792 }, + { url = "https://files.pythonhosted.org/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198 }, + { url = "https://files.pythonhosted.org/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262 }, + { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988 }, + { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324 }, + { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742 }, + { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863 }, + { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837 }, + { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550 }, + { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162 }, + { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019 }, + { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310 }, + { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022 }, + { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383 }, + { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098 }, + { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991 }, + { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456 }, + { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978 }, + { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969 }, + { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425 }, + { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162 }, + { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558 }, + { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497 }, + { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240 }, + { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471 }, + { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864 }, + { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647 }, + { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110 }, + { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839 }, + { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667 }, + { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535 }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816 }, + { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694 }, + { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131 }, + { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390 }, + { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091 }, + { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936 }, + { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180 }, + { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346 }, + { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874 }, + { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076 }, + { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601 }, + { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376 }, + { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825 }, + { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583 }, + { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366 }, + { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300 }, + { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465 }, + { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404 }, + { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092 }, + { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408 }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746 }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889 }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641 }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779 }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035 }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542 }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524 }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395 }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680 }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045 }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687 }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014 }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044 }, + { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940 }, + { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104 }, + { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743 }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402 }, +] + +[[package]] +name = "cloudpickle" +version = "3.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228 }, +] + [[package]] name = "colorama" version = "0.4.6" @@ -176,18 +300,41 @@ toml = [ { name = "tomli", marker = "python_full_version <= '3.11'" }, ] +[[package]] +name = "docker" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "requests" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/9b/4a2ea29aeba62471211598dac5d96825bb49348fa07e906ea930394a83ce/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c", size = 117834 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/26/57c6fb270950d476074c087527a558ccb6f4436657314bfb6cdf484114c4/docker-7.1.0-py3-none-any.whl", hash = "sha256:c96b93b7f0a746f9e77d325bcfb87422a3d8bd4f03136ae8a85b37f1898d5fc0", size = 147774 }, +] + [[package]] name = "exceptiongroup" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371 } wheels = [ { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740 }, ] +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008 }, +] + [[package]] name = "iniconfig" version = "2.3.0" @@ -197,6 +344,282 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484 }, ] +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321 }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631 }, + { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057 }, + { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050 }, + { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681 }, + { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705 }, + { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524 }, + { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282 }, + { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745 }, + { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571 }, + { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056 }, + { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932 }, + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631 }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058 }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287 }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940 }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887 }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692 }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471 }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923 }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572 }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077 }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876 }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615 }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020 }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332 }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947 }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962 }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760 }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529 }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015 }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540 }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105 }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906 }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622 }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029 }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374 }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980 }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990 }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784 }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588 }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041 }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543 }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113 }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911 }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658 }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066 }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639 }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569 }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284 }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801 }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769 }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642 }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612 }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200 }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973 }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619 }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029 }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408 }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005 }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048 }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821 }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606 }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043 }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747 }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341 }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073 }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661 }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069 }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670 }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598 }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261 }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835 }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733 }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672 }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819 }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426 }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146 }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245 }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048 }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542 }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301 }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320 }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050 }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034 }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185 }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149 }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620 }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963 }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743 }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616 }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579 }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005 }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570 }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548 }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521 }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866 }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455 }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348 }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362 }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103 }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382 }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462 }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618 }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511 }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783 }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506 }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190 }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828 }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006 }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765 }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736 }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719 }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072 }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213 }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632 }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532 }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885 }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467 }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144 }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217 }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014 }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935 }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122 }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143 }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260 }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225 }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374 }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391 }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754 }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476 }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666 }, +] + +[[package]] +name = "numpy" +version = "2.3.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/77/84dd1d2e34d7e2792a236ba180b5e8fcc1e3e414e761ce0253f63d7f572e/numpy-2.3.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de5672f4a7b200c15a4127042170a694d4df43c992948f5e1af57f0174beed10", size = 17034641 }, + { url = "https://files.pythonhosted.org/packages/2a/ea/25e26fa5837106cde46ae7d0b667e20f69cbbc0efd64cba8221411ab26ae/numpy-2.3.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:acfd89508504a19ed06ef963ad544ec6664518c863436306153e13e94605c218", size = 12528324 }, + { url = "https://files.pythonhosted.org/packages/4d/1a/e85f0eea4cf03d6a0228f5c0256b53f2df4bc794706e7df019fc622e47f1/numpy-2.3.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ffe22d2b05504f786c867c8395de703937f934272eb67586817b46188b4ded6d", size = 5356872 }, + { url = "https://files.pythonhosted.org/packages/5c/bb/35ef04afd567f4c989c2060cde39211e4ac5357155c1833bcd1166055c61/numpy-2.3.5-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:872a5cf366aec6bb1147336480fef14c9164b154aeb6542327de4970282cd2f5", size = 6893148 }, + { url = "https://files.pythonhosted.org/packages/f2/2b/05bbeb06e2dff5eab512dfc678b1cc5ee94d8ac5956a0885c64b6b26252b/numpy-2.3.5-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3095bdb8dd297e5920b010e96134ed91d852d81d490e787beca7e35ae1d89cf7", size = 14557282 }, + { url = "https://files.pythonhosted.org/packages/65/fb/2b23769462b34398d9326081fad5655198fcf18966fcb1f1e49db44fbf31/numpy-2.3.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8cba086a43d54ca804ce711b2a940b16e452807acebe7852ff327f1ecd49b0d4", size = 16897903 }, + { url = "https://files.pythonhosted.org/packages/ac/14/085f4cf05fc3f1e8aa95e85404e984ffca9b2275a5dc2b1aae18a67538b8/numpy-2.3.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6cf9b429b21df6b99f4dee7a1218b8b7ffbbe7df8764dc0bd60ce8a0708fed1e", size = 16341672 }, + { url = "https://files.pythonhosted.org/packages/6f/3b/1f73994904142b2aa290449b3bb99772477b5fd94d787093e4f24f5af763/numpy-2.3.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:396084a36abdb603546b119d96528c2f6263921c50df3c8fd7cb28873a237748", size = 18838896 }, + { url = "https://files.pythonhosted.org/packages/cd/b9/cf6649b2124f288309ffc353070792caf42ad69047dcc60da85ee85fea58/numpy-2.3.5-cp311-cp311-win32.whl", hash = "sha256:b0c7088a73aef3d687c4deef8452a3ac7c1be4e29ed8bf3b366c8111128ac60c", size = 6563608 }, + { url = "https://files.pythonhosted.org/packages/aa/44/9fe81ae1dcc29c531843852e2874080dc441338574ccc4306b39e2ff6e59/numpy-2.3.5-cp311-cp311-win_amd64.whl", hash = "sha256:a414504bef8945eae5f2d7cb7be2d4af77c5d1cb5e20b296c2c25b61dff2900c", size = 13078442 }, + { url = "https://files.pythonhosted.org/packages/6d/a7/f99a41553d2da82a20a2f22e93c94f928e4490bb447c9ff3c4ff230581d3/numpy-2.3.5-cp311-cp311-win_arm64.whl", hash = "sha256:0cd00b7b36e35398fa2d16af7b907b65304ef8bb4817a550e06e5012929830fa", size = 10458555 }, + { url = "https://files.pythonhosted.org/packages/44/37/e669fe6cbb2b96c62f6bbedc6a81c0f3b7362f6a59230b23caa673a85721/numpy-2.3.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:74ae7b798248fe62021dbf3c914245ad45d1a6b0cb4a29ecb4b31d0bfbc4cc3e", size = 16733873 }, + { url = "https://files.pythonhosted.org/packages/c5/65/df0db6c097892c9380851ab9e44b52d4f7ba576b833996e0080181c0c439/numpy-2.3.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee3888d9ff7c14604052b2ca5535a30216aa0a58e948cdd3eeb8d3415f638769", size = 12259838 }, + { url = "https://files.pythonhosted.org/packages/5b/e1/1ee06e70eb2136797abe847d386e7c0e830b67ad1d43f364dd04fa50d338/numpy-2.3.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:612a95a17655e213502f60cfb9bf9408efdc9eb1d5f50535cc6eb365d11b42b5", size = 5088378 }, + { url = "https://files.pythonhosted.org/packages/6d/9c/1ca85fb86708724275103b81ec4cf1ac1d08f465368acfc8da7ab545bdae/numpy-2.3.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3101e5177d114a593d79dd79658650fe28b5a0d8abeb8ce6f437c0e6df5be1a4", size = 6628559 }, + { url = "https://files.pythonhosted.org/packages/74/78/fcd41e5a0ce4f3f7b003da85825acddae6d7ecb60cf25194741b036ca7d6/numpy-2.3.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b973c57ff8e184109db042c842423ff4f60446239bd585a5131cc47f06f789d", size = 14250702 }, + { url = "https://files.pythonhosted.org/packages/b6/23/2a1b231b8ff672b4c450dac27164a8b2ca7d9b7144f9c02d2396518352eb/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28", size = 16606086 }, + { url = "https://files.pythonhosted.org/packages/a0/c5/5ad26fbfbe2012e190cc7d5003e4d874b88bb18861d0829edc140a713021/numpy-2.3.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:51c1e14eb1e154ebd80e860722f9e6ed6ec89714ad2db2d3aa33c31d7c12179b", size = 16025985 }, + { url = "https://files.pythonhosted.org/packages/d2/fa/dd48e225c46c819288148d9d060b047fd2a6fb1eb37eae25112ee4cb4453/numpy-2.3.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b46b4ec24f7293f23adcd2d146960559aaf8020213de8ad1909dba6c013bf89c", size = 18542976 }, + { url = "https://files.pythonhosted.org/packages/05/79/ccbd23a75862d95af03d28b5c6901a1b7da4803181513d52f3b86ed9446e/numpy-2.3.5-cp312-cp312-win32.whl", hash = "sha256:3997b5b3c9a771e157f9aae01dd579ee35ad7109be18db0e85dbdbe1de06e952", size = 6285274 }, + { url = "https://files.pythonhosted.org/packages/2d/57/8aeaf160312f7f489dea47ab61e430b5cb051f59a98ae68b7133ce8fa06a/numpy-2.3.5-cp312-cp312-win_amd64.whl", hash = "sha256:86945f2ee6d10cdfd67bcb4069c1662dd711f7e2a4343db5cecec06b87cf31aa", size = 12782922 }, + { url = "https://files.pythonhosted.org/packages/78/a6/aae5cc2ca78c45e64b9ef22f089141d661516856cf7c8a54ba434576900d/numpy-2.3.5-cp312-cp312-win_arm64.whl", hash = "sha256:f28620fe26bee16243be2b7b874da327312240a7cdc38b769a697578d2100013", size = 10194667 }, + { url = "https://files.pythonhosted.org/packages/db/69/9cde09f36da4b5a505341180a3f2e6fadc352fd4d2b7096ce9778db83f1a/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff", size = 16728251 }, + { url = "https://files.pythonhosted.org/packages/79/fb/f505c95ceddd7027347b067689db71ca80bd5ecc926f913f1a23e65cf09b/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188", size = 12254652 }, + { url = "https://files.pythonhosted.org/packages/78/da/8c7738060ca9c31b30e9301ee0cf6c5ffdbf889d9593285a1cead337f9a5/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0", size = 5083172 }, + { url = "https://files.pythonhosted.org/packages/a4/b4/ee5bb2537fb9430fd2ef30a616c3672b991a4129bb1c7dcc42aa0abbe5d7/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903", size = 6622990 }, + { url = "https://files.pythonhosted.org/packages/95/03/dc0723a013c7d7c19de5ef29e932c3081df1c14ba582b8b86b5de9db7f0f/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d", size = 14248902 }, + { url = "https://files.pythonhosted.org/packages/f5/10/ca162f45a102738958dcec8023062dad0cbc17d1ab99d68c4e4a6c45fb2b/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017", size = 16597430 }, + { url = "https://files.pythonhosted.org/packages/2a/51/c1e29be863588db58175175f057286900b4b3327a1351e706d5e0f8dd679/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf", size = 16024551 }, + { url = "https://files.pythonhosted.org/packages/83/68/8236589d4dbb87253d28259d04d9b814ec0ecce7cb1c7fed29729f4c3a78/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce", size = 18533275 }, + { url = "https://files.pythonhosted.org/packages/40/56/2932d75b6f13465239e3b7b7e511be27f1b8161ca2510854f0b6e521c395/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e", size = 6277637 }, + { url = "https://files.pythonhosted.org/packages/0c/88/e2eaa6cffb115b85ed7c7c87775cb8bcf0816816bc98ca8dbfa2ee33fe6e/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b", size = 12779090 }, + { url = "https://files.pythonhosted.org/packages/8f/88/3f41e13a44ebd4034ee17baa384acac29ba6a4fcc2aca95f6f08ca0447d1/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae", size = 10194710 }, + { url = "https://files.pythonhosted.org/packages/13/cb/71744144e13389d577f867f745b7df2d8489463654a918eea2eeb166dfc9/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd", size = 16827292 }, + { url = "https://files.pythonhosted.org/packages/71/80/ba9dc6f2a4398e7f42b708a7fdc841bb638d353be255655498edbf9a15a8/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f", size = 12378897 }, + { url = "https://files.pythonhosted.org/packages/2e/6d/db2151b9f64264bcceccd51741aa39b50150de9b602d98ecfe7e0c4bff39/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a", size = 5207391 }, + { url = "https://files.pythonhosted.org/packages/80/ae/429bacace5ccad48a14c4ae5332f6aa8ab9f69524193511d60ccdfdc65fa/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139", size = 6721275 }, + { url = "https://files.pythonhosted.org/packages/74/5b/1919abf32d8722646a38cd527bc3771eb229a32724ee6ba340ead9b92249/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e", size = 14306855 }, + { url = "https://files.pythonhosted.org/packages/a5/87/6831980559434973bebc30cd9c1f21e541a0f2b0c280d43d3afd909b66d0/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9", size = 16657359 }, + { url = "https://files.pythonhosted.org/packages/dd/91/c797f544491ee99fd00495f12ebb7802c440c1915811d72ac5b4479a3356/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946", size = 16093374 }, + { url = "https://files.pythonhosted.org/packages/74/a6/54da03253afcbe7a72785ec4da9c69fb7a17710141ff9ac5fcb2e32dbe64/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1", size = 18594587 }, + { url = "https://files.pythonhosted.org/packages/80/e9/aff53abbdd41b0ecca94285f325aff42357c6b5abc482a3fcb4994290b18/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3", size = 6405940 }, + { url = "https://files.pythonhosted.org/packages/d5/81/50613fec9d4de5480de18d4f8ef59ad7e344d497edbef3cfd80f24f98461/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234", size = 12920341 }, + { url = "https://files.pythonhosted.org/packages/bb/ab/08fd63b9a74303947f34f0bd7c5903b9c5532c2d287bead5bdf4c556c486/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7", size = 10262507 }, + { url = "https://files.pythonhosted.org/packages/ba/97/1a914559c19e32d6b2e233cf9a6a114e67c856d35b1d6babca571a3e880f/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82", size = 16735706 }, + { url = "https://files.pythonhosted.org/packages/57/d4/51233b1c1b13ecd796311216ae417796b88b0616cfd8a33ae4536330748a/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0", size = 12264507 }, + { url = "https://files.pythonhosted.org/packages/45/98/2fe46c5c2675b8306d0b4a3ec3494273e93e1226a490f766e84298576956/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63", size = 5093049 }, + { url = "https://files.pythonhosted.org/packages/ce/0e/0698378989bb0ac5f1660c81c78ab1fe5476c1a521ca9ee9d0710ce54099/numpy-2.3.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2dcd0808a421a482a080f89859a18beb0b3d1e905b81e617a188bd80422d62e9", size = 6626603 }, + { url = "https://files.pythonhosted.org/packages/5e/a6/9ca0eecc489640615642a6cbc0ca9e10df70df38c4d43f5a928ff18d8827/numpy-2.3.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727fd05b57df37dc0bcf1a27767a3d9a78cbbc92822445f32cc3436ba797337b", size = 14262696 }, + { url = "https://files.pythonhosted.org/packages/c8/f6/07ec185b90ec9d7217a00eeeed7383b73d7e709dae2a9a021b051542a708/numpy-2.3.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fffe29a1ef00883599d1dc2c51aa2e5d80afe49523c261a74933df395c15c520", size = 16597350 }, + { url = "https://files.pythonhosted.org/packages/75/37/164071d1dde6a1a84c9b8e5b414fa127981bad47adf3a6b7e23917e52190/numpy-2.3.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f7f0e05112916223d3f438f293abf0727e1181b5983f413dfa2fefc4098245c", size = 16040190 }, + { url = "https://files.pythonhosted.org/packages/08/3c/f18b82a406b04859eb026d204e4e1773eb41c5be58410f41ffa511d114ae/numpy-2.3.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2e2eb32ddb9ccb817d620ac1d8dae7c3f641c1e5f55f531a33e8ab97960a75b8", size = 18536749 }, + { url = "https://files.pythonhosted.org/packages/40/79/f82f572bf44cf0023a2fe8588768e23e1592585020d638999f15158609e1/numpy-2.3.5-cp314-cp314-win32.whl", hash = "sha256:66f85ce62c70b843bab1fb14a05d5737741e74e28c7b8b5a064de10142fad248", size = 6335432 }, + { url = "https://files.pythonhosted.org/packages/a3/2e/235b4d96619931192c91660805e5e49242389742a7a82c27665021db690c/numpy-2.3.5-cp314-cp314-win_amd64.whl", hash = "sha256:e6a0bc88393d65807d751a614207b7129a310ca4fe76a74e5c7da5fa5671417e", size = 12919388 }, + { url = "https://files.pythonhosted.org/packages/07/2b/29fd75ce45d22a39c61aad74f3d718e7ab67ccf839ca8b60866054eb15f8/numpy-2.3.5-cp314-cp314-win_arm64.whl", hash = "sha256:aeffcab3d4b43712bb7a60b65f6044d444e75e563ff6180af8f98dd4b905dfd2", size = 10476651 }, + { url = "https://files.pythonhosted.org/packages/17/e1/f6a721234ebd4d87084cfa68d081bcba2f5cfe1974f7de4e0e8b9b2a2ba1/numpy-2.3.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17531366a2e3a9e30762c000f2c43a9aaa05728712e25c11ce1dbe700c53ad41", size = 16834503 }, + { url = "https://files.pythonhosted.org/packages/5c/1c/baf7ffdc3af9c356e1c135e57ab7cf8d247931b9554f55c467efe2c69eff/numpy-2.3.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d21644de1b609825ede2f48be98dfde4656aefc713654eeee280e37cadc4e0ad", size = 12381612 }, + { url = "https://files.pythonhosted.org/packages/74/91/f7f0295151407ddc9ba34e699013c32c3c91944f9b35fcf9281163dc1468/numpy-2.3.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c804e3a5aba5460c73955c955bdbd5c08c354954e9270a2c1565f62e866bdc39", size = 5210042 }, + { url = "https://files.pythonhosted.org/packages/2e/3b/78aebf345104ec50dd50a4d06ddeb46a9ff5261c33bcc58b1c4f12f85ec2/numpy-2.3.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:cc0a57f895b96ec78969c34f682c602bf8da1a0270b09bc65673df2e7638ec20", size = 6724502 }, + { url = "https://files.pythonhosted.org/packages/02/c6/7c34b528740512e57ef1b7c8337ab0b4f0bddf34c723b8996c675bc2bc91/numpy-2.3.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:900218e456384ea676e24ea6a0417f030a3b07306d29d7ad843957b40a9d8d52", size = 14308962 }, + { url = "https://files.pythonhosted.org/packages/80/35/09d433c5262bc32d725bafc619e095b6a6651caf94027a03da624146f655/numpy-2.3.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a1bea522b25109bf8e6f3027bd810f7c1085c64a0c7ce050c1676ad0ba010b", size = 16655054 }, + { url = "https://files.pythonhosted.org/packages/7a/ab/6a7b259703c09a88804fa2430b43d6457b692378f6b74b356155283566ac/numpy-2.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04822c00b5fd0323c8166d66c701dc31b7fbd252c100acd708c48f763968d6a3", size = 16091613 }, + { url = "https://files.pythonhosted.org/packages/c2/88/330da2071e8771e60d1038166ff9d73f29da37b01ec3eb43cb1427464e10/numpy-2.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d6889ec4ec662a1a37eb4b4fb26b6100841804dac55bd9df579e326cdc146227", size = 18591147 }, + { url = "https://files.pythonhosted.org/packages/51/41/851c4b4082402d9ea860c3626db5d5df47164a712cb23b54be028b184c1c/numpy-2.3.5-cp314-cp314t-win32.whl", hash = "sha256:93eebbcf1aafdf7e2ddd44c2923e2672e1010bddc014138b229e49725b4d6be5", size = 6479806 }, + { url = "https://files.pythonhosted.org/packages/90/30/d48bde1dfd93332fa557cff1972fbc039e055a52021fbef4c2c4b1eefd17/numpy-2.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c8a9958e88b65c3b27e22ca2a076311636850b612d6bbfb76e8d156aacde2aaf", size = 13105760 }, + { url = "https://files.pythonhosted.org/packages/2d/fd/4b5eb0b3e888d86aee4d198c23acec7d214baaf17ea93c1adec94c9518b9/numpy-2.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:6203fdf9f3dc5bdaed7319ad8698e685c7a3be10819f41d32a0723e611733b42", size = 10545459 }, + { url = "https://files.pythonhosted.org/packages/c6/65/f9dea8e109371ade9c782b4e4756a82edf9d3366bca495d84d79859a0b79/numpy-2.3.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f0963b55cdd70fad460fa4c1341f12f976bb26cb66021a5580329bd498988310", size = 16910689 }, + { url = "https://files.pythonhosted.org/packages/00/4f/edb00032a8fb92ec0a679d3830368355da91a69cab6f3e9c21b64d0bb986/numpy-2.3.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f4255143f5160d0de972d28c8f9665d882b5f61309d8362fdd3e103cf7bf010c", size = 12457053 }, + { url = "https://files.pythonhosted.org/packages/16/a4/e8a53b5abd500a63836a29ebe145fc1ab1f2eefe1cfe59276020373ae0aa/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:a4b9159734b326535f4dd01d947f919c6eefd2d9827466a696c44ced82dfbc18", size = 5285635 }, + { url = "https://files.pythonhosted.org/packages/a3/2f/37eeb9014d9c8b3e9c55bc599c68263ca44fdbc12a93e45a21d1d56df737/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:2feae0d2c91d46e59fcd62784a3a83b3fb677fead592ce51b5a6fbb4f95965ff", size = 6801770 }, + { url = "https://files.pythonhosted.org/packages/7d/e4/68d2f474df2cb671b2b6c2986a02e520671295647dad82484cde80ca427b/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffac52f28a7849ad7576293c0cb7b9f08304e8f7d738a8cb8a90ec4c55a998eb", size = 14391768 }, + { url = "https://files.pythonhosted.org/packages/b8/50/94ccd8a2b141cb50651fddd4f6a48874acb3c91c8f0842b08a6afc4b0b21/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c0e9e7eea69588479ebf4a8a270d5ac22763cc5854e9a7eae952a3908103f7", size = 16729263 }, + { url = "https://files.pythonhosted.org/packages/2d/ee/346fa473e666fe14c52fcdd19ec2424157290a032d4c41f98127bfb31ac7/numpy-2.3.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f16417ec91f12f814b10bafe79ef77e70113a2f5f7018640e7425ff979253425", size = 12967213 }, +] + +[[package]] +name = "nvidia-ml-py" +version = "13.590.44" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/23/3871537f204aee823c574ba25cbeb08cae779979d4d43c01adddda00bab9/nvidia_ml_py-13.590.44.tar.gz", hash = "sha256:b358c7614b0fdeea4b95f046f1c90123bfe25d148ab93bb1c00248b834703373", size = 49737 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/47/4c822bd37a008e72fd5a0eae33524ae3ac97b13f7030f63bae1728b8957e/nvidia_ml_py-13.590.44-py3-none-any.whl", hash = "sha256:18feb54eca7d0e3cdc8d1a040a771eda72d9ec3148e5443087970dbfd7377ecc", size = 50683 }, +] + [[package]] name = "packaging" version = "25.0" @@ -215,6 +638,165 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 }, ] +[[package]] +name = "psutil" +version = "7.1.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz", hash = "sha256:6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74", size = 489059 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc", size = 239751 }, + { url = "https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0", size = 240368 }, + { url = "https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7", size = 287134 }, + { url = "https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251", size = 289904 }, + { url = "https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa", size = 249642 }, + { url = "https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee", size = 245518 }, + { url = "https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353", size = 239843 }, + { url = "https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b", size = 240369 }, + { url = "https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9", size = 288210 }, + { url = "https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f", size = 291182 }, + { url = "https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7", size = 250466 }, + { url = "https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264", size = 245756 }, + { url = "https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab", size = 238359 }, + { url = "https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880", size = 239171 }, + { url = "https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3", size = 263261 }, + { url = "https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b", size = 264635 }, + { url = "https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl", hash = "sha256:f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd", size = 247633 }, + { url = "https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl", hash = "sha256:bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1", size = 244608 }, +] + +[[package]] +name = "pydantic" +version = "2.12.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580 }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298 }, + { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475 }, + { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815 }, + { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567 }, + { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442 }, + { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956 }, + { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253 }, + { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050 }, + { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178 }, + { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833 }, + { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156 }, + { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378 }, + { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622 }, + { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873 }, + { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826 }, + { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869 }, + { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890 }, + { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740 }, + { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021 }, + { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378 }, + { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761 }, + { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303 }, + { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355 }, + { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875 }, + { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549 }, + { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305 }, + { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902 }, + { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990 }, + { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003 }, + { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200 }, + { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578 }, + { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504 }, + { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816 }, + { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366 }, + { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698 }, + { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603 }, + { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591 }, + { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068 }, + { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908 }, + { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145 }, + { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179 }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403 }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206 }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307 }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258 }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917 }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186 }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164 }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146 }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788 }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133 }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852 }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679 }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766 }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005 }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622 }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725 }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040 }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691 }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897 }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302 }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877 }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680 }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960 }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102 }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039 }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126 }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489 }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288 }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255 }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760 }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092 }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385 }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832 }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585 }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078 }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914 }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560 }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244 }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955 }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906 }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607 }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769 }, + { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441 }, + { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291 }, + { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632 }, + { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905 }, + { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495 }, + { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388 }, + { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879 }, + { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017 }, + { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351 }, + { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363 }, + { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615 }, + { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369 }, + { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218 }, + { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951 }, + { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428 }, + { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009 }, + { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980 }, + { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865 }, + { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256 }, + { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762 }, + { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141 }, + { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317 }, + { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992 }, + { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302 }, +] + [[package]] name = "pygments" version = "2.19.2" @@ -256,6 +838,37 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424 }, ] +[[package]] +name = "python-dotenv" +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230 }, +] + +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/40/44efbb0dfbd33aca6a6483191dae0716070ed99e2ecb0c53683f400a0b4f/pywin32-311-cp310-cp310-win32.whl", hash = "sha256:d03ff496d2a0cd4a5893504789d4a15399133fe82517455e78bad62efbb7f0a3", size = 8760432 }, + { url = "https://files.pythonhosted.org/packages/5e/bf/360243b1e953bd254a82f12653974be395ba880e7ec23e3731d9f73921cc/pywin32-311-cp310-cp310-win_amd64.whl", hash = "sha256:797c2772017851984b97180b0bebe4b620bb86328e8a884bb626156295a63b3b", size = 9590103 }, + { url = "https://files.pythonhosted.org/packages/57/38/d290720e6f138086fb3d5ffe0b6caa019a791dd57866940c82e4eeaf2012/pywin32-311-cp310-cp310-win_arm64.whl", hash = "sha256:0502d1facf1fed4839a9a51ccbcc63d952cf318f78ffc00a7e78528ac27d7a2b", size = 8778557 }, + { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031 }, + { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308 }, + { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930 }, + { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543 }, + { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040 }, + { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102 }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700 }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700 }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318 }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714 }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800 }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540 }, +] + [[package]] name = "redis" version = "7.1.0" @@ -268,30 +881,112 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/89/f0/8956f8a86b20d7bb9d6ac0187cf4cd54d8065bc9a1a09eb8011d4d326596/redis-7.1.0-py3-none-any.whl", hash = "sha256:23c52b208f92b56103e17c5d06bdc1a6c2c0b3106583985a76a18f83b265de2b", size = 354159 }, ] +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738 }, +] + +[[package]] +name = "rich" +version = "14.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393 }, +] + [[package]] name = "ruff" -version = "0.14.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ed/d9/f7a0c4b3a2bf2556cd5d99b05372c29980249ef71e8e32669ba77428c82c/ruff-0.14.8.tar.gz", hash = "sha256:774ed0dd87d6ce925e3b8496feb3a00ac564bea52b9feb551ecd17e0a23d1eed", size = 5765385 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/48/b8/9537b52010134b1d2b72870cc3f92d5fb759394094741b09ceccae183fbe/ruff-0.14.8-py3-none-linux_armv6l.whl", hash = "sha256:ec071e9c82eca417f6111fd39f7043acb53cd3fde9b1f95bbed745962e345afb", size = 13441540 }, - { url = "https://files.pythonhosted.org/packages/24/00/99031684efb025829713682012b6dd37279b1f695ed1b01725f85fd94b38/ruff-0.14.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8cdb162a7159f4ca36ce980a18c43d8f036966e7f73f866ac8f493b75e0c27e9", size = 13669384 }, - { url = "https://files.pythonhosted.org/packages/72/64/3eb5949169fc19c50c04f28ece2c189d3b6edd57e5b533649dae6ca484fe/ruff-0.14.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e2fcbefe91f9fad0916850edf0854530c15bd1926b6b779de47e9ab619ea38f", size = 12806917 }, - { url = "https://files.pythonhosted.org/packages/c4/08/5250babb0b1b11910f470370ec0cbc67470231f7cdc033cee57d4976f941/ruff-0.14.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9d70721066a296f45786ec31916dc287b44040f553da21564de0ab4d45a869b", size = 13256112 }, - { url = "https://files.pythonhosted.org/packages/78/4c/6c588e97a8e8c2d4b522c31a579e1df2b4d003eddfbe23d1f262b1a431ff/ruff-0.14.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c87e09b3cd9d126fc67a9ecd3b5b1d3ded2b9c7fce3f16e315346b9d05cfb52", size = 13227559 }, - { url = "https://files.pythonhosted.org/packages/23/ce/5f78cea13eda8eceac71b5f6fa6e9223df9b87bb2c1891c166d1f0dce9f1/ruff-0.14.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d62cb310c4fbcb9ee4ac023fe17f984ae1e12b8a4a02e3d21489f9a2a5f730c", size = 13896379 }, - { url = "https://files.pythonhosted.org/packages/cf/79/13de4517c4dadce9218a20035b21212a4c180e009507731f0d3b3f5df85a/ruff-0.14.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1af35c2d62633d4da0521178e8a2641c636d2a7153da0bac1b30cfd4ccd91344", size = 15372786 }, - { url = "https://files.pythonhosted.org/packages/00/06/33df72b3bb42be8a1c3815fd4fae83fa2945fc725a25d87ba3e42d1cc108/ruff-0.14.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:25add4575ffecc53d60eed3f24b1e934493631b48ebbc6ebaf9d8517924aca4b", size = 14990029 }, - { url = "https://files.pythonhosted.org/packages/64/61/0f34927bd90925880394de0e081ce1afab66d7b3525336f5771dcf0cb46c/ruff-0.14.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c943d847b7f02f7db4201a0600ea7d244d8a404fbb639b439e987edcf2baf9a", size = 14407037 }, - { url = "https://files.pythonhosted.org/packages/96/bc/058fe0aefc0fbf0d19614cb6d1a3e2c048f7dc77ca64957f33b12cfdc5ef/ruff-0.14.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb6e8bf7b4f627548daa1b69283dac5a296bfe9ce856703b03130732e20ddfe2", size = 14102390 }, - { url = "https://files.pythonhosted.org/packages/af/a4/e4f77b02b804546f4c17e8b37a524c27012dd6ff05855d2243b49a7d3cb9/ruff-0.14.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7aaf2974f378e6b01d1e257c6948207aec6a9b5ba53fab23d0182efb887a0e4a", size = 14230793 }, - { url = "https://files.pythonhosted.org/packages/3f/52/bb8c02373f79552e8d087cedaffad76b8892033d2876c2498a2582f09dcf/ruff-0.14.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e5758ca513c43ad8a4ef13f0f081f80f08008f410790f3611a21a92421ab045b", size = 13160039 }, - { url = "https://files.pythonhosted.org/packages/1f/ad/b69d6962e477842e25c0b11622548df746290cc6d76f9e0f4ed7456c2c31/ruff-0.14.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f74f7ba163b6e85a8d81a590363bf71618847e5078d90827749bfda1d88c9cdf", size = 13205158 }, - { url = "https://files.pythonhosted.org/packages/06/63/54f23da1315c0b3dfc1bc03fbc34e10378918a20c0b0f086418734e57e74/ruff-0.14.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eed28f6fafcc9591994c42254f5a5c5ca40e69a30721d2ab18bb0bb3baac3ab6", size = 13469550 }, - { url = "https://files.pythonhosted.org/packages/70/7d/a4d7b1961e4903bc37fffb7ddcfaa7beb250f67d97cfd1ee1d5cddb1ec90/ruff-0.14.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:21d48fa744c9d1cb8d71eb0a740c4dd02751a5de9db9a730a8ef75ca34cf138e", size = 14211332 }, - { url = "https://files.pythonhosted.org/packages/5d/93/2a5063341fa17054e5c86582136e9895db773e3c2ffb770dde50a09f35f0/ruff-0.14.8-py3-none-win32.whl", hash = "sha256:15f04cb45c051159baebb0f0037f404f1dc2f15a927418f29730f411a79bc4e7", size = 13151890 }, - { url = "https://files.pythonhosted.org/packages/02/1c/65c61a0859c0add13a3e1cbb6024b42de587456a43006ca2d4fd3d1618fe/ruff-0.14.8-py3-none-win_amd64.whl", hash = "sha256:9eeb0b24242b5bbff3011409a739929f497f3fb5fe3b5698aba5e77e8c833097", size = 14537826 }, - { url = "https://files.pythonhosted.org/packages/6d/63/8b41cea3afd7f58eb64ac9251668ee0073789a3bc9ac6f816c8c6fef986d/ruff-0.14.8-py3-none-win_arm64.whl", hash = "sha256:965a582c93c63fe715fd3e3f8aa37c4b776777203d8e1d8aa3cc0c14424a4b99", size = 13634522 }, +version = "0.14.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/1b/ab712a9d5044435be8e9a2beb17cbfa4c241aa9b5e4413febac2a8b79ef2/ruff-0.14.9.tar.gz", hash = "sha256:35f85b25dd586381c0cc053f48826109384c81c00ad7ef1bd977bfcc28119d5b", size = 5809165 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/1c/d1b1bba22cffec02351c78ab9ed4f7d7391876e12720298448b29b7229c1/ruff-0.14.9-py3-none-linux_armv6l.whl", hash = "sha256:f1ec5de1ce150ca6e43691f4a9ef5c04574ad9ca35c8b3b0e18877314aba7e75", size = 13576541 }, + { url = "https://files.pythonhosted.org/packages/94/ab/ffe580e6ea1fca67f6337b0af59fc7e683344a43642d2d55d251ff83ceae/ruff-0.14.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ed9d7417a299fc6030b4f26333bf1117ed82a61ea91238558c0268c14e00d0c2", size = 13779363 }, + { url = "https://files.pythonhosted.org/packages/7d/f8/2be49047f929d6965401855461e697ab185e1a6a683d914c5c19c7962d9e/ruff-0.14.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d5dc3473c3f0e4a1008d0ef1d75cee24a48e254c8bed3a7afdd2b4392657ed2c", size = 12925292 }, + { url = "https://files.pythonhosted.org/packages/9e/e9/08840ff5127916bb989c86f18924fd568938b06f58b60e206176f327c0fe/ruff-0.14.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84bf7c698fc8f3cb8278830fb6b5a47f9bcc1ed8cb4f689b9dd02698fa840697", size = 13362894 }, + { url = "https://files.pythonhosted.org/packages/31/1c/5b4e8e7750613ef43390bb58658eaf1d862c0cc3352d139cd718a2cea164/ruff-0.14.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aa733093d1f9d88a5d98988d8834ef5d6f9828d03743bf5e338bf980a19fce27", size = 13311482 }, + { url = "https://files.pythonhosted.org/packages/5b/3a/459dce7a8cb35ba1ea3e9c88f19077667a7977234f3b5ab197fad240b404/ruff-0.14.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a1cfb04eda979b20c8c19550c8b5f498df64ff8da151283311ce3199e8b3648", size = 14016100 }, + { url = "https://files.pythonhosted.org/packages/a6/31/f064f4ec32524f9956a0890fc6a944e5cf06c63c554e39957d208c0ffc45/ruff-0.14.9-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1e5cb521e5ccf0008bd74d5595a4580313844a42b9103b7388eca5a12c970743", size = 15477729 }, + { url = "https://files.pythonhosted.org/packages/7a/6d/f364252aad36ccd443494bc5f02e41bf677f964b58902a17c0b16c53d890/ruff-0.14.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd429a8926be6bba4befa8cdcf3f4dd2591c413ea5066b1e99155ed245ae42bb", size = 15122386 }, + { url = "https://files.pythonhosted.org/packages/20/02/e848787912d16209aba2799a4d5a1775660b6a3d0ab3944a4ccc13e64a02/ruff-0.14.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab208c1b7a492e37caeaf290b1378148f75e13c2225af5d44628b95fd7834273", size = 14497124 }, + { url = "https://files.pythonhosted.org/packages/f3/51/0489a6a5595b7760b5dbac0dd82852b510326e7d88d51dbffcd2e07e3ff3/ruff-0.14.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72034534e5b11e8a593f517b2f2f2b273eb68a30978c6a2d40473ad0aaa4cb4a", size = 14195343 }, + { url = "https://files.pythonhosted.org/packages/f6/53/3bb8d2fa73e4c2f80acc65213ee0830fa0c49c6479313f7a68a00f39e208/ruff-0.14.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:712ff04f44663f1b90a1195f51525836e3413c8a773574a7b7775554269c30ed", size = 14346425 }, + { url = "https://files.pythonhosted.org/packages/ad/04/bdb1d0ab876372da3e983896481760867fc84f969c5c09d428e8f01b557f/ruff-0.14.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a111fee1db6f1d5d5810245295527cda1d367c5aa8f42e0fca9a78ede9b4498b", size = 13258768 }, + { url = "https://files.pythonhosted.org/packages/40/d9/8bf8e1e41a311afd2abc8ad12be1b6c6c8b925506d9069b67bb5e9a04af3/ruff-0.14.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8769efc71558fecc25eb295ddec7d1030d41a51e9dcf127cbd63ec517f22d567", size = 13326939 }, + { url = "https://files.pythonhosted.org/packages/f4/56/a213fa9edb6dd849f1cfbc236206ead10913693c72a67fb7ddc1833bf95d/ruff-0.14.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:347e3bf16197e8a2de17940cd75fd6491e25c0aa7edf7d61aa03f146a1aa885a", size = 13578888 }, + { url = "https://files.pythonhosted.org/packages/33/09/6a4a67ffa4abae6bf44c972a4521337ffce9cbc7808faadede754ef7a79c/ruff-0.14.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7715d14e5bccf5b660f54516558aa94781d3eb0838f8e706fb60e3ff6eff03a8", size = 14314473 }, + { url = "https://files.pythonhosted.org/packages/12/0d/15cc82da5d83f27a3c6b04f3a232d61bc8c50d38a6cd8da79228e5f8b8d6/ruff-0.14.9-py3-none-win32.whl", hash = "sha256:df0937f30aaabe83da172adaf8937003ff28172f59ca9f17883b4213783df197", size = 13202651 }, + { url = "https://files.pythonhosted.org/packages/32/f7/c78b060388eefe0304d9d42e68fab8cffd049128ec466456cef9b8d4f06f/ruff-0.14.9-py3-none-win_amd64.whl", hash = "sha256:c0b53a10e61df15a42ed711ec0bda0c582039cf6c754c49c020084c55b5b0bc2", size = 14702079 }, + { url = "https://files.pythonhosted.org/packages/26/09/7a9520315decd2334afa65ed258fed438f070e31f05a2e43dd480a5e5911/ruff-0.14.9-py3-none-win_arm64.whl", hash = "sha256:8e821c366517a074046d92f0e9213ed1c13dbc5b37a7fc20b07f79b64d62cc84", size = 13744730 }, +] + +[[package]] +name = "scalene" +version = "1.5.55" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cloudpickle" }, + { name = "jinja2" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "nvidia-ml-py", marker = "sys_platform != 'darwin'" }, + { name = "psutil" }, + { name = "pydantic" }, + { name = "rich" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/65/e57f87fd92aa8c14f5404dc04542054afbc41c1ba8e9e86f4414a58983e9/scalene-1.5.55.tar.gz", hash = "sha256:71c0c89287f46f9f1fa965def5866156313a949ed592b8acb008f8cafcf7c518", size = 9331156 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/da/e270ae7e92f7ee2311af1125047f77a5f81ad45568cceae3e20f0b03750a/scalene-1.5.55-cp310-cp310-macosx_13_0_universal2.whl", hash = "sha256:441db462f1f69e11eb0fad6c9d061df4882287c99c4a2430b117dcbd84f4b7d8", size = 1135686 }, + { url = "https://files.pythonhosted.org/packages/ab/22/1abaf12312fb1f0df1e0533b968bfccb10f451a83ff3f0c041f8c9ef85d1/scalene-1.5.55-cp310-cp310-macosx_15_0_universal2.whl", hash = "sha256:2c6906abab7481935449a3f8fd460db3b8a9d9971ba14a5db44b95150931e1de", size = 1134464 }, + { url = "https://files.pythonhosted.org/packages/c7/80/59811e59e1ce2937b92c61fcb60aa31e76a60e70f41854f93cf33fc921ff/scalene-1.5.55-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7de65acfb441df94cb32d60e960c6335a6fe1617827a3da4cbb07816d12f372a", size = 1410961 }, + { url = "https://files.pythonhosted.org/packages/b1/d0/e05fadab789effd32c32b47a822106b65455db70736e968c612820770e62/scalene-1.5.55-cp310-cp310-win_amd64.whl", hash = "sha256:6707b7ddb87ca22fb55b1605960f9bae2a7f68f9acfb161f6b0816079b5496cf", size = 1025322 }, + { url = "https://files.pythonhosted.org/packages/10/fd/a88a2355a6290dffd32f7771ceb425aa42fa2b181f28a00df5a25797ce6a/scalene-1.5.55-cp311-cp311-macosx_13_0_universal2.whl", hash = "sha256:58c0ed50c159df32887fe91abde01e1e152d270814ffa892edbd79f132d3ffb3", size = 1136476 }, + { url = "https://files.pythonhosted.org/packages/cf/65/032be96f3d5dd548dfe60aed6403d367a35a76d712b6fd919527e51363e9/scalene-1.5.55-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:be4f5c58c8e31a8f7262c7c2bf39855b8573570ccb99e235055141a00f72fec6", size = 1134545 }, + { url = "https://files.pythonhosted.org/packages/f5/94/dfc47c4a3ffeaea541885296699961832cbf79328e432a565148218917cb/scalene-1.5.55-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9651c24636edf72e07d57ee24cc636b19ce4dbf3c0ca9d1d527fc69d20e1ae5c", size = 1411207 }, + { url = "https://files.pythonhosted.org/packages/d9/9a/616850c58f987aa889685431cfdce5bcfd0e7444fa20acdc750809a015c5/scalene-1.5.55-cp312-cp312-macosx_13_0_universal2.whl", hash = "sha256:1750f70215762dec3b7998fecbaf9b59704d18711f24258adf15d54cecf42e33", size = 1136310 }, + { url = "https://files.pythonhosted.org/packages/f2/e4/ba77dd1a9b3415287d9ee73909a4527799eaf44908fc8abe9ddb94ac8887/scalene-1.5.55-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:8bb094a887062bb12e91a81cc8b69c73a5f35a42da3cc6a67e92f8a3eea72af7", size = 1134356 }, + { url = "https://files.pythonhosted.org/packages/37/b5/8b67429f201b74c576794a4fbfc7fa401d2f4570ba3aa98d9922e3a6f5a8/scalene-1.5.55-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31ddee2590bcb55c53d9562b6aa8989c8c975b49777a0b4beb5d68ac7804d8c", size = 1411709 }, + { url = "https://files.pythonhosted.org/packages/ab/21/fe23516085fb57686bf3ce5573f83b28e12a7c994b96ea28b214b022aff9/scalene-1.5.55-cp312-cp312-win_amd64.whl", hash = "sha256:c86c06a88a1714f5a77c609e69153702a30e679a015045ba53e504aea19ede4b", size = 1025322 }, + { url = "https://files.pythonhosted.org/packages/a4/b9/9c0279f95e254eff8880d65687007f8ff3ec955fb0e0a3c3d93694a1ef7b/scalene-1.5.55-cp313-cp313-macosx_13_0_universal2.whl", hash = "sha256:34fd559e5043d91b17e450bd3373dec0279881959314be4db47bedaa9da065a9", size = 1136330 }, + { url = "https://files.pythonhosted.org/packages/31/84/a21828d85f94bbb053268c4513bef0f7e5c168ecb1e21315bc66f598c87f/scalene-1.5.55-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:c625fd30a3b73b98ae1acd2cb2268b0f654987021192277c62c0e6e0883cd0ae", size = 1134342 }, + { url = "https://files.pythonhosted.org/packages/bb/b4/33636da3cd6ed2a2bea19907c4c64a630931eb0fb6697a27735234ab4282/scalene-1.5.55-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4f42a8daaf7a17beca104d44dafc704617f35af385305baa27ed489bb2f2dc1", size = 1411645 }, + { url = "https://files.pythonhosted.org/packages/d0/5d/c620fd816a05b979cb5b61c8c18128e2136214a0e50b755231dfd4f4f0b4/scalene-1.5.55-cp313-cp313-win_amd64.whl", hash = "sha256:57daf3072f88e7fdda3bc94d0e75f30733268f033fed76f1b909c59315926634", size = 1025323 }, +] + +[[package]] +name = "testcontainers" +version = "4.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docker" }, + { name = "python-dotenv" }, + { name = "typing-extensions" }, + { name = "urllib3" }, + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/b3/c272537f3ea2f312555efeb86398cc382cd07b740d5f3c730918c36e64e1/testcontainers-4.13.3.tar.gz", hash = "sha256:9d82a7052c9a53c58b69e1dc31da8e7a715e8b3ec1c4df5027561b47e2efe646", size = 79064 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/27/c2f24b19dafa197c514abe70eda69bc031c5152c6b1f1e5b20099e2ceedd/testcontainers-4.13.3-py3-none-any.whl", hash = "sha256:063278c4805ffa6dd85e56648a9da3036939e6c0ac1001e851c9276b19b05970", size = 124784 }, +] + +[package.optional-dependencies] +redis = [ + { name = "redis" }, ] [[package]] @@ -352,6 +1047,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614 }, ] +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611 }, +] + [[package]] name = "tzdata" version = "2025.2" @@ -372,3 +1079,105 @@ sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd177 wheels = [ { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026 }, ] + +[[package]] +name = "urllib3" +version = "2.6.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/24/a2a2ed9addd907787d7aa0355ba36a6cadf1768b934c652ea78acbd59dcd/urllib3-2.6.2.tar.gz", hash = "sha256:016f9c98bb7e98085cb2b4b17b87d2c702975664e4f060c6532e64d1c1a5e797", size = 432930 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/b9/4095b668ea3678bf6a0af005527f39de12fb026516fb3df17495a733b7f8/urllib3-2.6.2-py3-none-any.whl", hash = "sha256:ec21cddfe7724fc7cb4ba4bea7aa8e2ef36f607a4bab81aa6ce42a13dc3f03dd", size = 131182 }, +] + +[[package]] +name = "wrapt" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2a/6de8a50cb435b7f42c46126cf1a54b2aab81784e74c8595c8e025e8f36d3/wrapt-2.0.1.tar.gz", hash = "sha256:9c9c635e78497cacb81e84f8b11b23e0aacac7a136e73b8e5b2109a1d9fc468f", size = 82040 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/0d/12d8c803ed2ce4e5e7d5b9f5f602721f9dfef82c95959f3ce97fa584bb5c/wrapt-2.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:64b103acdaa53b7caf409e8d45d39a8442fe6dcfec6ba3f3d141e0cc2b5b4dbd", size = 77481 }, + { url = "https://files.pythonhosted.org/packages/05/3e/4364ebe221ebf2a44d9fc8695a19324692f7dd2795e64bd59090856ebf12/wrapt-2.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:91bcc576260a274b169c3098e9a3519fb01f2989f6d3d386ef9cbf8653de1374", size = 60692 }, + { url = "https://files.pythonhosted.org/packages/1f/ff/ae2a210022b521f86a8ddcdd6058d137c051003812b0388a5e9a03d3fe10/wrapt-2.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ab594f346517010050126fcd822697b25a7031d815bb4fbc238ccbe568216489", size = 61574 }, + { url = "https://files.pythonhosted.org/packages/c6/93/5cf92edd99617095592af919cb81d4bff61c5dbbb70d3c92099425a8ec34/wrapt-2.0.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:36982b26f190f4d737f04a492a68accbfc6fa042c3f42326fdfbb6c5b7a20a31", size = 113688 }, + { url = "https://files.pythonhosted.org/packages/a0/0a/e38fc0cee1f146c9fb266d8ef96ca39fb14a9eef165383004019aa53f88a/wrapt-2.0.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23097ed8bc4c93b7bf36fa2113c6c733c976316ce0ee2c816f64ca06102034ef", size = 115698 }, + { url = "https://files.pythonhosted.org/packages/b0/85/bef44ea018b3925fb0bcbe9112715f665e4d5309bd945191da814c314fd1/wrapt-2.0.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8bacfe6e001749a3b64db47bcf0341da757c95959f592823a93931a422395013", size = 112096 }, + { url = "https://files.pythonhosted.org/packages/7c/0b/733a2376e413117e497aa1a5b1b78e8f3a28c0e9537d26569f67d724c7c5/wrapt-2.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8ec3303e8a81932171f455f792f8df500fc1a09f20069e5c16bd7049ab4e8e38", size = 114878 }, + { url = "https://files.pythonhosted.org/packages/da/03/d81dcb21bbf678fcda656495792b059f9d56677d119ca022169a12542bd0/wrapt-2.0.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:3f373a4ab5dbc528a94334f9fe444395b23c2f5332adab9ff4ea82f5a9e33bc1", size = 111298 }, + { url = "https://files.pythonhosted.org/packages/c9/d5/5e623040e8056e1108b787020d56b9be93dbbf083bf2324d42cde80f3a19/wrapt-2.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f49027b0b9503bf6c8cdc297ca55006b80c2f5dd36cecc72c6835ab6e10e8a25", size = 113361 }, + { url = "https://files.pythonhosted.org/packages/a1/f3/de535ccecede6960e28c7b722e5744846258111d6c9f071aa7578ea37ad3/wrapt-2.0.1-cp310-cp310-win32.whl", hash = "sha256:8330b42d769965e96e01fa14034b28a2a7600fbf7e8f0cc90ebb36d492c993e4", size = 58035 }, + { url = "https://files.pythonhosted.org/packages/21/15/39d3ca5428a70032c2ec8b1f1c9d24c32e497e7ed81aed887a4998905fcc/wrapt-2.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:1218573502a8235bb8a7ecaed12736213b22dcde9feab115fa2989d42b5ded45", size = 60383 }, + { url = "https://files.pythonhosted.org/packages/43/c2/dfd23754b7f7a4dce07e08f4309c4e10a40046a83e9ae1800f2e6b18d7c1/wrapt-2.0.1-cp310-cp310-win_arm64.whl", hash = "sha256:eda8e4ecd662d48c28bb86be9e837c13e45c58b8300e43ba3c9b4fa9900302f7", size = 58894 }, + { url = "https://files.pythonhosted.org/packages/98/60/553997acf3939079dab022e37b67b1904b5b0cc235503226898ba573b10c/wrapt-2.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0e17283f533a0d24d6e5429a7d11f250a58d28b4ae5186f8f47853e3e70d2590", size = 77480 }, + { url = "https://files.pythonhosted.org/packages/2d/50/e5b3d30895d77c52105c6d5cbf94d5b38e2a3dd4a53d22d246670da98f7c/wrapt-2.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:85df8d92158cb8f3965aecc27cf821461bb5f40b450b03facc5d9f0d4d6ddec6", size = 60690 }, + { url = "https://files.pythonhosted.org/packages/f0/40/660b2898703e5cbbb43db10cdefcc294274458c3ca4c68637c2b99371507/wrapt-2.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c1be685ac7700c966b8610ccc63c3187a72e33cab53526a27b2a285a662cd4f7", size = 61578 }, + { url = "https://files.pythonhosted.org/packages/5b/36/825b44c8a10556957bc0c1d84c7b29a40e05fcf1873b6c40aa9dbe0bd972/wrapt-2.0.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:df0b6d3b95932809c5b3fecc18fda0f1e07452d05e2662a0b35548985f256e28", size = 114115 }, + { url = "https://files.pythonhosted.org/packages/83/73/0a5d14bb1599677304d3c613a55457d34c344e9b60eda8a737c2ead7619e/wrapt-2.0.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4da7384b0e5d4cae05c97cd6f94faaf78cc8b0f791fc63af43436d98c4ab37bb", size = 116157 }, + { url = "https://files.pythonhosted.org/packages/01/22/1c158fe763dbf0a119f985d945711d288994fe5514c0646ebe0eb18b016d/wrapt-2.0.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ec65a78fbd9d6f083a15d7613b2800d5663dbb6bb96003899c834beaa68b242c", size = 112535 }, + { url = "https://files.pythonhosted.org/packages/5c/28/4f16861af67d6de4eae9927799b559c20ebdd4fe432e89ea7fe6fcd9d709/wrapt-2.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7de3cc939be0e1174969f943f3b44e0d79b6f9a82198133a5b7fc6cc92882f16", size = 115404 }, + { url = "https://files.pythonhosted.org/packages/a0/8b/7960122e625fad908f189b59c4aae2d50916eb4098b0fb2819c5a177414f/wrapt-2.0.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:fb1a5b72cbd751813adc02ef01ada0b0d05d3dcbc32976ce189a1279d80ad4a2", size = 111802 }, + { url = "https://files.pythonhosted.org/packages/3e/73/7881eee5ac31132a713ab19a22c9e5f1f7365c8b1df50abba5d45b781312/wrapt-2.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3fa272ca34332581e00bf7773e993d4f632594eb2d1b0b162a9038df0fd971dd", size = 113837 }, + { url = "https://files.pythonhosted.org/packages/45/00/9499a3d14e636d1f7089339f96c4409bbc7544d0889f12264efa25502ae8/wrapt-2.0.1-cp311-cp311-win32.whl", hash = "sha256:fc007fdf480c77301ab1afdbb6ab22a5deee8885f3b1ed7afcb7e5e84a0e27be", size = 58028 }, + { url = "https://files.pythonhosted.org/packages/70/5d/8f3d7eea52f22638748f74b102e38fdf88cb57d08ddeb7827c476a20b01b/wrapt-2.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:47434236c396d04875180171ee1f3815ca1eada05e24a1ee99546320d54d1d1b", size = 60385 }, + { url = "https://files.pythonhosted.org/packages/14/e2/32195e57a8209003587bbbad44d5922f13e0ced2a493bb46ca882c5b123d/wrapt-2.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:837e31620e06b16030b1d126ed78e9383815cbac914693f54926d816d35d8edf", size = 58893 }, + { url = "https://files.pythonhosted.org/packages/cb/73/8cb252858dc8254baa0ce58ce382858e3a1cf616acebc497cb13374c95c6/wrapt-2.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1fdbb34da15450f2b1d735a0e969c24bdb8d8924892380126e2a293d9902078c", size = 78129 }, + { url = "https://files.pythonhosted.org/packages/19/42/44a0db2108526ee6e17a5ab72478061158f34b08b793df251d9fbb9a7eb4/wrapt-2.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3d32794fe940b7000f0519904e247f902f0149edbe6316c710a8562fb6738841", size = 61205 }, + { url = "https://files.pythonhosted.org/packages/4d/8a/5b4b1e44b791c22046e90d9b175f9a7581a8cc7a0debbb930f81e6ae8e25/wrapt-2.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:386fb54d9cd903ee0012c09291336469eb7b244f7183d40dc3e86a16a4bace62", size = 61692 }, + { url = "https://files.pythonhosted.org/packages/11/53/3e794346c39f462bcf1f58ac0487ff9bdad02f9b6d5ee2dc84c72e0243b2/wrapt-2.0.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7b219cb2182f230676308cdcacd428fa837987b89e4b7c5c9025088b8a6c9faf", size = 121492 }, + { url = "https://files.pythonhosted.org/packages/c6/7e/10b7b0e8841e684c8ca76b462a9091c45d62e8f2de9c4b1390b690eadf16/wrapt-2.0.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:641e94e789b5f6b4822bb8d8ebbdfc10f4e4eae7756d648b717d980f657a9eb9", size = 123064 }, + { url = "https://files.pythonhosted.org/packages/0e/d1/3c1e4321fc2f5ee7fd866b2d822aa89b84495f28676fd976c47327c5b6aa/wrapt-2.0.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe21b118b9f58859b5ebaa4b130dee18669df4bd111daad082b7beb8799ad16b", size = 117403 }, + { url = "https://files.pythonhosted.org/packages/a4/b0/d2f0a413cf201c8c2466de08414a15420a25aa83f53e647b7255cc2fab5d/wrapt-2.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:17fb85fa4abc26a5184d93b3efd2dcc14deb4b09edcdb3535a536ad34f0b4dba", size = 121500 }, + { url = "https://files.pythonhosted.org/packages/bd/45/bddb11d28ca39970a41ed48a26d210505120f925918592283369219f83cc/wrapt-2.0.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b89ef9223d665ab255ae42cc282d27d69704d94be0deffc8b9d919179a609684", size = 116299 }, + { url = "https://files.pythonhosted.org/packages/81/af/34ba6dd570ef7a534e7eec0c25e2615c355602c52aba59413411c025a0cb/wrapt-2.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a453257f19c31b31ba593c30d997d6e5be39e3b5ad9148c2af5a7314061c63eb", size = 120622 }, + { url = "https://files.pythonhosted.org/packages/e2/3e/693a13b4146646fb03254636f8bafd20c621955d27d65b15de07ab886187/wrapt-2.0.1-cp312-cp312-win32.whl", hash = "sha256:3e271346f01e9c8b1130a6a3b0e11908049fe5be2d365a5f402778049147e7e9", size = 58246 }, + { url = "https://files.pythonhosted.org/packages/a7/36/715ec5076f925a6be95f37917b66ebbeaa1372d1862c2ccd7a751574b068/wrapt-2.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:2da620b31a90cdefa9cd0c2b661882329e2e19d1d7b9b920189956b76c564d75", size = 60492 }, + { url = "https://files.pythonhosted.org/packages/ef/3e/62451cd7d80f65cc125f2b426b25fbb6c514bf6f7011a0c3904fc8c8df90/wrapt-2.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:aea9c7224c302bc8bfc892b908537f56c430802560e827b75ecbde81b604598b", size = 58987 }, + { url = "https://files.pythonhosted.org/packages/ad/fe/41af4c46b5e498c90fc87981ab2972fbd9f0bccda597adb99d3d3441b94b/wrapt-2.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:47b0f8bafe90f7736151f61482c583c86b0693d80f075a58701dd1549b0010a9", size = 78132 }, + { url = "https://files.pythonhosted.org/packages/1c/92/d68895a984a5ebbbfb175512b0c0aad872354a4a2484fbd5552e9f275316/wrapt-2.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cbeb0971e13b4bd81d34169ed57a6dda017328d1a22b62fda45e1d21dd06148f", size = 61211 }, + { url = "https://files.pythonhosted.org/packages/e8/26/ba83dc5ae7cf5aa2b02364a3d9cf74374b86169906a1f3ade9a2d03cf21c/wrapt-2.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb7cffe572ad0a141a7886a1d2efa5bef0bf7fe021deeea76b3ab334d2c38218", size = 61689 }, + { url = "https://files.pythonhosted.org/packages/cf/67/d7a7c276d874e5d26738c22444d466a3a64ed541f6ef35f740dbd865bab4/wrapt-2.0.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c8d60527d1ecfc131426b10d93ab5d53e08a09c5fa0175f6b21b3252080c70a9", size = 121502 }, + { url = "https://files.pythonhosted.org/packages/0f/6b/806dbf6dd9579556aab22fc92908a876636e250f063f71548a8660382184/wrapt-2.0.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c654eafb01afac55246053d67a4b9a984a3567c3808bb7df2f8de1c1caba2e1c", size = 123110 }, + { url = "https://files.pythonhosted.org/packages/e5/08/cdbb965fbe4c02c5233d185d070cabed2ecc1f1e47662854f95d77613f57/wrapt-2.0.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:98d873ed6c8b4ee2418f7afce666751854d6d03e3c0ec2a399bb039cd2ae89db", size = 117434 }, + { url = "https://files.pythonhosted.org/packages/2d/d1/6aae2ce39db4cb5216302fa2e9577ad74424dfbe315bd6669725569e048c/wrapt-2.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9e850f5b7fc67af856ff054c71690d54fa940c3ef74209ad9f935b4f66a0233", size = 121533 }, + { url = "https://files.pythonhosted.org/packages/79/35/565abf57559fbe0a9155c29879ff43ce8bd28d2ca61033a3a3dd67b70794/wrapt-2.0.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e505629359cb5f751e16e30cf3f91a1d3ddb4552480c205947da415d597f7ac2", size = 116324 }, + { url = "https://files.pythonhosted.org/packages/e1/e0/53ff5e76587822ee33e560ad55876d858e384158272cd9947abdd4ad42ca/wrapt-2.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2879af909312d0baf35f08edeea918ee3af7ab57c37fe47cb6a373c9f2749c7b", size = 120627 }, + { url = "https://files.pythonhosted.org/packages/7c/7b/38df30fd629fbd7612c407643c63e80e1c60bcc982e30ceeae163a9800e7/wrapt-2.0.1-cp313-cp313-win32.whl", hash = "sha256:d67956c676be5a24102c7407a71f4126d30de2a569a1c7871c9f3cabc94225d7", size = 58252 }, + { url = "https://files.pythonhosted.org/packages/85/64/d3954e836ea67c4d3ad5285e5c8fd9d362fd0a189a2db622df457b0f4f6a/wrapt-2.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9ca66b38dd642bf90c59b6738af8070747b610115a39af2498535f62b5cdc1c3", size = 60500 }, + { url = "https://files.pythonhosted.org/packages/89/4e/3c8b99ac93527cfab7f116089db120fef16aac96e5f6cdb724ddf286086d/wrapt-2.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:5a4939eae35db6b6cec8e7aa0e833dcca0acad8231672c26c2a9ab7a0f8ac9c8", size = 58993 }, + { url = "https://files.pythonhosted.org/packages/f9/f4/eff2b7d711cae20d220780b9300faa05558660afb93f2ff5db61fe725b9a/wrapt-2.0.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a52f93d95c8d38fed0669da2ebdb0b0376e895d84596a976c15a9eb45e3eccb3", size = 82028 }, + { url = "https://files.pythonhosted.org/packages/0c/67/cb945563f66fd0f61a999339460d950f4735c69f18f0a87ca586319b1778/wrapt-2.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4e54bbf554ee29fcceee24fa41c4d091398b911da6e7f5d7bffda963c9aed2e1", size = 62949 }, + { url = "https://files.pythonhosted.org/packages/ec/ca/f63e177f0bbe1e5cf5e8d9b74a286537cd709724384ff20860f8f6065904/wrapt-2.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:908f8c6c71557f4deaa280f55d0728c3bca0960e8c3dd5ceeeafb3c19942719d", size = 63681 }, + { url = "https://files.pythonhosted.org/packages/39/a1/1b88fcd21fd835dca48b556daef750952e917a2794fa20c025489e2e1f0f/wrapt-2.0.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e2f84e9af2060e3904a32cea9bb6db23ce3f91cfd90c6b426757cf7cc01c45c7", size = 152696 }, + { url = "https://files.pythonhosted.org/packages/62/1c/d9185500c1960d9f5f77b9c0b890b7fc62282b53af7ad1b6bd779157f714/wrapt-2.0.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3612dc06b436968dfb9142c62e5dfa9eb5924f91120b3c8ff501ad878f90eb3", size = 158859 }, + { url = "https://files.pythonhosted.org/packages/91/60/5d796ed0f481ec003220c7878a1d6894652efe089853a208ea0838c13086/wrapt-2.0.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d2d947d266d99a1477cd005b23cbd09465276e302515e122df56bb9511aca1b", size = 146068 }, + { url = "https://files.pythonhosted.org/packages/04/f8/75282dd72f102ddbfba137e1e15ecba47b40acff32c08ae97edbf53f469e/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:7d539241e87b650cbc4c3ac9f32c8d1ac8a54e510f6dca3f6ab60dcfd48c9b10", size = 155724 }, + { url = "https://files.pythonhosted.org/packages/5a/27/fe39c51d1b344caebb4a6a9372157bdb8d25b194b3561b52c8ffc40ac7d1/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:4811e15d88ee62dbf5c77f2c3ff3932b1e3ac92323ba3912f51fc4016ce81ecf", size = 144413 }, + { url = "https://files.pythonhosted.org/packages/83/2b/9f6b643fe39d4505c7bf926d7c2595b7cb4b607c8c6b500e56c6b36ac238/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c1c91405fcf1d501fa5d55df21e58ea49e6b879ae829f1039faaf7e5e509b41e", size = 150325 }, + { url = "https://files.pythonhosted.org/packages/bb/b6/20ffcf2558596a7f58a2e69c89597128781f0b88e124bf5a4cadc05b8139/wrapt-2.0.1-cp313-cp313t-win32.whl", hash = "sha256:e76e3f91f864e89db8b8d2a8311d57df93f01ad6bb1e9b9976d1f2e83e18315c", size = 59943 }, + { url = "https://files.pythonhosted.org/packages/87/6a/0e56111cbb3320151eed5d3821ee1373be13e05b376ea0870711f18810c3/wrapt-2.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:83ce30937f0ba0d28818807b303a412440c4b63e39d3d8fc036a94764b728c92", size = 63240 }, + { url = "https://files.pythonhosted.org/packages/1d/54/5ab4c53ea1f7f7e5c3e7c1095db92932cc32fd62359d285486d00c2884c3/wrapt-2.0.1-cp313-cp313t-win_arm64.whl", hash = "sha256:4b55cacc57e1dc2d0991dbe74c6419ffd415fb66474a02335cb10efd1aa3f84f", size = 60416 }, + { url = "https://files.pythonhosted.org/packages/73/81/d08d83c102709258e7730d3cd25befd114c60e43ef3891d7e6877971c514/wrapt-2.0.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:5e53b428f65ece6d9dad23cb87e64506392b720a0b45076c05354d27a13351a1", size = 78290 }, + { url = "https://files.pythonhosted.org/packages/f6/14/393afba2abb65677f313aa680ff0981e829626fed39b6a7e3ec807487790/wrapt-2.0.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ad3ee9d0f254851c71780966eb417ef8e72117155cff04821ab9b60549694a55", size = 61255 }, + { url = "https://files.pythonhosted.org/packages/c4/10/a4a1f2fba205a9462e36e708ba37e5ac95f4987a0f1f8fd23f0bf1fc3b0f/wrapt-2.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7b822c61ed04ee6ad64bc90d13368ad6eb094db54883b5dde2182f67a7f22c0", size = 61797 }, + { url = "https://files.pythonhosted.org/packages/12/db/99ba5c37cf1c4fad35349174f1e38bd8d992340afc1ff27f526729b98986/wrapt-2.0.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7164a55f5e83a9a0b031d3ffab4d4e36bbec42e7025db560f225489fa929e509", size = 120470 }, + { url = "https://files.pythonhosted.org/packages/30/3f/a1c8d2411eb826d695fc3395a431757331582907a0ec59afce8fe8712473/wrapt-2.0.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e60690ba71a57424c8d9ff28f8d006b7ad7772c22a4af432188572cd7fa004a1", size = 122851 }, + { url = "https://files.pythonhosted.org/packages/b3/8d/72c74a63f201768d6a04a8845c7976f86be6f5ff4d74996c272cefc8dafc/wrapt-2.0.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3cd1a4bd9a7a619922a8557e1318232e7269b5fb69d4ba97b04d20450a6bf970", size = 117433 }, + { url = "https://files.pythonhosted.org/packages/c7/5a/df37cf4042cb13b08256f8e27023e2f9b3d471d553376616591bb99bcb31/wrapt-2.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b4c2e3d777e38e913b8ce3a6257af72fb608f86a1df471cb1d4339755d0a807c", size = 121280 }, + { url = "https://files.pythonhosted.org/packages/54/34/40d6bc89349f9931e1186ceb3e5fbd61d307fef814f09fbbac98ada6a0c8/wrapt-2.0.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3d366aa598d69416b5afedf1faa539fac40c1d80a42f6b236c88c73a3c8f2d41", size = 116343 }, + { url = "https://files.pythonhosted.org/packages/70/66/81c3461adece09d20781dee17c2366fdf0cb8754738b521d221ca056d596/wrapt-2.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c235095d6d090aa903f1db61f892fffb779c1eaeb2a50e566b52001f7a0f66ed", size = 119650 }, + { url = "https://files.pythonhosted.org/packages/46/3a/d0146db8be8761a9e388cc9cc1c312b36d583950ec91696f19bbbb44af5a/wrapt-2.0.1-cp314-cp314-win32.whl", hash = "sha256:bfb5539005259f8127ea9c885bdc231978c06b7a980e63a8a61c8c4c979719d0", size = 58701 }, + { url = "https://files.pythonhosted.org/packages/1a/38/5359da9af7d64554be63e9046164bd4d8ff289a2dd365677d25ba3342c08/wrapt-2.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:4ae879acc449caa9ed43fc36ba08392b9412ee67941748d31d94e3cedb36628c", size = 60947 }, + { url = "https://files.pythonhosted.org/packages/aa/3f/96db0619276a833842bf36343685fa04f987dd6e3037f314531a1e00492b/wrapt-2.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:8639b843c9efd84675f1e100ed9e99538ebea7297b62c4b45a7042edb84db03e", size = 59359 }, + { url = "https://files.pythonhosted.org/packages/71/49/5f5d1e867bf2064bf3933bc6cf36ade23505f3902390e175e392173d36a2/wrapt-2.0.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:9219a1d946a9b32bb23ccae66bdb61e35c62773ce7ca6509ceea70f344656b7b", size = 82031 }, + { url = "https://files.pythonhosted.org/packages/2b/89/0009a218d88db66ceb83921e5685e820e2c61b59bbbb1324ba65342668bc/wrapt-2.0.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fa4184e74197af3adad3c889a1af95b53bb0466bced92ea99a0c014e48323eec", size = 62952 }, + { url = "https://files.pythonhosted.org/packages/ae/18/9b968e920dd05d6e44bcc918a046d02afea0fb31b2f1c80ee4020f377cbe/wrapt-2.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c5ef2f2b8a53b7caee2f797ef166a390fef73979b15778a4a153e4b5fedce8fa", size = 63688 }, + { url = "https://files.pythonhosted.org/packages/a6/7d/78bdcb75826725885d9ea26c49a03071b10c4c92da93edda612910f150e4/wrapt-2.0.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e042d653a4745be832d5aa190ff80ee4f02c34b21f4b785745eceacd0907b815", size = 152706 }, + { url = "https://files.pythonhosted.org/packages/dd/77/cac1d46f47d32084a703df0d2d29d47e7eb2a7d19fa5cbca0e529ef57659/wrapt-2.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2afa23318136709c4b23d87d543b425c399887b4057936cd20386d5b1422b6fa", size = 158866 }, + { url = "https://files.pythonhosted.org/packages/8a/11/b521406daa2421508903bf8d5e8b929216ec2af04839db31c0a2c525eee0/wrapt-2.0.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c72328f668cf4c503ffcf9434c2b71fdd624345ced7941bc6693e61bbe36bef", size = 146148 }, + { url = "https://files.pythonhosted.org/packages/0c/c0/340b272bed297baa7c9ce0c98ef7017d9c035a17a6a71dce3184b8382da2/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3793ac154afb0e5b45d1233cb94d354ef7a983708cc3bb12563853b1d8d53747", size = 155737 }, + { url = "https://files.pythonhosted.org/packages/f3/93/bfcb1fb2bdf186e9c2883a4d1ab45ab099c79cbf8f4e70ea453811fa3ea7/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fec0d993ecba3991645b4857837277469c8cc4c554a7e24d064d1ca291cfb81f", size = 144451 }, + { url = "https://files.pythonhosted.org/packages/d2/6b/dca504fb18d971139d232652656180e3bd57120e1193d9a5899c3c0b7cdd/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:949520bccc1fa227274da7d03bf238be15389cd94e32e4297b92337df9b7a349", size = 150353 }, + { url = "https://files.pythonhosted.org/packages/1d/f6/a1de4bd3653afdf91d250ca5c721ee51195df2b61a4603d4b373aa804d1d/wrapt-2.0.1-cp314-cp314t-win32.whl", hash = "sha256:be9e84e91d6497ba62594158d3d31ec0486c60055c49179edc51ee43d095f79c", size = 60609 }, + { url = "https://files.pythonhosted.org/packages/01/3a/07cd60a9d26fe73efead61c7830af975dfdba8537632d410462672e4432b/wrapt-2.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:61c4956171c7434634401db448371277d07032a81cc21c599c22953374781395", size = 64038 }, + { url = "https://files.pythonhosted.org/packages/41/99/8a06b8e17dddbf321325ae4eb12465804120f699cd1b8a355718300c62da/wrapt-2.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:35cdbd478607036fee40273be8ed54a451f5f23121bd9d4be515158f9498f7ad", size = 60634 }, + { url = "https://files.pythonhosted.org/packages/15/d1/b51471c11592ff9c012bd3e2f7334a6ff2f42a7aed2caffcf0bdddc9cb89/wrapt-2.0.1-py3-none-any.whl", hash = "sha256:4d2ce1bf1a48c5277d7969259232b57645aae5686dba1eaeade39442277afbca", size = 44046 }, +]