diff --git a/README.md b/README.md index 44f3f6ea..fc52893b 100644 --- a/README.md +++ b/README.md @@ -283,6 +283,63 @@ Check if a variable is a grid_mapping variable by looking for references to it. Validate that a specific band exists and is complete in the dataset. +## Supported Products + +### Sentinel-2 MSI + +Sentinel-2 MSI (MultiSpectral Instrument) L1C and L2A products are detected +automatically by `eopf-geozarr convert` and routed to the optimized multiscale +layout (`convert-s2-optimized`). The three native resolution groups (10 m, 20 m, +60 m) are reused as-is and coarser overviews (120 m, 360 m, 720 m) are computed +via /2 downsampling. + +### Sentinel-3 OLCI L1 EFR + +Sentinel-3 OLCI (Ocean and Land Colour Instrument) Level-1 EFR (Full Resolution) +products are detected automatically by `eopf-geozarr convert` and routed to the +dedicated OLCI converter. Unlike Sentinel-2, OLCI data uses **native swath geometry**: +measurements are stored on a per-pixel 2-D lat/lon grid with no reprojection to a +projected CRS. The exporter preserves this curvilinear geometry intact. + +#### Auto-detection + +```bash +eopf-geozarr convert S3A_OL_1_EFR.zarr output.zarr +``` + +#### Dedicated command + +```bash +eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ + --spatial-chunk 1024 \ + --min-dimension 256 \ + --compression-level 3 +``` + +Key flags: + +- `--spatial-chunk` — target spatial chunk size in pixels (default: 1024) +- `--compression-level` — Blosc/zstd compression level 1–9 (default: 3) +- `--min-dimension` — stop generating /2 overview levels once either spatial + dimension would drop below this value (default: 256) +- `--enable-sharding` — accepted but not yet wired into encoding (follow-up task) +- `--keep-scale-offset` — accepted but not yet wired into encoding (follow-up task) + +#### What is converted + +- **`/measurements`**: all 21 OLCI radiance bands at native full resolution, with + GeoZarr `spatial:` convention metadata and per-pixel 2-D `latitude`/`longitude` + coordinate arrays. +- **Overview subgroups** (`r2`, `r4`, …): /2-decimated copies of the measurements + stored as sibling Zarr groups under `measurements/`. +- **`/conditions` and `/quality`**: copied through unmodified. + +> **Note:** OLCI support is initial/measurements-focused (v1). Tie-point grid +> groups (`conditions/geometry`, `meteorology`, `instrument`) are copied through but +> not converted to GeoZarr convention. Encoding wiring for `--enable-sharding`, +> `--spatial-chunk`, `--compression-level`, and `--keep-scale-offset` is accepted +> but scheduled as a follow-up task. + ## Architecture The library is organized into the following modules: diff --git a/docs/converter.md b/docs/converter.md index 898c251a..39697cb0 100644 --- a/docs/converter.md +++ b/docs/converter.md @@ -177,6 +177,63 @@ dt_optimized = convert_s2_optimized( The result is a space-efficient multiscale pyramid: `/measurements/reflectance/{r10m, r20m, r60m, r120m, r360m, r720m}` where the native resolutions are preserved as-is and only the coarser levels are computed. +## Sentinel-3 OLCI L1 EFR Conversion + +Sentinel-3 OLCI (Ocean and Land Colour Instrument) Level-1 EFR (Full Resolution) +products are supported. OLCI uses **native swath geometry**: measurements are stored +on a per-pixel 2-D lat/lon grid, with no reprojection to a projected CRS. The +exporter preserves this curvilinear geometry intact and generates /2-decimated +overview subgroups for multi-resolution access. + +### Auto-detection + +The generic `convert` command detects OLCI products automatically: + +```bash +eopf-geozarr convert S3A_OL_1_EFR.zarr output.zarr +``` + +### Dedicated command + +A dedicated command offers fine-grained control: + +```bash +eopf-geozarr convert-s3-olci-optimized S3A_OL_1_EFR.zarr output.zarr \ + --spatial-chunk 1024 \ + --min-dimension 256 \ + --compression-level 3 +``` + +| Flag | Default | Description | +|------|---------|-------------| +| `--spatial-chunk` | 1024 | Target spatial chunk size in pixels | +| `--compression-level` | 3 | Blosc/zstd compression level (1–9) | +| `--min-dimension` | 256 | Minimum spatial dimension for overview levels | +| `--enable-sharding` | off | Accepted but not yet wired into encoding (follow-up task) | +| `--keep-scale-offset` | off | Accepted but not yet wired into encoding (follow-up task) | + +### Output layout + +``` +output.zarr/ +├── measurements/ # Native-resolution OLCI bands (oa01_radiance … oa21_radiance) +│ │ # with per-pixel latitude/longitude coordinates +│ ├── r2/ # 1/2-resolution overview +│ ├── r4/ # 1/4-resolution overview +│ └── ... +├── conditions/ # Copied through unmodified (tie-point geometry, meteorology) +└── quality/ # Copied through unmodified (quality flags) +``` + +Each measurement group carries GeoZarr `spatial:` convention metadata and +references the per-pixel 2-D coordinate arrays `latitude` and `longitude`. + +> **Note:** OLCI support is initial/measurements-focused (v1). Tie-point grid +> groups in `conditions/geometry`, `meteorology`, and `instrument` are copied +> through but not converted to GeoZarr convention. Encoding wiring for +> `--enable-sharding`, `--spatial-chunk`, `--compression-level`, and +> `--keep-scale-offset` is accepted but scheduled as a follow-up task. + ## Error Handling The converter includes robust error handling and retry logic for network operations, ensuring reliable processing even in challenging environments. diff --git a/docs/notebooks/sentinel3_olci_geozarr.ipynb b/docs/notebooks/sentinel3_olci_geozarr.ipynb new file mode 100644 index 00000000..1ca7536b --- /dev/null +++ b/docs/notebooks/sentinel3_olci_geozarr.ipynb @@ -0,0 +1,664 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2888da1e", + "metadata": {}, + "source": [ + "# Sentinel-3 OLCI L1 EFR → GeoZarr\n", + "\n", + "This notebook demonstrates the Sentinel-3 OLCI exporter in `eopf-geozarr`:\n", + "\n", + "1. **Open** an EOPF Zarr Sentinel-3 OLCI L1 EFR product.\n", + "2. **Detect** that it is an OLCI product.\n", + "3. **Convert** it to a GeoZarr-compliant, multiscale Zarr store.\n", + "4. **Visualize** the multiscale pyramid by splitting one field of view into\n", + " four quadrants, each rendered from a *different* overview level.\n", + "\n", + "OLCI is delivered as a **curvilinear swath** (per-pixel 2-D latitude/longitude,\n", + "no projected CRS). The exporter preserves that native geometry — it does not\n", + "reproject — and builds overviews by fill-aware 2×2 block averaging of the\n", + "radiance bands (coordinates are decimated to keep real measured positions).\n", + "\n", + "> Requires the `notebooks` dependency group:\n", + "> `uv sync --group notebooks` (jupyter, matplotlib, nbformat)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "96531b64", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:23.118582Z", + "iopub.status.busy": "2026-06-23T10:17:23.118408Z", + "iopub.status.idle": "2026-06-23T10:17:24.799718Z", + "shell.execute_reply": "2026-06-23T10:17:24.799151Z" + } + }, + "outputs": [], + "source": [ + "import pathlib\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import xarray as xr\n", + "import zarr\n", + "\n", + "from eopf_geozarr.s3_olci_optimization.olci_converter import (\n", + " convert_olci_optimized,\n", + " is_sentinel3_olci_dataset,\n", + ")\n", + "from eopf_geozarr.conversion.geozarr import get_zarr_group" + ] + }, + { + "cell_type": "markdown", + "id": "cb881df9", + "metadata": {}, + "source": [ + "## 1. Open an EOPF OLCI product\n", + "\n", + "We open a real Sentinel-3 OLCI L1 EFR product from the EOPF sample store on\n", + "EODC. If the store is unreachable (offline / CI), we fall back to the small\n", + "structure-only test fixture shipped with the repository so the notebook still\n", + "runs end to end.\n", + "\n", + "EOPF radiance is stored as scaled `uint16`; we open with `mask_and_scale=False`\n", + "so the raw integers and their `scale_factor` / `_FillValue` are preserved for a\n", + "faithful conversion (the converter expects un-decoded input)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "baf81f90", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:24.802088Z", + "iopub.status.busy": "2026-06-23T10:17:24.801845Z", + "iopub.status.idle": "2026-06-23T10:17:25.546984Z", + "shell.execute_reply": "2026-06-23T10:17:25.546382Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opened remote EODC OLCI product.\n", + "Top-level groups: ['/', '/conditions', '/conditions/geometry', '/conditions/image', '/conditions/instrument', '/conditions/meteorology', '/conditions/orphans', '/measurements', '/measurements/orphans', '/quality', '/quality/orphans']\n" + ] + } + ], + "source": [ + "# A real OLCI L1 EFR product on the EODC EOPF sample store (use an _NT_,\n", + "# fully-consolidated product — _NR_ near-real-time copies may lack metadata).\n", + "EODC_OLCI_URL = (\n", + " \"https://objects.eodc.eu/e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu/\"\n", + " \"01/products/cpm_v262/\"\n", + " \"S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_\"\n", + " \"0179_132_149_2160_PS1_O_NT_004.zarr\"\n", + ")\n", + "\n", + "\n", + "def open_olci_input() -> xr.DataTree:\n", + " \"\"\"Open the remote OLCI product; fall back to the repo test fixture offline.\"\"\"\n", + " try:\n", + " dt = xr.open_datatree(\n", + " EODC_OLCI_URL, engine=\"zarr\", chunks={}, mask_and_scale=False\n", + " )\n", + " print(\"Opened remote EODC OLCI product.\")\n", + " return dt\n", + " except Exception as exc: # noqa: BLE001 - notebook offline fallback\n", + " print(f\"Remote open failed ({type(exc).__name__}); using bundled fixture.\")\n", + " from tests.conftest import create_group_from_json\n", + "\n", + " fixture = pathlib.Path(\n", + " \"tests/_test_data/s3_examples/\"\n", + " \"S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_\"\n", + " \"0179_132_149_2160_PS1_O_NT_004.json\"\n", + " )\n", + " store = create_group_from_json(fixture, pathlib.Path(tempfile.mkdtemp()))\n", + " return xr.open_datatree(store, engine=\"zarr\", mask_and_scale=False)\n", + "\n", + "\n", + "dt_input = open_olci_input()\n", + "print(\"Top-level groups:\", sorted(dt_input.groups))" + ] + }, + { + "cell_type": "markdown", + "id": "fd59eb10", + "metadata": {}, + "source": [ + "### Inspect the measurements group\n", + "\n", + "OLCI L1 EFR carries 21 radiance bands (`oa01_radiance` … `oa21_radiance`) on a\n", + "single full-resolution grid, geolocated by per-pixel 2-D `latitude` /\n", + "`longitude` coordinate arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3bab9194", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:25.548827Z", + "iopub.status.busy": "2026-06-23T10:17:25.548535Z", + "iopub.status.idle": "2026-06-23T10:17:25.552958Z", + "shell.execute_reply": "2026-06-23T10:17:25.552363Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21 radiance bands; e.g. ['oa01_radiance', 'oa02_radiance', 'oa03_radiance'] … oa21_radiance\n", + "oa01_radiance: (4090, 4865) uint16 | dims ('rows', 'columns')\n", + "scale_factor: 0.013946459628641605 | _FillValue: 65535\n", + "geolocation coords: ['latitude', 'longitude', 'altitude']\n" + ] + } + ], + "source": [ + "meas = dt_input[\"/measurements\"].to_dataset()\n", + "bands = [v for v in meas.data_vars if str(v).endswith(\"_radiance\")]\n", + "print(f\"{len(bands)} radiance bands; e.g. {bands[:3]} … {bands[-1]}\")\n", + "oa = meas[\"oa01_radiance\"]\n", + "print(\"oa01_radiance:\", oa.shape, oa.dtype, \"| dims\", oa.dims)\n", + "print(\"scale_factor:\", oa.attrs.get(\"scale_factor\"), \"| _FillValue:\", oa.attrs.get(\"_FillValue\"))\n", + "print(\"geolocation coords:\", [c for c in (\"latitude\", \"longitude\", \"altitude\") if c in meas])" + ] + }, + { + "cell_type": "markdown", + "id": "90b511c0", + "metadata": {}, + "source": [ + "## 2. Detect the product type\n", + "\n", + "Detection is structural: a product is OLCI iff it validates against the OLCI\n", + "data model and its measurements group contains the radiance bands." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "35c20e40", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:25.554630Z", + "iopub.status.busy": "2026-06-23T10:17:25.554431Z", + "iopub.status.idle": "2026-06-23T10:17:25.629450Z", + "shell.execute_reply": "2026-06-23T10:17:25.628795Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "is_sentinel3_olci_dataset: True\n" + ] + } + ], + "source": [ + "group = get_zarr_group(dt_input)\n", + "print(\"is_sentinel3_olci_dataset:\", is_sentinel3_olci_dataset(group))" + ] + }, + { + "cell_type": "markdown", + "id": "f2497b10", + "metadata": {}, + "source": [ + "## 3. Convert to GeoZarr\n", + "\n", + "`convert_olci_optimized` writes the native measurements group plus `/2`\n", + "block-averaged overview subgroups (`r2`, `r4`, …) down to `min_dimension`, and\n", + "declares them with the GeoZarr `multiscales` convention. `conditions` and\n", + "`quality` are copied through unchanged.\n", + "\n", + "We use a small `min_dimension` here so even the small sample yields several\n", + "overview levels to visualize." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "781d44e8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:17:25.631065Z", + "iopub.status.busy": "2026-06-23T10:17:25.630958Z", + "iopub.status.idle": "2026-06-23T10:18:59.861715Z", + "shell.execute_reply": "2026-06-23T10:18:59.861003Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:17:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting native-resolution measurements\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 4090, 'columns': 4865}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:17:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mGenerating overview levels \u001b[0m \u001b[36mn_levels\u001b[0m=\u001b[35m9\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:09\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r2\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 2045, 'columns': 2432}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:17\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r4\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 1022, 'columns': 1216}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:21\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r8\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 511, 'columns': 608}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:25\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r16\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 255, 'columns': 304}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:29\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r32\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 127, 'columns': 152}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:32\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r64\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 63, 'columns': 76}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:35\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r128\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 31, 'columns': 38}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:39\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r256\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 15, 'columns': 19}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:42\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mWriting overview \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/r512\u001b[0m \u001b[36mshape\u001b[0m=\u001b[35m{'rows': 7, 'columns': 9}\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/geometry\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:45\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/image\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/instrument\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:47\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/meteorology\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:48\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mconditions/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary group \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:49\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mquality/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying measurements subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2m2026-06-23 12:18:58\u001b[0m [\u001b[32m\u001b[1minfo \u001b[0m] \u001b[1mCopying ancillary subgroup \u001b[0m \u001b[36mgroup\u001b[0m=\u001b[35mmeasurements/orphans\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyramid levels (native + overviews): ['.', 'r2', 'r4', 'r8', 'r16', 'r32', 'r64', 'r128', 'r256', 'r512']\n" + ] + } + ], + "source": [ + "output_path = str(pathlib.Path(tempfile.mkdtemp()) / \"olci_geozarr.zarr\")\n", + "convert_olci_optimized(dt_input, output_path=output_path, min_dimension=4)\n", + "\n", + "store = zarr.open_group(output_path, mode=\"r\")\n", + "# Overview levels are the rN subgroups under measurements (exclude e.g. orphans).\n", + "levels = [\".\"] + sorted(\n", + " (k for k in store[\"measurements\"].group_keys() if k.startswith(\"r\")),\n", + " key=lambda k: int(k[1:]),\n", + ")\n", + "print(\"Pyramid levels (native + overviews):\", levels)" + ] + }, + { + "cell_type": "markdown", + "id": "1c5310cc", + "metadata": {}, + "source": [ + "### Load one band at every pyramid level\n", + "\n", + "Level `.` is the native resolution written at the measurements group root;\n", + "`r2`, `r4`, … are successively coarser block-averaged overviews. We read with\n", + "default decoding so the stored `uint16` radiance is scaled to physical units\n", + "for display." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3f654e2e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:18:59.864062Z", + "iopub.status.busy": "2026-06-23T10:18:59.863872Z", + "iopub.status.idle": "2026-06-23T10:19:00.100825Z", + "shell.execute_reply": "2026-06-23T10:19:00.100149Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " .: shape (4090, 4865)\n", + " r2: shape (2045, 2432)\n", + " r4: shape (1022, 1216)\n", + " r8: shape (511, 608)\n", + " r16: shape (255, 304)\n", + " r32: shape (127, 152)\n", + " r64: shape (63, 76)\n", + "r128: shape (31, 38)\n", + "r256: shape (15, 19)\n", + "r512: shape (7, 9)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_990047/66218547.py:6: RuntimeWarning: Failed to open Zarr store with consolidated metadata, but successfully read with non-consolidated metadata. This is typically much slower for opening a dataset. To silence this warning, consider:\n", + "1. Consolidating metadata in this existing store with zarr.consolidate_metadata().\n", + "2. Explicitly setting consolidated=False, to avoid trying to read consolidate metadata, or\n", + "3. Explicitly setting consolidated=True, to raise an error in this case instead of falling back to try reading non-consolidated metadata.\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n" + ] + } + ], + "source": [ + "BAND = \"oa08_radiance\" # ~665 nm (red); good visual contrast\n", + "\n", + "\n", + "def read_level(level: str) -> xr.DataArray:\n", + " group = \"measurements\" if level == \".\" else f\"measurements/{level}\"\n", + " ds = xr.open_dataset(output_path, engine=\"zarr\", group=group)\n", + " return ds[BAND]\n", + "\n", + "\n", + "level_arrays = {lvl: read_level(lvl) for lvl in levels}\n", + "for lvl, arr in level_arrays.items():\n", + " print(f\"{lvl:>4}: shape {tuple(arr.shape)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "95da72f9", + "metadata": {}, + "source": [ + "## 4. Multiscale quadrant visualization\n", + "\n", + "To show the pyramid in a single field of view, we split the native-resolution\n", + "image into four quadrants and fill each quadrant with data from a **different**\n", + "overview level. Each level's array is nearest-neighbour upsampled back to the\n", + "native quadrant size, so coarser levels render as visibly blockier — the\n", + "resolution drop is the point.\n", + "\n", + "Top-left = native, top-right = `r2`, bottom-left = `r4`, bottom-right = the\n", + "next coarser level available (clamped to the coarsest if fewer exist)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b40965eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-23T10:19:00.103316Z", + "iopub.status.busy": "2026-06-23T10:19:00.103038Z", + "iopub.status.idle": "2026-06-23T10:19:04.459494Z", + "shell.execute_reply": "2026-06-23T10:19:04.458850Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def to_native_grid(arr: xr.DataArray, ny: int, nx: int) -> np.ndarray:\n", + " \"\"\"Nearest-neighbour upsample a (rows, columns) array to (ny, nx).\"\"\"\n", + " a = np.asarray(arr.values, dtype=float)\n", + " row_idx = (np.arange(ny) * a.shape[0] // ny).clip(0, a.shape[0] - 1)\n", + " col_idx = (np.arange(nx) * a.shape[1] // nx).clip(0, a.shape[1] - 1)\n", + " return a[np.ix_(row_idx, col_idx)]\n", + "\n", + "\n", + "native = level_arrays[\".\"]\n", + "ny, nx = native.shape\n", + "hy, hx = ny // 2, nx // 2\n", + "\n", + "# Choose four levels (native + up to three coarser), clamped to what exists.\n", + "chosen = [levels[min(i, len(levels) - 1)] for i in range(4)]\n", + "\n", + "# Build a single canvas: each quadrant upsampled from its chosen level.\n", + "canvas = np.empty((ny, nx), dtype=float)\n", + "quadrants = {\n", + " (slice(0, hy), slice(0, hx)): chosen[0], # top-left\n", + " (slice(0, hy), slice(hx, nx)): chosen[1], # top-right\n", + " (slice(hy, ny), slice(0, hx)): chosen[2], # bottom-left\n", + " (slice(hy, ny), slice(hx, nx)): chosen[3], # bottom-right\n", + "}\n", + "for (rsl, csl), lvl in quadrants.items():\n", + " full = to_native_grid(level_arrays[lvl], ny, nx)\n", + " canvas[rsl, csl] = full[rsl, csl]\n", + "\n", + "fig, ax = plt.subplots(figsize=(7, 7))\n", + "im = ax.imshow(canvas, cmap=\"viridis\")\n", + "ax.axhline(hy - 0.5, color=\"white\", lw=1)\n", + "ax.axvline(hx - 0.5, color=\"white\", lw=1)\n", + "labels = {\n", + " (hx / 2, hy / 2): chosen[0],\n", + " (hx + hx / 2, hy / 2): chosen[1],\n", + " (hx / 2, hy + hy / 2): chosen[2],\n", + " (hx + hx / 2, hy + hy / 2): chosen[3],\n", + "}\n", + "for (x, y), lvl in labels.items():\n", + " res = 1 if lvl == \".\" else int(lvl[1:])\n", + " name = \"native (r1)\" if lvl == \".\" else lvl\n", + " ax.text(\n", + " x, y, f\"{name}\\n1/{res} res\", color=\"white\", ha=\"center\", va=\"center\",\n", + " fontweight=\"bold\", bbox={\"facecolor\": \"black\", \"alpha\": 0.4, \"pad\": 3},\n", + " )\n", + "ax.set_title(f\"OLCI {BAND}: one FOV, four pyramid levels\")\n", + "ax.set_xlabel(\"columns (across-track)\")\n", + "ax.set_ylabel(\"rows (along-track)\")\n", + "fig.colorbar(im, ax=ax, shrink=0.8, label=\"radiance (scaled)\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b4beef58", + "metadata": {}, + "source": [ + "Each quadrant covers the same ground area but is drawn from a coarser level as\n", + "you move down/right — the blockier quadrants are the lower-resolution overviews\n", + "from the multiscale pyramid, all produced by the single conversion above." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md b/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md new file mode 100644 index 00000000..664fb5ae --- /dev/null +++ b/docs/superpowers/plans/2026-06-21-sentinel3-olci-export.md @@ -0,0 +1,1170 @@ +# Sentinel-3 OLCI L1 EFR → GeoZarr Export Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a Sentinel-3 OLCI L1 EFR exporter that converts an EOPF OLCI product into a GeoZarr-compliant, multiscale Zarr store, preserving native swath geometry (per-pixel 2-D lat/lon, no reprojection). + +**Architecture:** Mirror the existing Sentinel-2 exporter: a self-contained `s3_olci_optimization/` package (band mapping, multiscale, converter), a `data_api/s3_olci.py` pydantic-zarr model for structural product detection, and CLI auto-detection plus a dedicated `convert-s3-olci-optimized` subcommand. Overviews are produced by /2 decimation of the swath grid (radiance bands and 2-D lat/lon/altitude coordinate arrays decimated together). + +**Tech Stack:** Python 3.12+, pydantic v2 + pydantic-zarr, zarr v3 (output) / zarr v2 (EOPF input), xarray (DataTree), zarr-cm conventions, pyright (type checker), ruff, pytest. + +Design doc: `docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md` + +## Global Constraints + +- Python ≥ 3.12; modern type hints (`|`, `list`, `dict`). +- **Never use `typing.Any`.** Use `object` + narrowing or precise types. (Existing `ArraySpec[Any]` in s2.py is pre-existing; do not copy `Any` into new code — use `ArraySpec[object]` or a precise attrs type.) +- Type checker is **pyright** (`uv run --frozen pyright`); 0 errors required. Lint/format is **ruff** (`uv run ruff check`, `uv run ruff format`). +- Build convention metadata via `zarr_cm` / `eopf_geozarr.conversion.utils.build_convention_attrs`; never hand-assemble `zarr_conventions`. +- Run tools with `uv run`. Tests: `uv run pytest`. +- Commit messages end with the project's `Co-Authored-By: Claude Opus 4.8 ` trailer. +- Pydantic model members: keep genuinely-optional keys `NotRequired`/`total=False`; never make variant keys Required (real products fail validation otherwise). Property accessors narrow with `.get()` + guard. + +--- + +## File Structure + +Create: +- `src/eopf_geozarr/s3_olci_optimization/__init__.py` — package marker. +- `src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py` — the 21 OLCI band names + per-band metadata; "all bands one resolution" config. +- `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` — swath /2 decimation pyramid + GeoZarr metadata. +- `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` — `convert_olci_optimized()` entry point + `is_sentinel3_olci_dataset()`. +- `src/eopf_geozarr/data_api/s3_olci.py` — `Sentinel3OlciRoot` pydantic-zarr model. +- `tests/test_data_api/test_s3_olci.py` — model + detection tests. +- `tests/test_olci_band_mapping.py` — band mapping tests. +- `tests/test_olci_multiscale.py` — decimation + metadata tests. +- `tests/test_olci_integration.py` — synthetic end-to-end + CLI e2e. +- `tests/_test_data/s3_examples/.json` — committed structure dump (Task 8). + +Modify: +- `src/eopf_geozarr/cli.py` — auto-detect OLCI in `convert_command`; add `convert-s3-olci-optimized` subcommand. +- `src/eopf_geozarr/s2_optimization/s2_converter.py` — extend the detection `TypeAdapter` union to include `Sentinel3OlciRoot` (or add a dedicated OLCI detector — see Task 4). +- `tests/conftest.py` — add `s3_olci_group_example` fixture + `s3_example_json_paths`. + +--- + +## Task 1: OLCI band mapping + +**Files:** +- Create: `src/eopf_geozarr/s3_olci_optimization/__init__.py` +- Create: `src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py` +- Test: `tests/test_olci_band_mapping.py` + +**Interfaces:** +- Produces: `OLCI_BANDS: tuple[str, ...]` (the 21 names `oa01_radiance`..`oa21_radiance`); `OlciBandInfo` dataclass (`name: str`, `data_type: str`, `wavelength_center: float`); `OLCI_BAND_INFO: dict[str, OlciBandInfo]`; `RADIANCE_DTYPE = "uint16"`. + +OLCI band central wavelengths (nm), Oa01–Oa21: +`400, 412.5, 442.5, 490, 510, 560, 620, 665, 673.75, 681.25, 708.75, 753.75, 761.25, 764.375, 767.5, 778.75, 865, 885, 900, 940, 1020`. + +- [ ] **Step 1: Write the failing test** + +```python +# test: skip +# tests/test_olci_band_mapping.py +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import ( + OLCI_BANDS, + OLCI_BAND_INFO, + OlciBandInfo, + RADIANCE_DTYPE, +) + + +def test_there_are_21_olci_bands() -> None: + assert len(OLCI_BANDS) == 21 + assert OLCI_BANDS[0] == "oa01_radiance" + assert OLCI_BANDS[-1] == "oa21_radiance" + + +def test_every_band_has_info() -> None: + assert set(OLCI_BAND_INFO) == set(OLCI_BANDS) + for name, info in OLCI_BAND_INFO.items(): + assert isinstance(info, OlciBandInfo) + assert info.name == name + assert info.data_type == RADIANCE_DTYPE + assert info.wavelength_center > 0 + + +def test_first_band_wavelength() -> None: + assert OLCI_BAND_INFO["oa01_radiance"].wavelength_center == 400.0 +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_band_mapping.py -v` +Expected: FAIL (ModuleNotFoundError: eopf_geozarr.s3_olci_optimization). + +- [ ] **Step 3: Create the package marker** + +```python +# src/eopf_geozarr/s3_olci_optimization/__init__.py +"""Sentinel-3 OLCI L1 EFR optimization (GeoZarr export).""" +``` + +- [ ] **Step 4: Implement the band mapping** + +```python +# src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py +"""Band definitions for Sentinel-3 OLCI L1 EFR. + +OLCI has 21 radiance bands (Oa01..Oa21), all delivered at the same full +resolution (~300 m) on a single swath grid. +""" + +from dataclasses import dataclass + +RADIANCE_DTYPE = "uint16" + +# Band index -> central wavelength in nm (OLCI Oa01..Oa21). +_WAVELENGTHS_NM: tuple[float, ...] = ( + 400.0, 412.5, 442.5, 490.0, 510.0, 560.0, 620.0, 665.0, 673.75, 681.25, + 708.75, 753.75, 761.25, 764.375, 767.5, 778.75, 865.0, 885.0, 900.0, + 940.0, 1020.0, +) + +OLCI_BANDS: tuple[str, ...] = tuple(f"oa{i:02d}_radiance" for i in range(1, 22)) + + +@dataclass(frozen=True) +class OlciBandInfo: + """Spectral characterization of a single OLCI radiance band.""" + + name: str + data_type: str + wavelength_center: float # nanometers + + +OLCI_BAND_INFO: dict[str, OlciBandInfo] = { + name: OlciBandInfo(name=name, data_type=RADIANCE_DTYPE, wavelength_center=wl) + for name, wl in zip(OLCI_BANDS, _WAVELENGTHS_NM, strict=True) +} +``` + +- [ ] **Step 5: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_band_mapping.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_band_mapping.py` +Expected: tests PASS; pyright 0 errors; ruff clean. + +- [ ] **Step 6: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_band_mapping.py +git commit -m "feat(s3-olci): add OLCI band mapping + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 2: Data API model + structural detection helper + +**Files:** +- Create: `src/eopf_geozarr/data_api/s3_olci.py` +- Test: `tests/test_data_api/test_s3_olci.py` + +**Interfaces:** +- Consumes: `OLCI_BANDS` (Task 1); `eopf_geozarr.pyz.v2.{ArraySpec, GroupSpec}`; `eopf_geozarr.data_api.geozarr.common.DatasetAttrs`. +- Produces: + - `Sentinel3OlciMeasurementsMembers` (TypedDict, closed, total=False): 21 `oaNN_radiance` + `latitude`/`longitude`/`altitude` + optional `orphans`. + - `Sentinel3OlciMeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers])`. + - `Sentinel3OlciRootMembers` (closed, total=False): `measurements` (required), `quality` (NotRequired), `conditions` (NotRequired). + - `Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers])` with `.measurements` accessor. + +Use `ArraySpec[object]` (NOT `ArraySpec[Any]`). `quality`/`conditions` members typed as `GroupSpec[object, object]` (we don't model their internals in v1). Detection is structural: a product is OLCI iff it validates as `Sentinel3OlciRoot` (i.e. has `measurements` with the radiance bands). + +- [ ] **Step 1: Write the failing test** + +```python +# tests/test_data_api/test_s3_olci.py +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec + + +def _olci_arr() -> dict[str, object]: + # minimal v2 ArraySpec-shaped dict for a 2-D uint16 array + return ArraySpec( + shape=(4, 5), chunks=(4, 5), dtype=" None: + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root = { + "zarr_format": 2, + "node_type": "group", + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, "node_type": "group", "attributes": {}, + "members": {**radiance, **coords}, + }, + }, + } + model = Sentinel3OlciRoot.model_validate(root) + assert "oa01_radiance" in model.measurements.members + + +def test_rejects_non_olci_product() -> None: + import pytest + from pydantic import ValidationError + + not_olci = { + "zarr_format": 2, "node_type": "group", + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": {"measurements": { + "zarr_format": 2, "node_type": "group", "attributes": {}, + "members": {"reflectance": { + "zarr_format": 2, "node_type": "group", "attributes": {}, "members": {}}}, + }}, + } + with pytest.raises(ValidationError): + Sentinel3OlciRoot.model_validate(not_olci) +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: FAIL (cannot import `Sentinel3OlciRoot`). + +- [ ] **Step 3: Implement the model** (follow `data_api/s2.py` patterns exactly) + +```python +# src/eopf_geozarr/data_api/s3_olci.py +"""Pydantic-zarr model for the Sentinel-3 OLCI L1 EFR EOPF Zarr structure. + +Mirrors data_api/s2.py: GroupSpec + closed TypedDict members. Used for +structural product detection (an EOPF product is OLCI iff it validates here). +""" + +from __future__ import annotations + +from pydantic import BaseModel +from typing_extensions import TypedDict + +from eopf_geozarr.data_api.geozarr.common import DatasetAttrs +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec + + +class Sentinel3OlciRootAttrs(BaseModel): + """Root-level attributes for an OLCI DataTree (not validated in detail).""" + + other_metadata: dict[str, object] + stac_discovery: dict[str, object] + + +class Sentinel3OlciMeasurementsMembers(TypedDict, closed=True, total=False): + """Members of the OLCI measurements group. + + The 21 radiance bands and the per-pixel geolocation coordinate arrays are + required in practice but typed optional so partial/variant products still + validate; the converter checks for the bands it needs. + """ + + latitude: ArraySpec[object] + longitude: ArraySpec[object] + altitude: ArraySpec[object] + orphans: GroupSpec[object, object] + oa01_radiance: ArraySpec[object] + oa02_radiance: ArraySpec[object] + oa03_radiance: ArraySpec[object] + oa04_radiance: ArraySpec[object] + oa05_radiance: ArraySpec[object] + oa06_radiance: ArraySpec[object] + oa07_radiance: ArraySpec[object] + oa08_radiance: ArraySpec[object] + oa09_radiance: ArraySpec[object] + oa10_radiance: ArraySpec[object] + oa11_radiance: ArraySpec[object] + oa12_radiance: ArraySpec[object] + oa13_radiance: ArraySpec[object] + oa14_radiance: ArraySpec[object] + oa15_radiance: ArraySpec[object] + oa16_radiance: ArraySpec[object] + oa17_radiance: ArraySpec[object] + oa18_radiance: ArraySpec[object] + oa19_radiance: ArraySpec[object] + oa20_radiance: ArraySpec[object] + oa21_radiance: ArraySpec[object] + + +class Sentinel3OlciMeasurementsGroup( + GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers] +): + """OLCI measurements group: 21 radiance bands + 2-D geolocation.""" + + +class Sentinel3OlciRootMembers(TypedDict, closed=True, total=False): + """Members of the OLCI root group.""" + + measurements: Sentinel3OlciMeasurementsGroup + quality: GroupSpec[object, object] + conditions: GroupSpec[object, object] + + +class Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers]): + """Complete Sentinel-3 OLCI L1 EFR EOPF Zarr hierarchy.""" + + @property + def measurements(self) -> Sentinel3OlciMeasurementsGroup: + group = self.members.get("measurements") + if group is None: + raise KeyError("measurements") + return group +``` + +NOTE: to make detection meaningful (Task 4), the `measurements` member must be +required for a product to count as OLCI. If `closed=True, total=False` lets an +empty product validate, change `Sentinel3OlciRootMembers` so `measurements` is +required (a separate `closed=True` TypedDict without `total=False` containing +only `measurements`, with `quality`/`conditions` in a `total=False` mixin) OR +add an explicit check in `is_sentinel3_olci_dataset` (Task 4) that +`oa01_radiance` is among `measurements.members`. Implement the explicit check in +Task 4 (simpler, and keeps the model permissive). Adjust the +`test_rejects_non_olci_product` test if needed so it asserts via the Task 4 +detector rather than model validation — but since model validation with +`closed=True` rejects the `reflectance` key under `measurements`, the test above +should pass as written. Run it and confirm. + +- [ ] **Step 4: Run tests** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: PASS. If `test_rejects_non_olci_product` does not raise (because the +permissive members allow it), move that assertion into Task 4's detector test +and keep only the positive test here. + +- [ ] **Step 5: Type + lint** + +Run: `uv run --frozen pyright src/eopf_geozarr/data_api/s3_olci.py && uv run ruff check src/eopf_geozarr/data_api/s3_olci.py tests/test_data_api/test_s3_olci.py` +Expected: pyright 0 errors; ruff clean. + +- [ ] **Step 6: Commit** + +```bash +git add src/eopf_geozarr/data_api/s3_olci.py tests/test_data_api/test_s3_olci.py +git commit -m "feat(s3-olci): add Sentinel3OlciRoot data-api model + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 3: Swath /2 decimation + +**Files:** +- Create: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` +- Test: `tests/test_olci_multiscale.py` + +**Interfaces:** +- Consumes: `xarray`, `numpy`. +- Produces: `decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset` — returns a dataset with every 2-D `(rows, columns)` variable AND the 2-D coordinate arrays (`latitude`/`longitude`/`altitude`) subsampled `[::factor, ::factor]`, preserving attrs/encoding and CF `coordinates` linkage. 1-D and non-(rows,columns) variables are passed through unchanged. + +Decimation (not averaging) is correct for v1: it keeps geolocation exact (an averaged lat/lon would no longer correspond to a real pixel). Radiance is decimated too for consistency with its coordinates. + +- [ ] **Step 1: Write the failing test** + +```python +# tests/test_olci_multiscale.py +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_multiscale import decimate_swath + + +def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: + rad = xr.DataArray( + np.arange(rows * cols, dtype="uint16").reshape(rows, cols), + dims=("rows", "columns"), + attrs={"scale_factor": 0.5, "units": "mW.m-2.sr-1.nm-1"}, + ) + lat = xr.DataArray( + np.linspace(0, 1, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), attrs={"standard_name": "latitude"}, + ) + lon = xr.DataArray( + np.linspace(10, 11, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), attrs={"standard_name": "longitude"}, + ) + return xr.Dataset( + {"oa01_radiance": rad}, + coords={"latitude": lat, "longitude": lon}, + ) + + +def test_decimate_halves_each_axis() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].shape == (4, 3) + assert out["latitude"].shape == (4, 3) + assert out["longitude"].shape == (4, 3) + + +def test_decimate_takes_every_other_pixel() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + # top-left pixel is preserved exactly (no averaging) + assert int(out["oa01_radiance"].values[0, 0]) == 0 + assert float(out["latitude"].values[0, 0]) == 0.0 + + +def test_decimate_preserves_attrs() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 + assert out["latitude"].attrs["standard_name"] == "latitude" +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_multiscale.py -v` +Expected: FAIL (cannot import `decimate_swath`). + +- [ ] **Step 3: Implement decimation** + +```python +# src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +"""Multiscale (overview) generation for OLCI swath data. + +OLCI L1 EFR is a curvilinear swath geolocated by per-pixel 2-D lat/lon arrays, +so overviews are produced by /2 decimation of the (rows, columns) grid: every +2-D variable and its 2-D coordinate arrays are subsampled together, keeping +geolocation exact. (Averaging is intentionally avoided — an averaged lat/lon +would not correspond to a real pixel.) +""" + +from __future__ import annotations + +import xarray as xr + +SWATH_DIMS = ("rows", "columns") + + +def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: + """Return *ds* with every (rows, columns) array subsampled by *factor*. + + Both data variables and coordinate variables that span exactly the swath + dims are decimated `[::factor, ::factor]`; everything else is passed + through unchanged. Attributes and encoding are preserved by xarray's isel. + """ + if factor < 1: + raise ValueError(f"factor must be >= 1, got {factor}") + if factor == 1: + return ds + indexers = { + dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in ds.sizes + } + if not indexers: + return ds + return ds.isel(indexers) +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_multiscale.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py +git commit -m "feat(s3-olci): add swath /2 decimation for overviews + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 4: Product detection (`is_sentinel3_olci_dataset`) + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` (create in this task) +- Test: `tests/test_data_api/test_s3_olci.py` (extend) + +**Interfaces:** +- Consumes: `Sentinel3OlciRoot` (Task 2); `OLCI_BANDS` (Task 1); `eopf_geozarr.pyz.v2.GroupSpec`; `zarr`. +- Produces: `is_sentinel3_olci_dataset(group: zarr.Group) -> bool` — True iff the group validates as `Sentinel3OlciRoot` AND `measurements` contains `oa01_radiance`. + +Pattern mirrors `is_sentinel2_dataset` in `s2_converter.py` (validate `GroupSpec.from_zarr(group).model_dump()`), but the extra `oa01_radiance` check makes detection robust given the permissive model. + +- [ ] **Step 1: Write the failing test (extend test_s3_olci.py)** + +```python +# append to tests/test_data_api/test_s3_olci.py +def test_detector_accepts_olci_zarr(tmp_path) -> None: + import zarr + from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + # build a minimal OLCI zarr v2 store from the model dict used above + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root_dict = { + "zarr_format": 2, "node_type": "group", + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": {"measurements": { + "zarr_format": 2, "node_type": "group", "attributes": {}, + "members": {**radiance, **coords}}}, + } + out = tmp_path / "olci.zarr" + PyzGroupSpec.model_validate(root_dict).to_zarr(out, path="") # type: ignore[arg-type] + group = zarr.open_group(str(out), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_detector_rejects_s2_zarr(s2_group_example) -> None: + import zarr + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + group = zarr.open_group(str(s2_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is False +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: FAIL (cannot import `is_sentinel3_olci_dataset`). + +- [ ] **Step 3: Implement the converter module with the detector** + +```python +# src/eopf_geozarr/s3_olci_optimization/olci_converter.py +"""Top-level Sentinel-3 OLCI L1 EFR -> GeoZarr conversion.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import structlog + +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot + +if TYPE_CHECKING: + import zarr + +log = structlog.get_logger() + + +def is_sentinel3_olci_dataset(group: "zarr.Group") -> bool: + """Return True if *group* is a Sentinel-3 OLCI L1 EFR product. + + Detection is structural: the group must validate against + ``Sentinel3OlciRoot`` and its ``measurements`` group must contain the + first OLCI radiance band. + """ + from eopf_geozarr.pyz.v2 import GroupSpec + + try: + model = Sentinel3OlciRoot.model_validate(GroupSpec.from_zarr(group).model_dump()) + except ValueError as e: + log.debug("Not an OLCI dataset", error=str(e)) + return False + return "oa01_radiance" in model.measurements.members +``` + +- [ ] **Step 4: Run tests** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v` +Expected: PASS (positive detect + S2 rejected). + +- [ ] **Step 5: Type + lint** + +Run: `uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_converter.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_data_api/test_s3_olci.py` +Expected: pyright 0; ruff clean. + +- [ ] **Step 6: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_data_api/test_s3_olci.py +git commit -m "feat(s3-olci): add OLCI product detection + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 5: GeoZarr metadata for a swath group + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py` +- Test: `tests/test_olci_multiscale.py` (extend) + +**Interfaces:** +- Consumes: `eopf_geozarr.conversion.utils.build_convention_attrs`, `zarr_cm` types. +- Produces: `swath_spatial_attrs(dims: tuple[str, str] = ("rows", "columns")) -> SpatialAttrs` — returns the `spatial:` convention data for curvilinear (no-transform) data: `spatial:dimensions = ["rows", "columns"]`, `spatial:registration = "pixel"`, and NO `spatial:transform`/`spatial:bbox` (geolocation lives in the 2-D lat/lon coordinate arrays, not an affine transform). + +This isolates the one genuinely OLCI-specific GeoZarr decision (open question in the spec) into a small, tested unit. `build_convention_attrs(spatial=..., crs=None)` is called with `crs=None` because OLCI L1 carries no projected CRS — geolocation is via coordinate arrays. Confirm `build_convention_attrs` accepts `crs=None` (it does: signature is `crs: CRSLike | None`). + +- [ ] **Step 1: Write the failing test** + +```python +# append to tests/test_olci_multiscale.py +from eopf_geozarr.s3_olci_optimization.olci_multiscale import swath_spatial_attrs + + +def test_swath_spatial_attrs_has_no_transform() -> None: + attrs = swath_spatial_attrs() + assert attrs["spatial:dimensions"] == ["rows", "columns"] + assert attrs["spatial:registration"] == "pixel" + assert "spatial:transform" not in attrs + assert "spatial:bbox" not in attrs +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_multiscale.py::test_swath_spatial_attrs_has_no_transform -v` +Expected: FAIL (cannot import `swath_spatial_attrs`). + +- [ ] **Step 3: Implement** + +```python +# add to src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from zarr_cm import SpatialAttrs + + +def swath_spatial_attrs( + dims: tuple[str, str] = SWATH_DIMS, +) -> "SpatialAttrs": + """Spatial-convention data for curvilinear swath geometry. + + OLCI has no affine transform; geolocation is carried by 2-D lat/lon + coordinate arrays, so we declare the spatial dimensions and pixel + registration but no ``spatial:transform``/``spatial:bbox``. + """ + return { + "spatial:dimensions": [dims[0], dims[1]], + "spatial:registration": "pixel", + } +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_multiscale.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py && uv run ruff check src/eopf_geozarr/s3_olci_optimization/` +Expected: PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py tests/test_olci_multiscale.py +git commit -m "feat(s3-olci): swath spatial-convention attrs (no transform) + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 6: `convert_olci_optimized` entry point + +**Files:** +- Modify: `src/eopf_geozarr/s3_olci_optimization/olci_converter.py` +- Test: `tests/test_olci_integration.py` + +**Interfaces:** +- Consumes: `decimate_swath`, `swath_spatial_attrs` (Tasks 3/5); `OLCI_BANDS` (Task 1); `build_convention_attrs`; `xarray`, `zarr`; storage/consolidation helpers from `conversion` (`fs_utils`, `geozarr`). +- Produces: + ```python + def convert_olci_optimized( + dt_input: xr.DataTree, + *, + output_path: str, + enable_sharding: bool = False, + spatial_chunk: int = 1024, + compression_level: int = 3, + min_dimension: int = 256, + keep_scale_offset: bool = False, + ) -> xr.DataTree: ... + ``` + Writes a GeoZarr store at `output_path`: the `measurements` group with native-resolution radiance + 2-D coords + GeoZarr convention metadata, plus `/2` decimated overview subgroups (`r1`, `r2`, `r4`, …) down to `min_dimension`; copies `conditions`/`quality` through unchanged. Returns the opened output DataTree. + +This is the orchestration task. Build it incrementally with a small synthetic OLCI DataTree (a helper in the test module, reused by Task 7). Keep the function focused; factor any growing helper (e.g. `_write_overviews`, `_copy_group`) into `olci_multiscale.py`. + +- [ ] **Step 1: Write the failing test (synthetic OLCI builder + end-to-end)** + +```python +# tests/test_olci_integration.py +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized + + +def build_synthetic_olci(rows: int = 512, cols: int = 480) -> xr.DataTree: + """Minimal synthetic OLCI L1 EFR datatree (measurements only).""" + rng = np.random.default_rng(0) + lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) + lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + alt = np.zeros((rows, cols), dtype="int16") + data = {} + for i in range(1, 22): + name = f"oa{i:02d}_radiance" + arr = xr.DataArray( + rng.integers(0, 6000, (rows, cols)).astype("uint16"), + dims=("rows", "columns"), + attrs={"scale_factor": 0.0139, "add_offset": 0.0, + "standard_name": "toa_upwelling_spectral_radiance", + "coordinates": "latitude longitude altitude"}, + ) + data[name] = arr + ds = xr.Dataset( + data, + coords={ + "latitude": (("rows", "columns"), lat, {"standard_name": "latitude"}), + "longitude": (("rows", "columns"), lon, {"standard_name": "longitude"}), + "altitude": (("rows", "columns"), alt, {"standard_name": "altitude"}), + }, + ) + return xr.DataTree.from_dict({"/measurements": ds}) + + +def test_convert_olci_writes_measurements(tmp_path) -> None: + dt = build_synthetic_olci() + out = str(tmp_path / "olci_geozarr.zarr") + convert_olci_optimized(dt, output_path=out) + + import zarr + g = zarr.open_group(out, mode="r") + # native measurements present + assert "measurements" in g + # all 21 bands at native res + meas = g["measurements"] + for i in range(1, 22): + assert f"oa{i:02d}_radiance" in meas + + +def test_convert_olci_creates_overviews(tmp_path) -> None: + dt = build_synthetic_olci(rows=512, cols=480) + out = str(tmp_path / "olci_geozarr.zarr") + convert_olci_optimized(dt, output_path=out, min_dimension=256) + import zarr + g = zarr.open_group(out, mode="r") + # at least one decimated overview level exists under measurements + meas = g["measurements"] + subgroups = [k for k in meas.group_keys()] + assert len(subgroups) >= 1 +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_integration.py -v` +Expected: FAIL (convert_olci_optimized not implemented / missing behavior). + +- [ ] **Step 3: Implement `convert_olci_optimized`** (incrementally; minimal to pass) + +Implementation outline (write real code — this is the skeleton to flesh out against the tests; mirror `s2_multiscale.create_multiscale_from_datatree` for writing groups, encoding, and `build_convention_attrs` usage): + +```python +# add to src/eopf_geozarr/s3_olci_optimization/olci_converter.py +import xarray as xr + +from eopf_geozarr.conversion.utils import build_convention_attrs +from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( + decimate_swath, + swath_spatial_attrs, +) + + +def _overview_levels(rows: int, cols: int, min_dimension: int) -> int: + """Number of /2 decimations until min(rows, cols) would drop below min_dimension.""" + levels = 0 + r, c = rows, cols + while min(r, c) // 2 >= min_dimension: + r, c = r // 2, c // 2 + levels += 1 + return levels + + +def convert_olci_optimized( + dt_input: xr.DataTree, + *, + output_path: str, + enable_sharding: bool = False, + spatial_chunk: int = 1024, + compression_level: int = 3, + min_dimension: int = 256, + keep_scale_offset: bool = False, +) -> xr.DataTree: + """Convert an EOPF OLCI L1 EFR product to a GeoZarr multiscale store.""" + measurements = dt_input["/measurements"].to_dataset() + + # Attach GeoZarr convention metadata for native-resolution swath data. + conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) + measurements.attrs.update(dict(conv)) + + # Write native resolution. + measurements.to_zarr( + output_path, group="measurements", mode="w", + consolidated=False, zarr_format=3, + ) + + # Write /2 decimated overviews as subgroups r2, r4, ... + rows = measurements.sizes["rows"] + cols = measurements.sizes["columns"] + current = measurements + for level in range(1, _overview_levels(rows, cols, min_dimension) + 1): + current = decimate_swath(current, factor=2) + current.to_zarr( + output_path, group=f"measurements/r{2 ** level}", mode="a", + consolidated=False, zarr_format=3, + ) + + # Copy conditions/quality through unchanged (if present). + for grp in ("conditions", "quality"): + try: + node = dt_input[f"/{grp}"] + except KeyError: + continue + node.to_zarr(output_path, group=grp, mode="a", consolidated=False, zarr_format=3) + + return xr.open_datatree(output_path, engine="zarr", chunks={}) +``` + +NOTE: this skeleton uses xarray's `to_zarr` for simplicity. If the project's +chunk-alignment / encoding helpers (`conversion.utils`, +`s2_multiscale` encoding handling) are needed to match GeoZarr output +conventions (chunking, sharding, scale-offset), adopt them here the way +`s2_multiscale` does. Keep `keep_scale_offset`/`enable_sharding`/`spatial_chunk`/ +`compression_level` honored (wire into encoding); if a parameter is not yet used +by the minimal pass, leave a typed parameter and a follow-up note rather than +silently ignoring — but prefer wiring encoding via the existing helpers. + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_integration.py -v && uv run --frozen pyright src/eopf_geozarr/s3_olci_optimization/ && uv run ruff check src/eopf_geozarr/s3_olci_optimization/ tests/test_olci_integration.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/s3_olci_optimization/olci_converter.py tests/test_olci_integration.py +git commit -m "feat(s3-olci): add convert_olci_optimized entry point + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 7: CLI integration (auto-detect + `convert-s3-olci-optimized`) + +**Files:** +- Modify: `src/eopf_geozarr/cli.py` +- Modify: `src/eopf_geozarr/s2_optimization/s2_converter.py` (only if you choose the union-adapter detection approach; otherwise no change — Task 4's standalone detector is used) +- Test: `tests/test_olci_integration.py` (extend with a CLI test) + +**Interfaces:** +- Consumes: `convert_olci_optimized`, `is_sentinel3_olci_dataset` (Tasks 4/6); `_is_sentinel2_input` pattern in `cli.py`. +- Produces: CLI behavior — `convert` auto-routes OLCI products to `convert_olci_optimized`; new `convert-s3-olci-optimized` subcommand. + +In `convert_command`, add OLCI detection BEFORE the generic path and AFTER S2 (so the order is S2 → OLCI → S1/generic), mirroring the `if _is_sentinel2_input(dt):` block. Add `_is_sentinel3_olci_input(dt)` wrapping `is_sentinel3_olci_dataset(get_zarr_group(dt))` (guard exceptions, like `_is_sentinel2_input`). Add `add_s3_olci_optimization_commands(subparsers)` mirroring `add_s2_optimization_commands` and call it next to `add_s2_optimization_commands(subparsers)`. + +- [ ] **Step 1: Write the failing CLI test** + +```python +# append to tests/test_olci_integration.py +import subprocess +import sys + + +def test_cli_convert_s3_olci_optimized(tmp_path) -> None: + # materialize a synthetic OLCI product to a zarr v2 store on disk + dt = build_synthetic_olci(rows=300, cols=300) + src = tmp_path / "olci_src.zarr" + dt.to_zarr(src, mode="w", consolidated=False) + out = tmp_path / "olci_out.zarr" + result = subprocess.run( + [sys.executable, "-m", "eopf_geozarr", "convert-s3-olci-optimized", + str(src), str(out), "--spatial-chunk", "256"], + capture_output=True, text=True, timeout=300, + ) + assert result.returncode == 0, result.stdout + result.stderr + import zarr + g = zarr.open_group(str(out), mode="r") + assert "measurements" in g +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `uv run pytest tests/test_olci_integration.py::test_cli_convert_s3_olci_optimized -v` +Expected: FAIL (unknown subcommand). + +- [ ] **Step 3: Add the CLI subcommand + auto-detect** + +In `cli.py`, near the top imports add: +```python +from eopf_geozarr.s3_olci_optimization.olci_converter import ( + convert_olci_optimized, + is_sentinel3_olci_dataset, +) +``` + +Add the input helper (mirror `_is_sentinel2_input`): +```python +def _is_sentinel3_olci_input(dt: xr.DataTree) -> bool: + try: + return is_sentinel3_olci_dataset(get_zarr_group(dt)) + except Exception: # noqa: BLE001 - detection must never crash convert + return False +``` + +In `convert_command`, after the S2 block and before the generic/S1 path: +```python + if _is_sentinel3_olci_input(dt): + log.info("Detected Sentinel-3 OLCI product; using OLCI converter") + dt_geozarr = convert_olci_optimized( + dt, + output_path=args.output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + ) + # (skip the generic path; mirror how the S2 block returns/continues) +``` +Match exactly how the S2 block hands off (return vs. fallthrough) in the current `convert_command`. + +Add the subcommand (mirror `add_s2_optimization_commands`): +```python +def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> None: + p = subparsers.add_parser( + "convert-s3-olci-optimized", + help="Convert a Sentinel-3 OLCI L1 EFR dataset to optimized GeoZarr", + ) + p.add_argument("input_path", type=str, help="Path to input OLCI dataset (Zarr)") + p.add_argument("output_path", type=str, help="Path for output optimized dataset") + p.add_argument("--spatial-chunk", type=int, default=1024, help="Spatial chunk size") + p.add_argument("--enable-sharding", action="store_true", help="Enable Zarr v3 sharding") + p.add_argument("--compression-level", type=int, default=3, choices=range(1, 10), + help="Compression level 1-9 (default: 3)") + p.add_argument("--min-dimension", type=int, default=256, + help="Minimum overview dimension (default: 256)") + p.add_argument("--keep-scale-offset", action="store_true", + help="Preserve scale-offset encoding instead of decoding to float") + p.add_argument("--verbose", action="store_true", help="Enable verbose output") + p.set_defaults(func=convert_s3_olci_optimized_command) + + +def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: + storage_options = get_storage_options(str(args.input_path)) + dt_input = xr.open_datatree( + str(args.input_path), engine="zarr", chunks="auto", + storage_options=storage_options, + ) + convert_olci_optimized( + dt_input, + output_path=args.output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + compression_level=args.compression_level, + min_dimension=args.min_dimension, + keep_scale_offset=args.keep_scale_offset, + ) + log.info("✅ S3 OLCI optimization completed", output_path=args.output_path) +``` + +And register it next to the S2 registration: +```python + add_s2_optimization_commands(subparsers) + add_s3_olci_optimization_commands(subparsers) +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_olci_integration.py -v && uv run --frozen pyright src/eopf_geozarr/cli.py && uv run ruff check src/eopf_geozarr/cli.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add src/eopf_geozarr/cli.py tests/test_olci_integration.py +git commit -m "feat(s3-olci): CLI auto-detect + convert-s3-olci-optimized command + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 8: Real-product fixture + round-trip test + +**Files:** +- Create: `tests/_test_data/s3_examples/.json` +- Modify: `tests/conftest.py` +- Test: `tests/test_data_api/test_s3_olci.py` (extend with a real-product round-trip) + +**Interfaces:** +- Consumes: `create_group_from_json` (existing conftest helper); `is_sentinel3_olci_dataset`. +- Produces: `s3_example_json_paths` tuple + `s3_olci_group_example` fixture in conftest. + +**Generating the fixture** (run once, by the implementer, to create the committed JSON). The product is on the EODC EOPF store; use an `_NT_` product (the `_NR_` copies lack metadata). The store's `tenant:bucket` name breaks s3fs, but the consolidated `.zmetadata` is fetchable over HTTPS. Generate the structure dump with pydantic-zarr from the consolidated metadata. Reference product: +`https://objects.eodc.eu/e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu/01/products/cpm_v262/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.zarr` + +Write a one-off script `scripts/dump_olci_example.py` (NOT committed to src; can live under a scratch dir or `scripts/`) that builds a `pydantic_zarr.v2.GroupSpec` from the product's consolidated metadata and writes `model_dump_json(indent=2)` to the fixture path. If opening the remote store with xarray/zarr is blocked by the store's naming, build the `GroupSpec` dict directly from the fetched `.zmetadata` JSON (the `metadata` map contains every `.zgroup`/`.zarray`/`.zattrs`). The committed JSON must be a structure-only dump (chunks not required; shapes/dtypes/attrs are what matter), matching the form of `tests/_test_data/s2_examples/*.json`. + +Keep the fixture small if the full product is large: it is acceptable to truncate array shapes in the JSON (the model/detection tests only need structure), but document any truncation in a top-level attribute or a sibling README note. + +- [ ] **Step 1: Generate and commit the fixture JSON** + +Produce `tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_..._NT_004.json` via the one-off script. Verify it loads: +```bash +uv run python -c "import json,pathlib; json.loads(pathlib.Path('tests/_test_data/s3_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json').read_text()); print('ok')" +``` +Expected: `ok`. + +- [ ] **Step 2: Add conftest fixture** + +```python +# in tests/conftest.py, near the other *_example_json_paths +s3_example_json_paths = tuple(pathlib.Path("tests/_test_data/s3_examples").glob("*.json")) + + +@pytest.fixture(params=s3_example_json_paths, ids=get_stem) +def s3_olci_group_example( + request: pytest.FixtureRequest, tmp_path: pathlib.Path +) -> pathlib.Path: + """Path to a Zarr group with the layout of a Sentinel-3 OLCI product.""" + return create_group_from_json(request.param, tmp_path) +``` + +- [ ] **Step 3: Write the round-trip / detection test** + +```python +# append to tests/test_data_api/test_s3_olci.py +def test_real_olci_product_is_detected(s3_olci_group_example) -> None: + import zarr + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + group = zarr.open_group(str(s3_olci_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_real_olci_product_validates_model(s3_olci_group_example) -> None: + import zarr + from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec + from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot + + group = zarr.open_group(str(s3_olci_group_example), mode="r") + model = Sentinel3OlciRoot.model_validate(PyzGroupSpec.from_zarr(group).model_dump()) + assert "oa01_radiance" in model.measurements.members +``` + +- [ ] **Step 4: Run tests + type/lint** + +Run: `uv run pytest tests/test_data_api/test_s3_olci.py -v && uv run --frozen pyright tests/conftest.py && uv run ruff check tests/conftest.py tests/test_data_api/test_s3_olci.py` +Expected: tests PASS; pyright 0; ruff clean. + +- [ ] **Step 5: Commit** + +```bash +git add tests/_test_data/s3_examples/ tests/conftest.py tests/test_data_api/test_s3_olci.py +git commit -m "test(s3-olci): real OLCI product fixture + round-trip detection + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 9: Golden-file snapshot of converted OLCI structure + +**Files:** +- Create: `tests/_test_data/optimized_olci_examples/.json` +- Test: `tests/test_olci_multiscale.py` (extend) or `tests/test_olci_integration.py` + +**Interfaces:** +- Consumes: `s3_olci_group_example` (Task 8); `convert_olci_optimized`; `pydantic_zarr.v3.GroupSpec`. +- Produces: a committed expected-structure snapshot + a test comparing converted output to it (mirrors `test_s2_multiscale.test_create_multiscale_from_datatree`). + +- [ ] **Step 1: Write the snapshot comparison test** + +```python +# append to tests/test_olci_integration.py +import json +from pathlib import Path + +import zarr +from pydantic_zarr.v3 import GroupSpec +from pydantic_zarr.core import tuplify_json + + +def test_olci_conversion_matches_snapshot(s3_olci_group_example, tmp_path) -> None: + import xarray as xr + + dt_in = xr.open_datatree(str(s3_olci_group_example), engine="zarr", chunks={}) + out = str(tmp_path / "out.zarr") + convert_olci_optimized(dt_in, output_path=out, min_dimension=256) + + observed = GroupSpec.from_zarr(zarr.open_group(out, use_consolidated=False)).model_dump() + expected_path = Path("tests/_test_data/optimized_olci_examples") / ( + Path(str(s3_olci_group_example)).stem + ".json" + ) + # To (re)generate the snapshot, uncomment: + # expected_path.parent.mkdir(parents=True, exist_ok=True) + # expected_path.write_text(json.dumps(observed, indent=2, sort_keys=True)) + expected = tuplify_json(json.loads(expected_path.read_text())) + observed_flat = GroupSpec(**tuplify_json(observed)).to_flat() + expected_flat = GroupSpec(**expected).to_flat() + assert set(observed_flat) == set(expected_flat) + assert [k for k in observed_flat if observed_flat[k] != expected_flat[k]] == [] +``` + +- [ ] **Step 2: Generate the snapshot** + +Temporarily uncomment the regeneration lines, run the test once to write the snapshot, re-comment, and verify it now passes: +```bash +uv run pytest tests/test_olci_integration.py::test_olci_conversion_matches_snapshot -v +``` +Expected: PASS after the snapshot is written. + +- [ ] **Step 3: Run tests + lint** + +Run: `uv run pytest tests/test_olci_integration.py -v && uv run ruff check tests/test_olci_integration.py` +Expected: PASS; ruff clean. + +- [ ] **Step 4: Commit** + +```bash +git add tests/_test_data/optimized_olci_examples/ tests/test_olci_integration.py +git commit -m "test(s3-olci): golden-file snapshot of converted OLCI structure + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 10: Full verification + docs + +**Files:** +- Modify: `README.md` and/or `docs/` (add OLCI to supported products + CLI usage). + +- [ ] **Step 1: Whole-suite type + lint + tests** + +Run: +```bash +uv run --frozen pyright +uv run ruff check src/ tests/ +uv run ruff format --check src/ tests/ +uv run pytest tests/ -p no:cacheprovider -q -m "not network" +``` +Expected: pyright 0 errors; ruff clean; tests green. + +- [ ] **Step 2: Document OLCI support** + +Add a short section to `README.md` (and/or `docs/converter.md`) noting Sentinel-3 OLCI L1 EFR support, the native-swath (no reprojection) behavior, and the `convert-s3-olci-optimized` command + auto-detection. + +- [ ] **Step 3: Commit** + +```bash +git add README.md docs/ +git commit -m "docs(s3-olci): document Sentinel-3 OLCI export support + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Notes / deferred (future specs) + +- GeoZarr-converting `conditions/geometry` (tie-point grid), `meteorology` (3-D + pressure_level), `instrument` (per-band/detector) — copied through unmodified in v1. +- Reprojection-to-regular-grid option (lossy) — explicitly out of scope. +- SLSTR / SRAL / SYNERGY product types — separate specs. +- If GeoZarr's spatial/proj convention for curvilinear (2-D-coordinate) data needs a specific representation beyond `spatial:dimensions` + coordinate arrays, refine `swath_spatial_attrs` (Task 5) and regenerate the Task 9 snapshot. diff --git a/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md b/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md new file mode 100644 index 00000000..6083174f --- /dev/null +++ b/docs/superpowers/specs/2026-06-21-sentinel3-olci-export-design.md @@ -0,0 +1,194 @@ +# Sentinel-3 OLCI L1 EFR → GeoZarr export — design + +Status: draft for review +Date: 2026-06-21 +Branch: `feat/sentinel3-export` (off `chore/new-conventions-metadata`) + +## Goal + +Add a first Sentinel-3 exporter to eopf-geozarr, scoped to **OLCI Level-1 EFR** +(Ocean and Land Colour Instrument, Earth-observation Full Resolution). It +converts an EOPF OLCI product into a GeoZarr-spec-compliant, multiscale Zarr +store, modeled on the existing Sentinel-2 exporter but adapted to OLCI's +fundamentally different geometry. + +This is the first of several Sentinel-3 product types (SLSTR, SRAL, SYNERGY are +out of scope here and will get their own specs). + +## Source format (verified against a real product) + +Introspected from a real `_NT_` (non-time-critical, fully consolidated) product +on the EODC EOPF sample store, e.g.: +`S3A_OL_1_EFR____20251101T073957..._NT_004.zarr` in bucket +`e05ab01a9d56408d82ac32d69a5aae2a:202511-s03olcefr-eu` on `objects.eodc.eu`. + +Key facts: + +- **Zarr v2**, consolidated metadata at root (`.zmetadata`). NOTE: `_NR_` + (near-real-time) copies of the same products are often *incomplete* (chunks + but no metadata) — use `_NT_` products as the source of truth. +- Top-level groups mirror S2: `measurements`, `quality`, `conditions` (plus + `*/orphans` subgroups, an OLCI artifact for removed/duplicate pixels). +- `measurements/`: 21 radiance bands `oa01_radiance` … `oa21_radiance`, each + `[4090, 4865]` `uint16`, dims `(rows, columns)` — a **single full-resolution + ~300 m grid; all 21 bands share the same shape** (unlike S2's 10/20/60 m). + Each band has CF `scale_factor`/`add_offset`, `units`, + `standard_name=toa_upwelling_spectral_radiance`, and + `coordinates: latitude longitude altitude time_stamp`. +- **Geolocation is per-pixel / curvilinear**: `measurements/latitude`, + `measurements/longitude`, `measurements/altitude` are 2D `[4090, 4865]` + arrays (`latitude`/`longitude` are scaled `int32`, scale `1e-6`, with fill + values). There is **no projected CRS, no EPSG, no affine transform** — root + attrs are empty. OLCI is delivered in satellite swath geometry. +- `conditions/geometry`: sun/view angles (`sza`, `saa`, `oza`, `oaa`) on a + **coarser across-track tie-point grid** `[4090, 77]`. +- `conditions/instrument`: per-band/detector spectral data (`lambda0`, + `solar_flux`, `fwhm`) shaped `[21, 3700]`; `relative_spectral_covariance` + `[21, 21]`. +- `conditions/meteorology`: ECMWF fields on the `[4090, 77]` tie-point grid, + some with a `pressure_level` (25) dim. +- `conditions/image`: `altitude`, `detector_index`, `frame_offset`, + `latitude`, `longitude` at full `[4090, 4865]`; `time_stamp` `[4090]`. + +## Core design decision: native swath geometry (no reprojection) + +OLCI L1 has no projected grid. We **preserve native swath geometry**: keep the +per-pixel `latitude`/`longitude` as 2-D auxiliary coordinate variables +(CF "two-dimensional coordinates" + GeoZarr geographic convention). **No +reprojection / resampling** — faithful and lossless. + +Consequences: +- The GeoZarr `proj` convention is geographic (lat/lon), not a projected CRS + + affine transform. We attach 2-D coordinate arrays via CF `coordinates` and the + appropriate GeoZarr `spatial`/`proj` metadata for curvilinear data (no + `spatial:transform`; lat/lon carried as coordinate arrays). +- Multiscale overviews are produced by **2×2 block reduction** of `rows`/`columns`: + - **Radiance bands → block-average** (mean over each 2×2 block), like the S2 + reflectance path. This is a genuine reduction, so each level carries new + information that justifies storing it (a literal `[::2,::2]` *subsample* would + add no information over the base array and must NOT be re-saved). + - **Coordinate arrays (`latitude`/`longitude`/`altitude`) → decimate** + (take a fixed sub-pixel, e.g. block top-left), NOT average — so each overview + pixel's geolocation remains a real measured position rather than an + interpolated one. Radiance and coords are reduced together so each level's + grid stays internally consistent. + - Levels are declared with the GeoZarr **`multiscales`** convention. Per the + multiscales spec, the per-level `transform` holds the **relative** index + relationship (`scale: [2, 2]` from the source level) — which remains valid + for a 2×2 reduction. We do **NOT** emit `spatial:transform` (the absolute + affine), because OLCI has no regular grid; absolute geolocation is carried by + each level's own 2-D lat/lon coordinate arrays. (Reprojection to a regular + grid is explicitly a *future* option, not in this deliverable.) + +## Scope (v1): measurements-first + +- **`measurements/`** → GeoZarr-compliant multiscale group: + - 21 radiance bands + the 2-D `latitude`/`longitude`/`altitude` coordinate + arrays, CF `coordinates` linkage preserved, scale/offset preserved + (same handling as S2 reflectance encoding). + - `/2` overview pyramid (decimation), down to a configurable min dimension. +- **`conditions/` and `quality/`** → copied through faithfully but unoptimized + (the way the S2 path copies non-reflectance groups as-is). +- **`orphans/`** subgroups → copied through as-is (not specially handled). +- Out of scope for v1: GeoZarr-converting the tie-point geometry grid, 3-D + meteorology, and 1-D instrument arrays; SLSTR/SRAL/SYNERGY; reprojection. + +## Architecture — mirror the S2 package + +Reuse the S2 exporter's shape (a self-contained product package + a data_api +model + CLI auto-detection). New code: + +``` +src/eopf_geozarr/s3_olci_optimization/ # parallels s2_optimization/ + __init__.py + olci_band_mapping.py # 21 OLCI bands (oa01..oa21), band metadata; the + # "all bands one resolution" config + olci_multiscale.py # swath /2 decimation pyramid + GeoZarr metadata; + # decimates radiance + 2D coord arrays together + olci_converter.py # convert_olci_optimized(dt, *, output_path, ...) + # entry point + is_sentinel3_olci_dataset() + common.py # (or reuse s2_optimization.common) + +src/eopf_geozarr/data_api/s3_olci.py # Sentinel3OlciRoot pydantic model + # (GroupSpec/TypedDict members) +``` + +Reused as-is from existing code: +- Generic encoding / chunk-alignment / fill-value helpers in + `conversion/utils.py` and `fs_utils.py`. +- GeoZarr convention metadata helpers (`conversion/utils.build_convention_attrs`, + zarr-cm), root consolidation, snapshot/round-trip test patterns. +- Type-aware resampling: OLCI radiance is all "reflectance-like" (block-average + on decimation); we can reuse `s2_resampling` averaging or a thin OLCI variant. + v1 only needs averaging/decimation since all bands are one continuous + radiance type (no SCL/quality-mask variety in `measurements/`). + +### Product detection + +S2/S1 are detected **structurally** (validate the zarr group against +`Sentinel1Root | Sentinel2Root` pydantic models in `is_sentinel2_dataset`). OLCI +root attrs are empty, so structural detection is the right approach: add +`Sentinel3OlciRoot` and extend the adapter to +`Sentinel1Root | Sentinel2Root | Sentinel3OlciRoot`. The CLI `convert` command's +auto-detect dispatches to `convert_olci_optimized` when the product validates as +OLCI. + +### CLI + +- Auto-detect in `convert` (as S2 does). +- Dedicated `convert-s3-olci-optimized` subcommand mirroring + `convert-s2-optimized` (spatial-chunk, sharding, compression-level, + keep-scale-offset, skip-validation, dask-cluster, verbose). + +## Data model (`data_api/s3_olci.py`) + +Follow the S2 pattern (pydantic `GroupSpec` + `closed=True` TypedDict members), +NOT the S1 dynamic-mapping pattern, because OLCI has a fixed known structure: + +- `Sentinel3OlciRoot(GroupSpec[..., Sentinel3OlciRootMembers])` with + `measurements`, `quality`, `conditions` members. +- `Sentinel3OlciMeasurementsMembers`: the 21 `oaNN_radiance` arrays + + `latitude`/`longitude`/`altitude` (+ optional `orphans`). Genuinely-optional + members stay `NotRequired`/`total=False` (lesson from the S1 model: don't make + variant keys required, or real products fail validation). Accessors narrow + with `.get()` + guard. + +Type checking: pyright (project standard). No `typing.Any`. Convention metadata +built via `zarr_cm` / `build_convention_attrs`. + +## Testing (match existing pattern) + +1. **Structure-dump fixture**: generate a JSON metadata-dump of a real OLCI + `_NT_` product via pydantic-zarr `GroupSpec` (as `s1_examples`/`s2_examples` + were made), commit to `tests/_test_data/s3_examples/`, add an + `s3_olci_group_example` fixture in `conftest.py` that materializes it to zarr + via `create_group_from_json`. First confirm the dump round-trips cleanly for + OLCI. +2. **Unit tests**: band mapping, swath decimation correctness (radiance and + lat/lon decimate consistently), GeoZarr metadata emitted, model validation + (incl. a real-product round-trip). +3. **Golden-file snapshot** of the converted structure (like + `optimized_geozarr_examples`), with the URL-only-diff regeneration discipline. +4. **Synthetic in-memory OLCI builder** for an integration test (mirrors the + S1/S2 integration mocks) exercising `convert_olci_optimized` end-to-end. +5. **CLI e2e** for `convert-s3-olci-optimized` on the materialized fixture. + +## Open questions / risks + +- **CF curvilinear + GeoZarr `spatial`/`proj` for swath data**: confirm the + exact GeoZarr metadata form for 2-D-coordinate (non-gridded) data during + implementation; the conventions are grid-oriented and may need a geographic / + coordinate-array representation rather than `spatial:transform`. +- **Decimation vs. averaging for overviews**: v1 uses simple /2; confirm whether + block-averaging radiance (and what to do with lat/lon — decimate, not average) + is preferred for the pyramid. +- **EOPF data access plumbing**: opening these remote products needs the right + storage handling (tenant:bucket name breaks s3fs; `_NR_` products lack + metadata). Test data is committed as JSON dumps, so this only matters for + regenerating fixtures, not for CI. + +## Decomposition / sequencing + +This spec is one implementation plan: the OLCI measurements-first exporter. +Follow-ups (separate specs): OLCI conditions/quality GeoZarr conversion; +reprojection-to-grid option; SLSTR / SRAL / SYNERGY. diff --git a/pyproject.toml b/pyproject.toml index bd22dce3..3b8ff219 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -71,6 +71,11 @@ docs = [ "pymdown-extensions>=10.0", "mike>=2.1.3", ] +notebooks = [ + "jupyter>=1.0.0", + "matplotlib>=3.8.0", + "nbformat>=5.9.0", +] [project.urls] Homepage = "https://github.com/developmentseed/eopf-geozarr" diff --git a/src/eopf_geozarr/cli.py b/src/eopf_geozarr/cli.py index 805c9237..8177052f 100755 --- a/src/eopf_geozarr/cli.py +++ b/src/eopf_geozarr/cli.py @@ -15,6 +15,10 @@ import xarray as xr from eopf_geozarr.s2_optimization.s2_converter import convert_s2_optimized, is_sentinel2_dataset +from eopf_geozarr.s3_olci_optimization.olci_converter import ( + convert_olci_optimized, + is_sentinel3_olci_dataset, +) from . import create_geozarr_dataset from .conversion.fs_utils import ( @@ -100,6 +104,20 @@ def _is_sentinel2_input(dt: xr.DataTree) -> bool: return False +def _is_sentinel3_olci_input(dt: xr.DataTree) -> bool: + """Best-effort Sentinel-3 OLCI detection that never breaks the generic path. + + ``is_sentinel3_olci_dataset`` validates structurally against a Zarr v2 model + and can raise on unrelated inputs; any failure simply means "not a recognised + OLCI product", so fall back to the generic converter. + """ + try: + return is_sentinel3_olci_dataset(get_zarr_group(dt)) + except Exception as exc: + log.debug("Sentinel-3 OLCI detection skipped", error=str(exc)) + return False + + def convert_command(args: argparse.Namespace) -> None: """ Convert EOPF dataset to GeoZarr compliant format. @@ -203,6 +221,14 @@ def convert_command(args: argparse.Namespace) -> None: keep_scale_offset=False, max_retries=args.max_retries, ) + elif _is_sentinel3_olci_input(dt): + log.info("Detected Sentinel-3 OLCI product; using OLCI converter") + dt_geozarr = convert_olci_optimized( + dt, + output_path=output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + ) else: dt_geozarr = create_geozarr_dataset( dt_input=dt, @@ -1154,6 +1180,7 @@ def create_parser() -> argparse.ArgumentParser: # Add S2 optimization commands add_s2_optimization_commands(subparsers) + add_s3_olci_optimization_commands(subparsers) return parser @@ -1247,6 +1274,60 @@ def convert_s2_optimized_command(args: argparse.Namespace) -> None: log.warning("Error closing dask cluster", error=str(e)) +def add_s3_olci_optimization_commands(subparsers: argparse._SubParsersAction) -> None: + """Add S3 OLCI optimization commands to CLI parser.""" + p = subparsers.add_parser( + "convert-s3-olci-optimized", + help="Convert a Sentinel-3 OLCI L1 EFR dataset to optimized GeoZarr", + ) + p.add_argument("input_path", type=str, help="Path to input OLCI dataset (Zarr)") + p.add_argument("output_path", type=str, help="Path for output optimized dataset") + p.add_argument("--spatial-chunk", type=int, default=1024, help="Spatial chunk size") + p.add_argument("--enable-sharding", action="store_true", help="Enable Zarr v3 sharding") + p.add_argument( + "--compression-level", + type=int, + default=3, + choices=range(1, 10), + help="Compression level 1-9 (default: 3)", + ) + p.add_argument( + "--min-dimension", + type=int, + default=256, + help="Minimum overview dimension (default: 256)", + ) + p.add_argument( + "--keep-scale-offset", + action="store_true", + help="Preserve scale-offset encoding instead of decoding to float", + ) + p.add_argument("--verbose", action="store_true", help="Enable verbose output") + p.set_defaults(func=convert_s3_olci_optimized_command) + + +def convert_s3_olci_optimized_command(args: argparse.Namespace) -> None: + """Execute S3 OLCI optimized conversion command.""" + storage_options = get_storage_options(str(args.input_path)) + dt_input = xr.open_datatree( + str(args.input_path), + engine="zarr", + chunks="auto", + storage_options=storage_options, + mask_and_scale=False, + ) + convert_olci_optimized( + dt_input, + output_path=args.output_path, + enable_sharding=args.enable_sharding, + spatial_chunk=args.spatial_chunk, + compression_level=args.compression_level, + min_dimension=args.min_dimension, + keep_scale_offset=args.keep_scale_offset, + ) + log.info("S3 OLCI optimization completed", output_path=args.output_path) + + def main() -> None: """Execute main entry point for the CLI.""" parser = create_parser() diff --git a/src/eopf_geozarr/data_api/s3_olci.py b/src/eopf_geozarr/data_api/s3_olci.py new file mode 100644 index 00000000..7b55f8f0 --- /dev/null +++ b/src/eopf_geozarr/data_api/s3_olci.py @@ -0,0 +1,94 @@ +"""Pydantic-zarr model for the Sentinel-3 OLCI L1 EFR EOPF Zarr structure. + +Mirrors data_api/s2.py: GroupSpec + closed TypedDict members. Used for +structural product detection (an EOPF product is OLCI iff it validates here). +""" + +from __future__ import annotations + +from collections.abc import Mapping # noqa: TC003 + +from pydantic import BaseModel +from typing_extensions import TypedDict + +from eopf_geozarr.data_api.geozarr.common import DatasetAttrs +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec + + +class Sentinel3OlciRootAttrs(BaseModel): + """Root-level attributes for an OLCI DataTree (not validated in detail).""" + + other_metadata: dict[str, object] + stac_discovery: dict[str, object] + + +class Sentinel3OlciMeasurementsMembers(TypedDict, closed=True, total=False): + """Members of the OLCI measurements group. + + The 21 radiance bands and the per-pixel geolocation coordinate arrays are + required in practice but typed optional so partial/variant products still + validate; the converter checks for the bands it needs. + """ + + latitude: ArraySpec[object] + longitude: ArraySpec[object] + altitude: ArraySpec[object] + time_stamp: ArraySpec[object] + orphans: GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] + oa01_radiance: ArraySpec[object] + oa02_radiance: ArraySpec[object] + oa03_radiance: ArraySpec[object] + oa04_radiance: ArraySpec[object] + oa05_radiance: ArraySpec[object] + oa06_radiance: ArraySpec[object] + oa07_radiance: ArraySpec[object] + oa08_radiance: ArraySpec[object] + oa09_radiance: ArraySpec[object] + oa10_radiance: ArraySpec[object] + oa11_radiance: ArraySpec[object] + oa12_radiance: ArraySpec[object] + oa13_radiance: ArraySpec[object] + oa14_radiance: ArraySpec[object] + oa15_radiance: ArraySpec[object] + oa16_radiance: ArraySpec[object] + oa17_radiance: ArraySpec[object] + oa18_radiance: ArraySpec[object] + oa19_radiance: ArraySpec[object] + oa20_radiance: ArraySpec[object] + oa21_radiance: ArraySpec[object] + + +class Sentinel3OlciMeasurementsGroup(GroupSpec[DatasetAttrs, Sentinel3OlciMeasurementsMembers]): + """OLCI measurements group: 21 radiance bands + 2-D geolocation.""" + + +class Sentinel3OlciRootMembers(TypedDict, closed=True, total=False): + """Members of the OLCI root group.""" + + measurements: Sentinel3OlciMeasurementsGroup + quality: GroupSpec[ + Mapping[str, object], + Mapping[ + str, + GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] | ArraySpec[object], + ], + ] + conditions: GroupSpec[ + Mapping[str, object], + Mapping[ + str, + GroupSpec[Mapping[str, object], Mapping[str, ArraySpec[object]]] | ArraySpec[object], + ], + ] + + +class Sentinel3OlciRoot(GroupSpec[Sentinel3OlciRootAttrs, Sentinel3OlciRootMembers]): + """Complete Sentinel-3 OLCI L1 EFR EOPF Zarr hierarchy.""" + + @property + def measurements(self) -> Sentinel3OlciMeasurementsGroup: + """Get the measurements group.""" + group = self.members.get("measurements") + if group is None: + raise KeyError("measurements") + return group diff --git a/src/eopf_geozarr/s3_olci_optimization/__init__.py b/src/eopf_geozarr/s3_olci_optimization/__init__.py new file mode 100644 index 00000000..6850218b --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/__init__.py @@ -0,0 +1 @@ +"""Sentinel-3 OLCI L1 EFR optimization (GeoZarr export).""" diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py b/src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py new file mode 100644 index 00000000..db0cc35e --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/olci_band_mapping.py @@ -0,0 +1,51 @@ +"""Band definitions for Sentinel-3 OLCI L1 EFR. + +OLCI has 21 radiance bands (Oa01..Oa21), all delivered at the same full +resolution (~300 m) on a single swath grid. +""" + +from dataclasses import dataclass + +RADIANCE_DTYPE = "uint16" + +# Band index -> central wavelength in nm (OLCI Oa01..Oa21). +_WAVELENGTHS_NM: tuple[float, ...] = ( + 400.0, + 412.5, + 442.5, + 490.0, + 510.0, + 560.0, + 620.0, + 665.0, + 673.75, + 681.25, + 708.75, + 753.75, + 761.25, + 764.375, + 767.5, + 778.75, + 865.0, + 885.0, + 900.0, + 940.0, + 1020.0, +) + +OLCI_BANDS: tuple[str, ...] = tuple(f"oa{i:02d}_radiance" for i in range(1, 22)) + + +@dataclass(frozen=True) +class OlciBandInfo: + """Spectral characterization of a single OLCI radiance band.""" + + name: str + data_type: str + wavelength_center: float # nanometers + + +OLCI_BAND_INFO: dict[str, OlciBandInfo] = { + name: OlciBandInfo(name=name, data_type=RADIANCE_DTYPE, wavelength_center=wl) + for name, wl in zip(OLCI_BANDS, _WAVELENGTHS_NM, strict=True) +} diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_converter.py b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py new file mode 100644 index 00000000..462fb395 --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/olci_converter.py @@ -0,0 +1,336 @@ +"""Top-level Sentinel-3 OLCI L1 EFR -> GeoZarr conversion.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, cast + +import structlog +import xarray as xr +import zarr + +from eopf_geozarr.conversion.utils import build_convention_attrs +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS +from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( + reduce_swath, + swath_spatial_attrs, +) + +if TYPE_CHECKING: + from zarr.core.common import JSON + from zarr_cm import LayoutObject, MultiscalesAttrs, Transform + +log = structlog.get_logger() + + +def _sanitize_olci_array_attrs(attrs: dict[str, object]) -> dict[str, object]: + """Return a copy of *attrs* with stale source-only keys removed. + + Strips ``_eopf_attrs``, ``dtype``, ``valid_min``, and ``valid_max`` (source + provenance and raw-integer-domain metadata that is misleading in GeoZarr + output). Unlike the shared :func:`~eopf_geozarr.conversion.utils.sanitize_array_attrs`, + this helper intentionally **preserves** ``_FillValue`` because OLCI input is + opened with ``mask_and_scale=False`` (raw uint16) and downstream code (e.g. + ``reduce_swath``) needs ``_FillValue`` in ``.attrs`` to identify fill pixels + without CF decoding. + + CF keys ``scale_factor``, ``add_offset``, ``units``, ``standard_name``, + ``coordinates``, and ``long_name`` are always preserved. + """ + _strip = frozenset(("_eopf_attrs", "dtype", "valid_min", "valid_max")) + return {k: v for k, v in attrs.items() if k not in _strip} + + +def is_sentinel3_olci_dataset(group: zarr.Group) -> bool: + """Return True if *group* is a Sentinel-3 OLCI L1 EFR product. + + Detection is structural: the group must validate against + ``Sentinel3OlciRoot`` and its ``measurements`` group must contain the + first OLCI radiance band. + """ + from eopf_geozarr.pyz.v2 import GroupSpec + + try: + model = Sentinel3OlciRoot.model_validate(GroupSpec.from_zarr(group).model_dump()) + except ValueError as e: + log.debug("Not an OLCI dataset", error=str(e)) + return False + try: + return OLCI_BANDS[0] in model.measurements.members + except KeyError: + return False + + +def _overview_levels(rows: int, cols: int, min_dimension: int) -> int: + """Return the number of /2 decimations before min(rows, cols) drops below min_dimension. + + A level is generated only when the *post*-decimation minimum spatial + dimension is at least *min_dimension*. For example, a 512x480 dataset + with min_dimension=256 yields zero levels because 480//2=240 < 256, while + a 1024x1024 dataset with min_dimension=256 yields two levels (512x512, + then 256x256). + """ + levels = 0 + r, c = rows, cols + while min(r, c) // 2 >= min_dimension: + r, c = r // 2, c // 2 + levels += 1 + return levels + + +def _clear_encoding(ds: xr.Dataset) -> xr.Dataset: + """Return *ds* with all inherited source encoding cleared. + + When the input DataTree was opened from a Zarr v2 store, xarray carries + ``numcodecs.Blosc`` compressors (and potentially scale-offset filters) in + each variable's ``.encoding``. Passing that encoding to + ``Dataset.to_zarr(zarr_format=3)`` raises:: + + TypeError: Expected a BytesBytesCodec. Got + + because numcodecs codecs are not valid Zarr v3 BytesBytesCodecs. Clearing + the encoding lets the Zarr v3 writer choose its own default codecs. + + This converter expects raw (non-mask-scaled) input: the caller must open + the source DataTree with ``mask_and_scale=False`` so that CF + ``scale_factor``/``add_offset`` stay in ``.attrs`` and integer fill pixels + are identified via ``attrs["_FillValue"]``. Only Zarr v2 *codec* encoding + (e.g. ``numcodecs.Blosc`` compressors) is stripped here — CF metadata is + untouched. + """ + ds = ds.copy() + ds.encoding = {} + for var in list(ds.data_vars) + list(ds.coords): + ds[var].encoding.clear() + return ds + + +def _sanitize_data_vars(ds: xr.Dataset) -> xr.Dataset: + """Return *ds* with stale source attrs stripped from all data variables. + + Applies :func:`_sanitize_olci_array_attrs` to every data variable in *ds*. + Coordinate variable attrs are left intact. + + This removes ``_eopf_attrs``, ``dtype``, ``valid_min``, and ``valid_max`` + (source-only / misleading) while preserving CF attrs + (``scale_factor``, ``add_offset``, ``_FillValue``, ``units``, + ``standard_name``, ``coordinates``). + + Note: ``xr.DataArray.assign_attrs`` *merges* (update semantics), so we + copy the DataArray and replace ``.attrs`` in-place to ensure stale keys + are actually removed rather than retained from the old dict. + """ + new_vars: dict[str, xr.DataArray] = {} + for name in ds.data_vars: + var = ds[name] + new_var = var.copy(data=var.data) + new_var.attrs = _sanitize_olci_array_attrs(dict(var.attrs)) + new_vars[str(name)] = new_var + return ds.assign(new_vars) + + +def _copy_subtree(node: xr.DataTree, output_path: str, *, root_group: str) -> None: + """Write every Dataset in *node*'s subtree to the Zarr store at *output_path*. + + Each path is mapped relative to the node's own path: the node root becomes + *root_group*, and child nodes are placed at ``root_group/``. + + ``DataTree.to_zarr`` does not yet support a ``group`` keyword for + specifying a root offset, so we write each leaf's :py:meth:`~xarray.DataTree.to_dataset` + using ``xr.Dataset.to_zarr`` instead. + """ + node_path = node.path # e.g. "/conditions" + for child in node.subtree: + ds = child.to_dataset() + if not ds.data_vars and not ds.coords: + continue + # Strip any inherited Zarr v2 encoding before writing to a v3 store. + ds = _clear_encoding(ds) + # Build the group path: strip the ancestor prefix and prepend root_group. + relative = child.path[len(node_path) :] # "" for root, "/sub" for children + group_path = root_group + relative + log.info("Copying ancillary subgroup", group=group_path) + ds.to_zarr( + output_path, + group=group_path, + mode="a", + consolidated=False, + zarr_format=3, + ) + + +def convert_olci_optimized( + dt_input: xr.DataTree, + *, + output_path: str, + enable_sharding: bool = False, + spatial_chunk: int = 1024, + compression_level: int = 3, + min_dimension: int = 256, + keep_scale_offset: bool = False, +) -> xr.DataTree: + """Convert an EOPF OLCI L1 EFR DataTree to a GeoZarr multiscale store. + + Writes the native-resolution ``measurements`` group with GeoZarr + convention metadata, then writes /2-reduced overview subgroups + (``r2``, ``r4``, …) down to *min_dimension*. Any ``conditions`` or + ``quality`` groups present in *dt_input* are copied through unchanged, + along with any child subgroups of ``measurements`` (e.g. ``orphans``). + + Parameters + ---------- + dt_input: + Input OLCI L1 EFR DataTree (must contain a ``/measurements`` node). + output_path: + Filesystem path for the output Zarr v3 store. + enable_sharding: + Enable Zarr v3 sharding on measurement arrays. + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + spatial_chunk: + Target spatial chunk size (pixels per side). + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + compression_level: + Blosc/zstd compression level. + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + min_dimension: + Stop generating overview levels once either spatial dimension would + drop below this value after /2 decimation. + keep_scale_offset: + When ``True``, preserve CF ``scale_factor``/``add_offset`` in the + output encoding rather than decoding to float32. + Not yet wired into encoding for this minimal pass; accepted as a + typed parameter for forward-compatibility (follow-up task). + + Returns + ------- + xr.DataTree + The opened output DataTree (lazy; backed by the written Zarr store). + Overview subgroups (``r2``, ``r4``, …) are written to the Zarr store + but are **not** represented as children of the returned DataTree, + because xarray enforces dimension consistency between parent and child + nodes and the overview subgroups have smaller spatial dimensions than + the parent ``measurements`` group. To read them, open the store + directly with ``zarr.open_group(output_path)["measurements"]["r2"]`` + etc. + + Notes + ----- + Parameters ``enable_sharding``, ``spatial_chunk``, ``compression_level``, + and ``keep_scale_offset`` are accepted but not yet applied to the on-disk + encoding. Wiring them through the existing ``conversion`` helpers + (``create_measurements_encoding``, sharding codec, etc.) is left for a + follow-up task so as not to block the integration test. + """ + measurements = dt_input["/measurements"].to_dataset() + # Strip any inherited Zarr v2 encoding (e.g. numcodecs.Blosc compressors) + # so the v3 writer can choose its own default codecs without raising a + # "Expected a BytesBytesCodec" error. The caller is expected to have opened + # the source with mask_and_scale=False, so CF attrs (scale_factor, + # add_offset, _FillValue) live in .attrs and are preserved here. + measurements = _clear_encoding(measurements) + # Sanitize radiance variable attrs: strip source-only / misleading attrs + # (_eopf_attrs, dtype, valid_min, valid_max) while keeping CF scale/offset + # and _FillValue so that downstream readers and reduce_swath can work + # correctly with raw integer data. + measurements = _sanitize_data_vars(measurements) + + log.info("Writing native-resolution measurements", shape=dict(measurements.sizes)) + measurements.to_zarr( + output_path, + group="measurements", + mode="w", + consolidated=False, + zarr_format=3, + ) + + # Write /2 reduced overview subgroups: r2, r4, r8, … + rows = measurements.sizes["rows"] + cols = measurements.sizes["columns"] + n_levels = _overview_levels(rows, cols, min_dimension) + log.info("Generating overview levels", n_levels=n_levels) + + current = measurements + for level in range(1, n_levels + 1): + current = reduce_swath(current, factor=2) + current = _clear_encoding(current) + # Attrs already sanitized at native level and passed through by + # reduce_swath; no second sanitize pass needed. + group_name = f"r{2**level}" + log.info("Writing overview", group=f"measurements/{group_name}", shape=dict(current.sizes)) + current.to_zarr( + output_path, + group=f"measurements/{group_name}", + mode="a", + consolidated=False, + zarr_format=3, + ) + + # Build and attach GeoZarr convention metadata (spatial + multiscales CMO) + # to the measurements group attrs. + layout: list[LayoutObject] = [{"asset": "."}] + for lvl in range(1, n_levels + 1): + transform: Transform = {"scale": [2.0, 2.0], "translation": [0.0, 0.0]} + lo: LayoutObject = { + "asset": f"r{2**lvl}", + "derived_from": "." if lvl == 1 else f"r{2 ** (lvl - 1)}", + "transform": transform, + "resampling_method": "average", + } + layout.append(lo) + + if n_levels > 0: + ms: MultiscalesAttrs = {"layout": layout, "resampling_method": "average"} + conv = build_convention_attrs(multiscales=ms, spatial=swath_spatial_attrs(), crs=None) + else: + conv = build_convention_attrs(spatial=swath_spatial_attrs(), crs=None) + + zarr.open_group(output_path, mode="a")["measurements"].attrs.update( + cast("dict[str, JSON]", conv) + ) + + # Copy conditions/quality through unchanged (if present). + # DataTree.to_zarr does not support a root ``group`` argument, so we + # iterate the subtree and write each leaf Dataset individually. + for grp in ("conditions", "quality"): + try: + node_item = dt_input[f"/{grp}"] + except KeyError: + continue + if not isinstance(node_item, xr.DataTree): + continue + log.info("Copying ancillary group", group=grp) + _copy_subtree(node_item, output_path, root_group=grp) + + # Copy any child subgroups of measurements (e.g. orphans) through unchanged. + try: + meas_node = dt_input["/measurements"] + except KeyError: + meas_node = None + if isinstance(meas_node, xr.DataTree): + for child in meas_node.children.values(): + log.info("Copying measurements subgroup", group=f"measurements/{child.name}") + _copy_subtree(child, output_path, root_group=f"measurements/{child.name}") + + # xarray DataTree enforces dimension consistency between parent and child + # nodes, so opening the whole store via ``xr.open_datatree`` would fail + # because the overview subgroups have smaller spatial dimensions than + # the parent ``measurements`` group. Instead, we build the DataTree + # manually from the top-level groups only: overview levels (r2, r4, …) + # are in the zarr store and accessible via ``zarr.open_group``, but are + # intentionally not exposed as DataTree children. + root = zarr.open_group(output_path, mode="r") + tree_dict: dict[str, xr.Dataset] = {} + for key in root.group_keys(): + child = root[key] + if isinstance(child, zarr.Group) and list(child.array_keys()): + tree_dict[f"/{key}"] = xr.open_dataset( + output_path, + engine="zarr", + group=key, + chunks={}, + consolidated=False, + ) + return xr.DataTree.from_dict(tree_dict) diff --git a/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py new file mode 100644 index 00000000..6239ffe3 --- /dev/null +++ b/src/eopf_geozarr/s3_olci_optimization/olci_multiscale.py @@ -0,0 +1,201 @@ +"""Multiscale (overview) generation for OLCI swath data. + +OLCI L1 EFR is a curvilinear swath geolocated by per-pixel 2-D lat/lon arrays. +Two reduction strategies are provided: + +* :func:`decimate_swath` — pure stride-based decimation; every (rows, columns) + variable is subsampled ``[::factor, ::factor]``. Geolocation (lat/lon) is + kept exact; intended for coordinate arrays and cases where preserving pixel + identity matters. + +* :func:`reduce_swath` — radiance bands are fill-aware block-averaged + (mean of ``factor x factor`` blocks) while coordinate arrays are decimated + with :func:`decimate_swath`; non-swath variables pass through unchanged. + Intended for producing GeoZarr multiscale overview groups. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import numpy as np +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import OLCI_BANDS + +if TYPE_CHECKING: + from zarr_cm import SpatialAttrs + +SWATH_DIMS = ("rows", "columns") + + +def decimate_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: + """Return *ds* with every (rows, columns) array subsampled by *factor*. + + Both data variables and coordinate variables that span exactly the swath + dims are decimated ``[::factor, ::factor]``; everything else is passed + through unchanged. Attributes and encoding are preserved by xarray's isel. + """ + if factor < 1: + raise ValueError(f"factor must be >= 1, got {factor}") + if factor == 1: + return ds + indexers = {dim: slice(None, None, factor) for dim in SWATH_DIMS if dim in ds.sizes} + if not indexers: + return ds + return ds.isel(indexers) + + +def reduce_swath(ds: xr.Dataset, factor: int = 2) -> xr.Dataset: + """Return *ds* with radiance bands block-averaged and 2-D coordinates decimated. + + Overviews are an unweighted index-block mean that ASSUMES locally-uniform + pixel spacing; intended for visualization, not quantitative analysis at + reduced resolution. Coordinates are decimated (real sub-pixels), radiance + is fill-aware block-averaged. + + Radiance variables (those named in :data:`OLCI_BANDS`) are averaged over + ``factor x factor`` pixel blocks with fill-value awareness: fill pixels + are masked before averaging so a single fill pixel does not contaminate + the entire block. Blocks where ALL pixels are fill are set back to the + fill value in the output. + + 2-D coordinate variables spanning exactly ``(rows, columns)`` and **not** + in :data:`OLCI_BANDS` (e.g. latitude, longitude, altitude) are decimated + ``[::factor, ::factor]`` to preserve real on-ground positions. + + Variables that do not span exactly ``(rows, columns)`` are passed through + unchanged. + + Parameters + ---------- + ds: + Input dataset. May contain any mix of radiance bands, 2-D coordinate + arrays, and other variables. + factor: + Spatial reduction factor. Must be >= 1. Factor 1 returns *ds* + unchanged. + + Returns + ------- + xr.Dataset + Reduced dataset with the same variables but smaller (rows, columns) + dimensions. + + Raises + ------ + ValueError + If *factor* < 1. + """ + if factor < 1: + raise ValueError(f"factor must be >= 1, got {factor}") + if factor == 1: + return ds + + olci_band_set: frozenset[str] = frozenset(OLCI_BANDS) + result_vars: dict[str, xr.DataArray] = {} + result_coords: dict[str, xr.DataArray] = {} + + coord_names: frozenset[str] = frozenset(str(k) for k in ds.coords) + + # Pre-compute the trimmed length for each swath dimension so that both the + # coarsen path (radiance) and the isel stride path (coordinates) produce + # exactly floor(N / factor) output elements. coarsen(boundary="trim") + # already truncates to a multiple of factor; we match it by stopping the + # stride at the same trimmed limit: slice(0, n_trim, factor). + # + # Without this, an odd-length dimension N yields: + # coarsen → floor(N / factor) e.g. 4865 → 2432 + # isel[::factor] → ceil(N / factor) e.g. 4865 → 2433 + # producing a store where coordinate arrays are longer than the data they + # describe, which makes xr.open_dataset raise a conflicting-sizes error. + dim_trim: dict[str, int] = { + dim: (ds.sizes[dim] // factor) * factor for dim in SWATH_DIMS if dim in ds.sizes + } + + all_names: list[str] = [str(k) for k in ds.data_vars] + [str(k) for k in ds.coords] + for name in all_names: + var: xr.DataArray = ds[name] if name in ds.data_vars else ds.coords[name] + is_swath_2d: bool = tuple(str(d) for d in var.dims) == SWATH_DIMS + + if name in olci_band_set and is_swath_2d: + # Fill-aware block averaging for radiance bands. + fill_value: int | float | None = var.attrs.get("_FillValue") + if fill_value is None: + fill_value = var.encoding.get("_FillValue") + orig_dtype = var.dtype + + float_var = var.astype("float64") + if fill_value is not None: + float_var = float_var.where(float_var != float(fill_value)) + + # coarsen().mean() is available at runtime; pyright stubs don't expose .mean() + # on DataArrayCoarsen, so we suppress the type-check on the reduction call. + coarsened = float_var.coarsen({"rows": factor, "columns": factor}, boundary="trim") + averaged: xr.DataArray = coarsened.mean() # type: ignore[attr-defined,assignment] + + if fill_value is not None: + fill_da = xr.where(averaged.isnull(), float(fill_value), averaged) + result_val = np.round(fill_da.values).astype(orig_dtype) + else: + result_val = np.round(averaged.values).astype(orig_dtype) + + out_var = xr.DataArray(result_val, dims=averaged.dims, attrs=var.attrs) + + if name in ds.data_vars: + result_vars[name] = out_var + else: + result_coords[name] = out_var + + elif is_swath_2d: + # Coordinate or non-radiance 2-D swath variable: decimate. + # Use slice(0, n_trim, factor) rather than slice(None, None, factor) + # so that an odd-length dimension N yields floor(N / factor) elements, + # matching the output length of coarsen(boundary="trim").mean(). + indexers: dict[str, slice] = { + dim: slice(0, dim_trim[dim], factor) for dim in SWATH_DIMS if dim in dim_trim + } + decimated = var.isel(indexers) + if name in coord_names: + result_coords[name] = decimated + else: + result_vars[name] = decimated + + elif any(dim in (str(d) for d in var.dims) for dim in SWATH_DIMS): + # 1-D (or higher) variable sharing a swath dim but not 2-D swath: + # decimate along whichever swath dims it carries. + var_dims = {str(d) for d in var.dims} + idx: dict[str, slice] = { + dim: slice(0, dim_trim[dim], factor) + for dim in SWATH_DIMS + if dim in var_dims and dim in dim_trim + } + decimated = var.isel(idx) + if name in coord_names: + result_coords[name] = decimated + else: + result_vars[name] = decimated + + else: + # Non-swath variable: pass through unchanged. + if name in coord_names: + result_coords[name] = var + else: + result_vars[name] = var + + return xr.Dataset(result_vars, coords=result_coords) + + +def swath_spatial_attrs( + dims: tuple[str, str] = SWATH_DIMS, +) -> SpatialAttrs: + """Spatial-convention data for curvilinear swath geometry. + + OLCI has no affine transform; geolocation is carried by 2-D lat/lon + coordinate arrays, so we declare the spatial dimensions and pixel + registration but no ``spatial:transform``/``spatial:bbox``. + """ + return { + "spatial:dimensions": [dims[0], dims[1]], + "spatial:registration": "pixel", + } diff --git a/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json new file mode 100644 index 00000000..a5dc9079 --- /dev/null +++ b/tests/_test_data/optimized_olci_examples/S3A_OL_1_EFR____20251101T073957_20251101T074257_20251102T084255_0179_132_149_2160_PS1_O_NT_004.json @@ -0,0 +1,10773 @@ +{ + "attributes": {}, + "members": { + "conditions": { + "attributes": {}, + "members": { + "geometry": { + "attributes": {}, + "members": { + "latitude": { + "attributes": { + "dimensions": [ + "rows", + "columns" + ], + "dtype": " return out_dir +@pytest.fixture(params=s3_example_json_paths, ids=get_stem) +def s3_olci_group_example(request: pytest.FixtureRequest, tmp_path: pathlib.Path) -> pathlib.Path: + """Path to a Zarr group with the layout of a Sentinel-3 OLCI product.""" + return create_group_from_json(request.param, tmp_path) + + @pytest.fixture(params=s1_example_json_paths, ids=get_stem) def s1_group_example(request: pytest.FixtureRequest, tmp_path: pathlib.Path) -> pathlib.Path: """ diff --git a/tests/test_data_api/test_s3_olci.py b/tests/test_data_api/test_s3_olci.py new file mode 100644 index 00000000..0625ec84 --- /dev/null +++ b/tests/test_data_api/test_s3_olci.py @@ -0,0 +1,132 @@ +"""Tests for the Sentinel-3 OLCI data-api model.""" + +import pytest +from pydantic import ValidationError + +from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot +from eopf_geozarr.pyz.v2 import ArraySpec, GroupSpec # noqa: F401 + + +def _olci_arr() -> dict[str, object]: + """Return a minimal v2 ArraySpec-shaped dict for a 2-D uint16 array.""" + return ArraySpec( + shape=(4, 5), + chunks=(4, 5), + dtype=" None: + """A dict with 21 radiance bands + geolocation validates as Sentinel3OlciRoot.""" + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root = { + "zarr_format": 2, + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, + "attributes": {}, + "members": {**radiance, **coords}, + }, + }, + } + model = Sentinel3OlciRoot.model_validate(root) + assert "oa01_radiance" in model.measurements.members + + +def test_rejects_non_olci_product() -> None: + """A dict with an unexpected key in measurements is rejected by closed=True.""" + not_olci = { + "zarr_format": 2, + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, + "attributes": {}, + "members": { + "reflectance": { + "zarr_format": 2, + "attributes": {}, + "members": {}, + } + }, + } + }, + } + with pytest.raises(ValidationError): + Sentinel3OlciRoot.model_validate(not_olci) + + +def test_detector_accepts_olci_zarr(tmp_path: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + # build a minimal OLCI zarr v2 store from the model dict used above + radiance = {f"oa{i:02d}_radiance": _olci_arr() for i in range(1, 22)} + coords = {c: _olci_arr() for c in ("latitude", "longitude", "altitude")} + root_dict = { + "zarr_format": 2, + "attributes": {"other_metadata": {}, "stac_discovery": {}}, + "members": { + "measurements": { + "zarr_format": 2, + "attributes": {}, + "members": {**radiance, **coords}, + } + }, + } + assert isinstance(tmp_path, pathlib.Path) + out = tmp_path / "olci.zarr" + Sentinel3OlciRoot.model_validate(root_dict).to_zarr(out, path="") # type: ignore[arg-type] + group = zarr.open_group(str(out), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_detector_rejects_s2_zarr(s2_group_example: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + assert isinstance(s2_group_example, pathlib.Path) + group = zarr.open_group(str(s2_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is False + + +def test_real_olci_product_is_detected(s3_olci_group_example: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.s3_olci_optimization.olci_converter import ( + is_sentinel3_olci_dataset, + ) + + assert isinstance(s3_olci_group_example, pathlib.Path) + group = zarr.open_group(str(s3_olci_group_example), mode="r") + assert is_sentinel3_olci_dataset(group) is True + + +def test_real_olci_product_validates_model(s3_olci_group_example: object) -> None: + import pathlib + + import zarr + + from eopf_geozarr.data_api.s3_olci import Sentinel3OlciRoot + from eopf_geozarr.pyz.v2 import GroupSpec as PyzGroupSpec + + assert isinstance(s3_olci_group_example, pathlib.Path) + group = zarr.open_group(str(s3_olci_group_example), mode="r") + model = Sentinel3OlciRoot.model_validate(PyzGroupSpec.from_zarr(group).model_dump()) + assert "oa01_radiance" in model.measurements.members diff --git a/tests/test_olci_band_mapping.py b/tests/test_olci_band_mapping.py new file mode 100644 index 00000000..8fca56c7 --- /dev/null +++ b/tests/test_olci_band_mapping.py @@ -0,0 +1,25 @@ +from eopf_geozarr.s3_olci_optimization.olci_band_mapping import ( + OLCI_BAND_INFO, + OLCI_BANDS, + RADIANCE_DTYPE, + OlciBandInfo, +) + + +def test_there_are_21_olci_bands() -> None: + assert len(OLCI_BANDS) == 21 + assert OLCI_BANDS[0] == "oa01_radiance" + assert OLCI_BANDS[-1] == "oa21_radiance" + + +def test_every_band_has_info() -> None: + assert set(OLCI_BAND_INFO) == set(OLCI_BANDS) + for name, info in OLCI_BAND_INFO.items(): + assert isinstance(info, OlciBandInfo) + assert info.name == name + assert info.data_type == RADIANCE_DTYPE + assert info.wavelength_center > 0 + + +def test_first_band_wavelength() -> None: + assert OLCI_BAND_INFO["oa01_radiance"].wavelength_center == 400.0 diff --git a/tests/test_olci_integration.py b/tests/test_olci_integration.py new file mode 100644 index 00000000..67ed0fc8 --- /dev/null +++ b/tests/test_olci_integration.py @@ -0,0 +1,406 @@ +"""Integration tests for convert_olci_optimized.""" + +from __future__ import annotations + +import json +import subprocess +import sys +from pathlib import Path +from typing import TYPE_CHECKING + +import numpy as np +import xarray as xr +import zarr +from pydantic_zarr.core import tuplify_json +from pydantic_zarr.v3 import GroupSpec + +from eopf_geozarr.s3_olci_optimization.olci_converter import _sanitize_olci_array_attrs + +if TYPE_CHECKING: + import pathlib + +from eopf_geozarr.s3_olci_optimization.olci_converter import convert_olci_optimized + + +def build_synthetic_olci(rows: int = 512, cols: int = 480) -> xr.DataTree: + """Minimal synthetic OLCI L1 EFR datatree (measurements only).""" + rng = np.random.default_rng(0) + lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) + lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + alt = np.zeros((rows, cols), dtype="int16") + data: dict[str, xr.DataArray] = {} + for i in range(1, 22): + name = f"oa{i:02d}_radiance" + arr = xr.DataArray( + rng.integers(0, 6000, (rows, cols)).astype("uint16"), + dims=("rows", "columns"), + attrs={ + "scale_factor": 0.0139, + "add_offset": 0.0, + "standard_name": "toa_upwelling_spectral_radiance", + "coordinates": "latitude longitude altitude", + }, + ) + data[name] = arr + ds = xr.Dataset( + data, + coords={ + "latitude": (("rows", "columns"), lat, {"standard_name": "latitude"}), + "longitude": (("rows", "columns"), lon, {"standard_name": "longitude"}), + "altitude": (("rows", "columns"), alt, {"standard_name": "altitude"}), + }, + ) + return xr.DataTree.from_dict({"/measurements": ds}) + + +def test_convert_olci_writes_measurements(tmp_path: object) -> None: + """Native-resolution measurements group must contain all 21 radiance bands.""" + import zarr + + dt = build_synthetic_olci() + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + convert_olci_optimized(dt, output_path=out) + + g = zarr.open_group(out, mode="r") + # native measurements present + assert "measurements" in g + # all 21 bands at native res + meas = g["measurements"] + for i in range(1, 22): + assert f"oa{i:02d}_radiance" in meas + + +def test_convert_olci_creates_overviews(tmp_path: object) -> None: + """Overview subgroups must only be written when BOTH post-decimation dims >= min_dimension. + + Case 1 — 512x480 with min_dimension=256: + 480//2 = 240 < 256, so the guard fires immediately → zero overview levels. + + Case 2 — 1024x1024 with min_dimension=256: + 1024//2=512>=256 → level r2 (512x512) + 512//2=256>=256 → level r4 (256x256) + 256//2=128<256 → stop + Exactly two levels; smallest must be exactly 256x256. + """ + import zarr + + # --- Case 1: 512x480, min_dimension=256 → zero overview levels --- + dt1 = build_synthetic_olci(rows=512, cols=480) + out1 = str(tmp_path / "olci_case1.zarr") # type: ignore[operator] + convert_olci_optimized(dt1, output_path=out1, min_dimension=256) + + g1 = zarr.open_group(out1, mode="r") + meas1 = g1["measurements"] + assert isinstance(meas1, zarr.Group) + subgroups1 = list(meas1.group_keys()) + assert len(subgroups1) == 0, ( + f"Expected 0 overview levels for 512x480 at min_dimension=256, got {subgroups1}" + ) + + # --- Case 2: 1024x1024, min_dimension=256 → exactly two valid levels --- + dt2 = build_synthetic_olci(rows=1024, cols=1024) + out2 = str(tmp_path / "olci_case2.zarr") # type: ignore[operator] + convert_olci_optimized(dt2, output_path=out2, min_dimension=256) + + g2 = zarr.open_group(out2, mode="r") + meas2 = g2["measurements"] + assert isinstance(meas2, zarr.Group) + subgroups2 = sorted(meas2.group_keys()) + assert len(subgroups2) == 2, ( + f"Expected exactly 2 overview levels for 1024x1024 at min_dimension=256, got {subgroups2}" + ) + + # Every overview level must have BOTH spatial dims >= min_dimension. + for sg_name in subgroups2: + sg = meas2[sg_name] + assert isinstance(sg, zarr.Group) + band = sg["oa01_radiance"] + assert isinstance(band, zarr.Array) + # shape is (rows, columns) + overview_rows, overview_cols = band.shape[0], band.shape[1] + assert overview_rows >= 256, f"measurements/{sg_name} rows={overview_rows} < 256" + assert overview_cols >= 256, f"measurements/{sg_name} cols={overview_cols} < 256" + + # The deepest level (r4 for 1024-input) must be exactly 256x256. + deepest = meas2[subgroups2[-1]] + assert isinstance(deepest, zarr.Group) + deepest_band = deepest["oa01_radiance"] + assert isinstance(deepest_band, zarr.Array) + assert deepest_band.shape[0] == 256, ( + f"Expected smallest overview rows=256, got {deepest_band.shape}" + ) + assert deepest_band.shape[1] == 256, ( + f"Expected smallest overview cols=256, got {deepest_band.shape}" + ) + + +def test_convert_olci_returns_datatree(tmp_path: object) -> None: + """convert_olci_optimized must return an xr.DataTree backed by the output store.""" + dt = build_synthetic_olci(rows=256, cols=256) + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + result = convert_olci_optimized(dt, output_path=out, min_dimension=256) + assert isinstance(result, xr.DataTree) + assert "/measurements" in result.groups + + +def test_convert_olci_conditions_quality_passthrough(tmp_path: object) -> None: + """conditions and quality groups, when present, are copied through unchanged.""" + import zarr + + # Build a tree with conditions and quality groups + rng = np.random.default_rng(1) + rows, cols = 128, 128 + lat = np.linspace(40, 41, rows * cols).reshape(rows, cols) + lon = np.linspace(10, 11, rows * cols).reshape(rows, cols) + alt = np.zeros((rows, cols), dtype="int16") + + meas_data: dict[str, xr.DataArray] = { + "oa01_radiance": xr.DataArray( + rng.integers(0, 6000, (rows, cols)).astype("uint16"), + dims=("rows", "columns"), + ) + } + meas_ds = xr.Dataset( + meas_data, + coords={ + "latitude": (("rows", "columns"), lat), + "longitude": (("rows", "columns"), lon), + "altitude": (("rows", "columns"), alt), + }, + ) + cond_ds = xr.Dataset( + { + "wind_speed": xr.DataArray( + rng.random((rows, cols)).astype("float32"), dims=("rows", "columns") + ) + } + ) + quality_ds = xr.Dataset( + { + "flags": xr.DataArray( + rng.integers(0, 255, (rows, cols)).astype("uint8"), dims=("rows", "columns") + ) + } + ) + # Build a measurements/orphans sub-dataset to verify child subgroup copy. + orphans_ds = xr.Dataset( + { + "removed_count": xr.DataArray( + rng.integers(0, 10, (rows,)).astype("int32"), dims=("rows",) + ) + } + ) + dt = xr.DataTree.from_dict( + { + "/measurements": meas_ds, + "/measurements/orphans": orphans_ds, + "/conditions": cond_ds, + "/quality": quality_ds, + } + ) + + out = str(tmp_path / "olci_geozarr.zarr") # type: ignore[operator] + convert_olci_optimized(dt, output_path=out, min_dimension=64) + + g = zarr.open_group(out, mode="r") + assert "conditions" in g + assert "quality" in g + # measurements/orphans subgroup must have been copied through. + assert "orphans" in g["measurements"] + + +def test_cli_convert_s3_olci_optimized(tmp_path: pathlib.Path) -> None: + """convert-s3-olci-optimized subcommand must write a GeoZarr measurements group.""" + import zarr + + # materialise a synthetic OLCI product to a zarr v2 store on disk + dt = build_synthetic_olci(rows=300, cols=300) + src = tmp_path / "olci_src.zarr" + dt.to_zarr(src, mode="w", consolidated=False) + out = tmp_path / "olci_out.zarr" + result = subprocess.run( + [ + sys.executable, + "-m", + "eopf_geozarr", + "convert-s3-olci-optimized", + str(src), + str(out), + "--spatial-chunk", + "256", + ], + capture_output=True, + text=True, + timeout=300, + ) + assert result.returncode == 0, result.stdout + result.stderr + g = zarr.open_group(str(out), mode="r") + assert "measurements" in g + + +def _assert_radiance_dtype_and_attrs( + group: zarr.Group, band_name: str, *, level_label: str +) -> None: + """Assert that *band_name* in *group* is uint16 with scale_factor and no stale attrs. + + This is a regression guard: the converter must preserve raw integer storage + and CF scale/offset, and must strip source-only attrs (_eopf_attrs, dtype, + valid_min, valid_max). + """ + band = group[band_name] + assert isinstance(band, zarr.Array), f"{level_label}/{band_name} is not a zarr.Array" + assert band.dtype == np.dtype("uint16"), ( + f"{level_label}/{band_name}: expected uint16, got {band.dtype}" + ) + attrs = dict(band.attrs) + assert "scale_factor" in attrs, ( + f"{level_label}/{band_name}: scale_factor missing from attrs (got {list(attrs)})" + ) + for stale_key in ("_eopf_attrs", "dtype", "valid_min", "valid_max"): + assert stale_key not in attrs, ( + f"{level_label}/{band_name}: stale attr '{stale_key}' present in output attrs" + ) + + +def test_olci_conversion_matches_snapshot( + s3_olci_group_example: pathlib.Path, + tmp_path: pathlib.Path, +) -> None: + """Snapshot test: converted OLCI structure must match committed golden file. + + The fixture is a Zarr v2 store representing a real OLCI L1 EFR product. + We open the whole DataTree so that conditions, quality, and + measurements/orphans subgroups are included in the conversion. + The fixture uses the real product's dimension names: tie-point grids reuse + 'columns' (at size 4) while measurement grids also use 'columns' (at size 16); + orphan arrays use removed_pixels=4. + + ``min_dimension=8`` is used so that the 16x16 measurements grid generates + one overview level (r2 at 8x8). + + To (re)generate the snapshot, uncomment the regeneration block below, + run the test once, then re-comment before committing. + """ + dt_in = xr.open_datatree( + str(s3_olci_group_example), + engine="zarr", + consolidated=False, + chunks={}, + mask_and_scale=False, + ) + out = str(tmp_path / "out.zarr") + convert_olci_optimized(dt_in, output_path=out, min_dimension=8) + + observed_group = zarr.open_group(out, use_consolidated=False) + observed_structure_json = GroupSpec.from_zarr(observed_group).model_dump() + + expected_path = Path("tests/_test_data/optimized_olci_examples") / ( + s3_olci_group_example.stem + ".json" + ) + + # Uncomment this block to (re)generate the snapshot from the observed structure. + # expected_path.parent.mkdir(parents=True, exist_ok=True) + # expected_path.write_text(json.dumps(observed_structure_json, indent=2, sort_keys=True)) + + observed_structure = GroupSpec(**tuplify_json(observed_structure_json)) + observed_structure_flat = observed_structure.to_flat() + expected_structure_json = tuplify_json(json.loads(expected_path.read_text())) + expected_structure = GroupSpec(**expected_structure_json) + expected_structure_flat = expected_structure.to_flat() + + o_keys = set(observed_structure_flat.keys()) + e_keys = set(expected_structure_flat.keys()) + assert o_keys == e_keys + assert [k for k in o_keys if observed_structure_flat[k] != expected_structure_flat[k]] == [] + + # Dtype/attrs regression guard: radiance must be stored as uint16 with + # scale_factor preserved and stale source attrs absent. + meas_g = observed_group["measurements"] + assert isinstance(meas_g, zarr.Group) + _assert_radiance_dtype_and_attrs(meas_g, "oa01_radiance", level_label="native") + if "r2" in meas_g: + r2_g = meas_g["r2"] + assert isinstance(r2_g, zarr.Group) + _assert_radiance_dtype_and_attrs(r2_g, "oa01_radiance", level_label="r2") + + +def test_convert_olci_odd_dims_overview_no_conflicting_sizes(tmp_path: object) -> None: + """Overview groups written from an odd-dimensioned swath must open without errors. + + Regression test for the off-by-one bug in reduce_swath where coordinate + decimation via [::factor] produced ceil(N/factor) elements while + coarsen(boundary="trim") produced floor(N/factor) for the radiance data. + On an odd-column real OLCI product (4865 cols) this caused xr.open_dataset + to raise ``ValueError: conflicting sizes for dimension 'columns'``. + + We use rows=10, cols=9 (odd cols) with min_dimension=4 so that two + overview levels (r2 at 5x4, r4 at 2x2) are generated. Each level is + opened via xr.open_dataset to confirm no conflicting-sizes error. + """ + dt = build_synthetic_olci(rows=10, cols=9) + out = str(tmp_path / "odd_olci.zarr") # type: ignore[operator] + convert_olci_optimized(dt, output_path=out, min_dimension=4) + + # Determine which overview groups were written. + import zarr as _zarr + + g = _zarr.open_group(out, mode="r") + meas = g["measurements"] + assert isinstance(meas, _zarr.Group) + overview_keys = sorted(meas.group_keys()) + # With rows=10, cols=9, min_dimension=4: + # floor(9/2)=4 >= 4 → r2 generated + # floor(4/2)=2 < 4 → stop + assert overview_keys == ["r2"], ( + f"Expected exactly ['r2'] for 10x9 at min_dimension=4, got {overview_keys}" + ) + + # Open each overview level; this must NOT raise a conflicting-sizes error. + for lvl in overview_keys: + ds = xr.open_dataset(out, engine="zarr", group=f"measurements/{lvl}", consolidated=False) + rad_shape = ds["oa01_radiance"].shape + lat_shape = ds["latitude"].shape + lon_shape = ds["longitude"].shape + assert rad_shape == lat_shape == lon_shape, ( + f"measurements/{lvl}: shapes disagree — " + f"oa01_radiance={rad_shape}, latitude={lat_shape}, longitude={lon_shape}" + ) + # r2 of a 10x9 swath must be (5, 4) = (floor(10/2), floor(9/2)) + if lvl == "r2": + assert rad_shape == (5, 4), f"r2 shape expected (5,4), got {rad_shape}" + ds.close() + + +def test_sanitize_olci_array_attrs_strips_stale_keeps_fill_value() -> None: + """_sanitize_olci_array_attrs must strip stale source attrs and preserve _FillValue. + + Unlike the shared sanitize_array_attrs (which always strips _FillValue), + the OLCI-local helper must preserve _FillValue so that downstream readers + and reduce_swath can identify fill pixels on raw uint16 data opened with + mask_and_scale=False. + """ + attrs: dict[str, object] = { + "_eopf_attrs": {"source": "some blob"}, + "dtype": "uint16", + "valid_min": 0, + "valid_max": 65534, + "scale_factor": 0.0139, + "add_offset": 0.0, + "_FillValue": 65535, + "units": "W m-2 sr-1 um-1", + "standard_name": "toa_upwelling_spectral_radiance", + "coordinates": "latitude longitude altitude", + } + result = _sanitize_olci_array_attrs(attrs) + # Stale source-only attrs must be removed. + assert "_eopf_attrs" not in result, "_eopf_attrs must be stripped" + assert "dtype" not in result, "dtype must be stripped" + assert "valid_min" not in result, "valid_min must be stripped" + assert "valid_max" not in result, "valid_max must be stripped" + # CF and fill attrs must be preserved. + assert result.get("scale_factor") == 0.0139, "scale_factor must be preserved" + assert result.get("add_offset") == 0.0, "add_offset must be preserved" + assert result.get("_FillValue") == 65535, "_FillValue must be preserved for OLCI raw uint16" + assert result.get("units") == "W m-2 sr-1 um-1", "units must be preserved" + assert result.get("standard_name") == "toa_upwelling_spectral_radiance" + assert result.get("coordinates") == "latitude longitude altitude" diff --git a/tests/test_olci_multiscale.py b/tests/test_olci_multiscale.py new file mode 100644 index 00000000..d7efd1c2 --- /dev/null +++ b/tests/test_olci_multiscale.py @@ -0,0 +1,292 @@ +"""Tests for olci_multiscale: decimate_swath, reduce_swath, swath_spatial_attrs.""" + +from __future__ import annotations + +import numpy as np +import pytest +import xarray as xr + +from eopf_geozarr.s3_olci_optimization.olci_multiscale import ( + decimate_swath, + reduce_swath, + swath_spatial_attrs, +) + + +def _swath(rows: int = 8, cols: int = 6) -> xr.Dataset: + """Minimal synthetic swath dataset with one radiance band and two coords.""" + rad = xr.DataArray( + np.arange(rows * cols, dtype="uint16").reshape(rows, cols), + dims=("rows", "columns"), + attrs={ + "scale_factor": 0.5, + "units": "mW.m-2.sr-1.nm-1", + "_FillValue": 65535, + }, + ) + lat = xr.DataArray( + np.linspace(0, 1, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "latitude"}, + ) + lon = xr.DataArray( + np.linspace(10, 11, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "longitude"}, + ) + return xr.Dataset( + {"oa01_radiance": rad}, + coords={"latitude": lat, "longitude": lon}, + ) + + +# --------------------------------------------------------------------------- +# decimate_swath tests +# --------------------------------------------------------------------------- + + +def test_decimate_halves_each_axis() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].shape == (4, 3) + assert out["latitude"].shape == (4, 3) + assert out["longitude"].shape == (4, 3) + + +def test_decimate_takes_every_other_pixel() -> None: + ds = _swath(8, 6) + out = decimate_swath(ds, factor=2) + # top-left pixel is preserved exactly (no averaging) + assert int(out["oa01_radiance"].values[0, 0]) == 0 + assert float(out["latitude"].values[0, 0]) == 0.0 + # interior pixel: stride-2 decimation means out[1, 1] comes from original [2, 2] + assert int(out["oa01_radiance"].values[1, 1]) == int(ds["oa01_radiance"].values[2, 2]) + + +def test_decimate_preserves_attrs() -> None: + out = decimate_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 + assert out["latitude"].attrs["standard_name"] == "latitude" + + +def test_decimate_factor_1_returns_unchanged() -> None: + ds = _swath(8, 6) + out = decimate_swath(ds, factor=1) + assert out["oa01_radiance"].shape == (8, 6) + + +def test_decimate_invalid_factor_raises() -> None: + with pytest.raises(ValueError, match="factor must be >= 1"): + decimate_swath(_swath(), factor=0) + + +# --------------------------------------------------------------------------- +# reduce_swath tests +# --------------------------------------------------------------------------- + + +def test_reduce_swath_halves_each_axis() -> None: + """reduce_swath must produce output with halved spatial dims.""" + out = reduce_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].shape == (4, 3) + assert out["latitude"].shape == (4, 3) + assert out["longitude"].shape == (4, 3) + + +def test_reduce_swath_radiance_is_averaged_not_decimated() -> None: + """Radiance must be block-averaged; top-left output != top-left input (unless accident).""" + rng = np.random.default_rng(42) + rad_data = rng.integers(100, 200, (8, 6)).astype("uint16") + rad = xr.DataArray( + rad_data, + dims=("rows", "columns"), + attrs={"_FillValue": 65535}, + ) + ds = xr.Dataset({"oa01_radiance": rad}) + out = reduce_swath(ds, factor=2) + # block [0:2, 0:2] averages to a value; verify it's a rounded mean + expected_block = int(np.round(rad_data[0:2, 0:2].astype("float64").mean())) + assert int(out["oa01_radiance"].values[0, 0]) == expected_block + + +def test_reduce_swath_coordinates_decimated() -> None: + """Coordinate arrays must be decimated (stride), not averaged.""" + ds = _swath(8, 6) + out = reduce_swath(ds, factor=2) + # lat[0,0] in output == lat[0,0] in input + assert float(out["latitude"].values[0, 0]) == float(ds["latitude"].values[0, 0]) + # lat[1,1] in output == lat[2,2] in input (stride-2) + assert float(out["latitude"].values[1, 1]) == float(ds["latitude"].values[2, 2]) + + +def test_reduce_swath_fill_value_preserved_in_all_fill_block() -> None: + """A block where all pixels are fill must produce fill output, not 65535.0 average.""" + fill = 65535 + rad_data = np.ones((4, 4), dtype="uint16") * fill + # put some non-fill values only in lower-right block + rad_data[2:4, 2:4] = 100 + rad = xr.DataArray( + rad_data, + dims=("rows", "columns"), + attrs={"_FillValue": fill}, + ) + ds = xr.Dataset({"oa01_radiance": rad}) + out = reduce_swath(ds, factor=2) + # top-left block: all fill -> output must be fill + assert int(out["oa01_radiance"].values[0, 0]) == fill + # bottom-right block: all 100 -> output must be 100 + assert int(out["oa01_radiance"].values[1, 1]) == 100 + + +def test_reduce_swath_preserves_attrs() -> None: + """reduce_swath must carry over variable attributes.""" + out = reduce_swath(_swath(8, 6), factor=2) + assert out["oa01_radiance"].attrs["scale_factor"] == 0.5 + assert out["latitude"].attrs["standard_name"] == "latitude" + + +def test_reduce_swath_factor_1_returns_unchanged() -> None: + ds = _swath(8, 6) + out = reduce_swath(ds, factor=1) + assert out["oa01_radiance"].shape == (8, 6) + + +def test_reduce_swath_invalid_factor_raises() -> None: + with pytest.raises(ValueError, match="factor must be >= 1"): + reduce_swath(_swath(), factor=0) + + +def test_reduce_swath_non_swath_var_passthrough() -> None: + """Variables that don't span (rows, columns) must pass through unchanged.""" + ds = _swath(8, 6) + scalar = xr.DataArray(42.0, attrs={"info": "scalar"}) + ds = ds.assign({"extra": scalar}) + out = reduce_swath(ds, factor=2) + assert "extra" in out + assert float(out["extra"].values) == 42.0 + + +# --------------------------------------------------------------------------- +# odd-dimension regression tests (real OLCI: 4865 columns is odd) +# --------------------------------------------------------------------------- + + +def _swath_odd(rows: int = 7, cols: int = 5) -> xr.Dataset: + """Synthetic swath with ODD spatial dimensions. + + Matches the real-world scenario where OLCI products have 4865 columns + (odd). Before the fix, reduce_swath on an odd-sized dimension produced + coordinate arrays one element longer than the corresponding radiance data + (ceil vs floor of N/factor), causing xr.open_dataset to raise a + conflicting-sizes error. + """ + fill = 65535 + rad = xr.DataArray( + np.arange(rows * cols, dtype="uint16").reshape(rows, cols), + dims=("rows", "columns"), + attrs={ + "scale_factor": 0.5, + "units": "mW.m-2.sr-1.nm-1", + "_FillValue": fill, + }, + ) + lat = xr.DataArray( + np.linspace(0, 1, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "latitude"}, + ) + lon = xr.DataArray( + np.linspace(10, 11, rows * cols).reshape(rows, cols), + dims=("rows", "columns"), + attrs={"standard_name": "longitude"}, + ) + return xr.Dataset( + {"oa01_radiance": rad}, + coords={"latitude": lat, "longitude": lon}, + ) + + +def test_reduce_swath_odd_dims_consistent_shape() -> None: + """reduce_swath must produce identical shapes for radiance AND coordinates on odd dims. + + Regression test for the off-by-one bug where coordinate decimation via + [::factor] yields ceil(N/factor) but coarsen(boundary="trim") yields + floor(N/factor). For rows=7, cols=5, factor=2 the expected output shape + is (floor(7/2), floor(5/2)) = (3, 2). + """ + ds = _swath_odd(rows=7, cols=5) + out = reduce_swath(ds, factor=2) + + expected_rows = 7 // 2 # 3 + expected_cols = 5 // 2 # 2 + + assert out["oa01_radiance"].shape == (expected_rows, expected_cols), ( + f"radiance shape {out['oa01_radiance'].shape} != ({expected_rows}, {expected_cols})" + ) + assert out["latitude"].shape == (expected_rows, expected_cols), ( + f"latitude shape {out['latitude'].shape} != ({expected_rows}, {expected_cols})" + ) + assert out["longitude"].shape == (expected_rows, expected_cols), ( + f"longitude shape {out['longitude'].shape} != ({expected_rows}, {expected_cols})" + ) + + +def test_reduce_swath_odd_dims_radiance_is_block_averaged() -> None: + """Radiance values must be block-averaged (not decimated) on odd-dim inputs.""" + rng = np.random.default_rng(7) + rows, cols = 7, 5 + rad_data = rng.integers(100, 200, (rows, cols)).astype("uint16") + rad = xr.DataArray( + rad_data, + dims=("rows", "columns"), + attrs={"_FillValue": 65535}, + ) + ds = xr.Dataset({"oa01_radiance": rad}) + out = reduce_swath(ds, factor=2) + # The top-left output pixel must be the rounded mean of the 2x2 input block. + expected = int(np.round(rad_data[0:2, 0:2].astype("float64").mean())) + assert int(out["oa01_radiance"].values[0, 0]) == expected + + +def test_reduce_swath_odd_dims_coords_decimated() -> None: + """Coordinate arrays must use stride decimation on odd-dim inputs.""" + ds = _swath_odd(rows=7, cols=5) + out = reduce_swath(ds, factor=2) + # Output[0,0] must equal input[0,0] (stride starts at 0). + assert float(out["latitude"].values[0, 0]) == float(ds["latitude"].values[0, 0]) + # Output[1,1] must equal input[2,2] (stride=2 -> second step at index 2). + assert float(out["latitude"].values[1, 1]) == float(ds["latitude"].values[2, 2]) + + +def test_reduce_swath_odd_simulates_real_olci_columns() -> None: + """Simulate the real-world OLCI case: 4090x4865 (odd cols) -> both 2432 cols. + + Uses smaller proxy dimensions that are proportionally odd to avoid + heavy memory use: rows=10, cols=9 with factor=2 must yield (5, 4) for + both radiance and coordinates. This specifically guards floor vs ceil + on the cols dimension (9 // 2 = 4, not 5). + """ + ds = _swath_odd(rows=10, cols=9) + out = reduce_swath(ds, factor=2) + expected = (10 // 2, 9 // 2) # (5, 4) + assert out["oa01_radiance"].shape == expected, ( + f"radiance shape {out['oa01_radiance'].shape} != {expected}" + ) + assert out["latitude"].shape == expected, ( + f"latitude shape {out['latitude'].shape} != {expected}" + ) + assert out["longitude"].shape == expected, ( + f"longitude shape {out['longitude'].shape} != {expected}" + ) + + +# --------------------------------------------------------------------------- +# swath_spatial_attrs tests +# --------------------------------------------------------------------------- + + +def test_swath_spatial_attrs_has_no_transform() -> None: + attrs = swath_spatial_attrs() + assert attrs["spatial:dimensions"] == ["rows", "columns"] + assert attrs.get("spatial:registration") == "pixel" + assert "spatial:transform" not in attrs + assert "spatial:bbox" not in attrs diff --git a/uv.lock b/uv.lock index 88d9e183..cca16cf0 100644 --- a/uv.lock +++ b/uv.lock @@ -214,6 +214,89 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, ] +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" }, + { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" }, + { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" }, + { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" }, + { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" }, + { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" }, + { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" }, + { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" }, + { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" }, + { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" }, + { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" }, +] + +[[package]] +name = "arrow" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, +] + +[[package]] +name = "async-lru" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/1f/989ecfef8e64109a489fff357450cb73fa73a865a92bd8c272170a6922c2/async_lru-2.3.0.tar.gz", hash = "sha256:89bdb258a0140d7313cf8f4031d816a042202faa61d0ab310a0a538baa1c24b6", size = 16332, upload-time = "2026-03-19T01:04:32.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/e2/c2e3abf398f80732e58b03be77bde9022550d221dd8781bf586bd4d97cc1/async_lru-2.3.0-py3-none-any.whl", hash = "sha256:eea27b01841909316f2cc739807acea1c623df2be8c5cfad7583286397bb8315", size = 8403, upload-time = "2026-03-19T01:04:30.883Z" }, +] + [[package]] name = "attrs" version = "26.1.0" @@ -260,6 +343,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/05/a4/a26d5b25671d27e03afb5401a0be5899d94ff8fab6a698b1ac5be3ec29ef/bandit-1.9.4-py3-none-any.whl", hash = "sha256:f89ffa663767f5a0585ea075f01020207e966a9c0f2b9ef56a57c7963a3f6f8e", size = 134741, upload-time = "2026-02-25T06:44:13.694Z" }, ] +[[package]] +name = "beautifulsoup4" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" }, +] + [[package]] name = "black" version = "26.3.1" @@ -292,6 +388,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8e/0d/52d98722666d6fc6c3dd4c76df339501d6efd40e0ff95e6186a7b7f0befd/black-26.3.1-py3-none-any.whl", hash = "sha256:2bd5aa94fc267d38bb21a70d7410a89f1a1d318841855f698746f8e7f51acd1b", size = 207542, upload-time = "2026-03-12T03:36:01.668Z" }, ] +[[package]] +name = "bleach" +version = "6.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", hash = "sha256:4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452", size = 204857, upload-time = "2026-06-05T13:01:13.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/9d/40b6267367182187139a4000b82a3b287d84d745bccd808e75d916920e9d/bleach-6.4.0-py3-none-any.whl", hash = "sha256:4b6b6a54fff2e69a3dde9d21cc6301220bee3c3cb792187d11403fd795031081", size = 165109, upload-time = "2026-06-05T13:01:12.504Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + [[package]] name = "boto3" version = "1.43.0" @@ -417,6 +530,63 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f4/2f/2d4f04e27c2481fd697522340df04f3a278dfe9a1f13292b2f9e39b98a44/cf_xarray-0.11.1-py3-none-any.whl", hash = "sha256:b55c77af7bc5c0768a65ab6eafef89646e5cbf003a12ec37513983565e25f888", size = 79377, upload-time = "2026-05-12T20:58:51.016Z" }, ] +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + [[package]] name = "cfgv" version = "3.5.0" @@ -564,6 +734,81 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + [[package]] name = "coverage" version = "7.13.5" @@ -716,6 +961,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/c6/c71e82e041c95ffe6a92ac707785500aa2a515a4339c2c7dd67e3c449249/cramjam-2.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:028400d699442d40dbda02f74158c73d05cb76587a12490d0bfedd958fd49188", size = 1713108, upload-time = "2025-07-27T21:24:10.147Z" }, ] +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + [[package]] name = "dask" version = "2026.3.0" @@ -742,6 +996,45 @@ distributed = [ { name = "distributed" }, ] +[[package]] +name = "debugpy" +version = "1.8.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/df/bf625547431a9cadc9f4cbfeda38866e2b17f6aed147b625377e87834449/debugpy-1.8.21-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:9f96713896f39c3dff0ee841f47320c3f2983d33c341e009361bb0ebc79adc4e", size = 2483609, upload-time = "2026-06-01T19:30:50.794Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/59324b903599031ff9faaec1758292409f6561a0ec2492fe4b703327705a/debugpy-1.8.21-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:c193d474f0a211191f2b4449d2d06157c689013035bd952f3b617e0ef422b176", size = 3968900, upload-time = "2026-06-01T19:30:52.341Z" }, + { url = "https://files.pythonhosted.org/packages/14/cd/27f65b805d7fe005c44e1a36b9183ecdfbcdbf9d3e721a5115d461ecc7ee/debugpy-1.8.21-cp312-cp312-win32.whl", hash = "sha256:4743373c1cac7f9e74a1b9915bf1dbe0e900eca657ffb170ae07ac8363205ae9", size = 5336340, upload-time = "2026-06-01T19:30:54.047Z" }, + { url = "https://files.pythonhosted.org/packages/77/1d/c84e30c0c674184948b66f076ab271c01d940618a2824c23cd035a27bc20/debugpy-1.8.21-cp312-cp312-win_amd64.whl", hash = "sha256:bd7ba9dd3daa7c2f942c6ca8d4695a16bf9ac16b63615261c7982bc74f7ed20c", size = 5374751, upload-time = "2026-06-01T19:30:55.891Z" }, + { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" }, + { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, + { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, +] + +[[package]] +name = "decorator" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + [[package]] name = "distlib" version = "0.4.0" @@ -829,6 +1122,11 @@ downstream-titiler = [ { name = "httpx" }, { name = "titiler-xarray" }, ] +notebooks = [ + { name = "jupyter" }, + { name = "matplotlib" }, + { name = "nbformat" }, +] test = [ { name = "jsondiff" }, { name = "pytest" }, @@ -854,7 +1152,7 @@ requires-dist = [ { name = "typing-extensions", specifier = ">=4.15.0" }, { name = "xarray", specifier = ">=2025.7.1" }, { name = "zarr", extras = ["cast-value-rs"], specifier = ">=3.2.0" }, - { name = "zarr-cm", git = "https://github.com/zarr-conventions/zarr-cm.git?rev=main" }, + { name = "zarr-cm", specifier = ">=0.4.1" }, ] [package.metadata.requires-dev] @@ -875,6 +1173,11 @@ downstream-titiler = [ { name = "httpx", specifier = ">=0.27.0" }, { name = "titiler-xarray", specifier = ">=2.0.0" }, ] +notebooks = [ + { name = "jupyter", specifier = ">=1.0.0" }, + { name = "matplotlib", specifier = ">=3.8.0" }, + { name = "nbformat", specifier = ">=5.9.0" }, +] test = [ { name = "jsondiff", specifier = ">=2.0.0" }, { name = "jsondiff", specifier = ">=2.2.1" }, @@ -894,6 +1197,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" }, ] +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + [[package]] name = "fastapi" version = "0.136.1" @@ -910,6 +1222,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", hash = "sha256:a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f", size = 117683, upload-time = "2026-04-23T16:49:42.437Z" }, ] +[[package]] +name = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, +] + [[package]] name = "filelock" version = "3.29.0" @@ -919,6 +1240,56 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" }, ] +[[package]] +name = "fonttools" +version = "4.63.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" }, + { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" }, + { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" }, + { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" }, + { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8d/d8fec3dcde2963f8c908fb315e5ff2cd0ac34f82394bbbf73a2aa5145ce3/fonttools-4.63.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd7e9857e5e63738b9d9fd707bc1f59c8b09e5177726d23664db393c59bb08bd", size = 2876062, upload-time = "2026-05-14T12:03:32.554Z" }, + { url = "https://files.pythonhosted.org/packages/ef/71/d935dc54e4ff121bfdd11e08702db63a7e6f25af21d8a3d7b7212df53641/fonttools-4.63.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c2a2a42198b696a6f48fad91709afb55176e66a5e566131219dba372fb7f8c59", size = 2424594, upload-time = "2026-05-14T12:03:34.86Z" }, + { url = "https://files.pythonhosted.org/packages/8e/40/e76320afa1df918e146155ef239b1719ee266092e96f5423bfd075affba1/fonttools-4.63.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e874792a8212b44583ea02189d9e693906b2f78b261f372f95d6c563210ac1d", size = 5024840, upload-time = "2026-05-14T12:03:36.745Z" }, + { url = "https://files.pythonhosted.org/packages/ce/36/0b805d8c485f872f65a509cbe3b58a5d0d17bee855333b54a150c79d3061/fonttools-4.63.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22135da48a348785c5e2d5d2d9d6bec5ed44adacbaeb9db12d9493bf6c6bfa68", size = 4975801, upload-time = "2026-05-14T12:03:38.833Z" }, + { url = "https://files.pythonhosted.org/packages/c8/26/2cee03d0aa083ab022da5c07aff9ed3f689da1defb81ad6917c9627896da/fonttools-4.63.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccf41f2efdf56994d22d73bef4ced1052161958169428d06ba9724ea9e9a64be", size = 4965009, upload-time = "2026-05-14T12:03:41.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" }, + { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" }, + { url = "https://files.pythonhosted.org/packages/27/d2/23d25e3f247b328be58d04a4c9f894178a0d1eda7d42867cfb388adaf416/fonttools-4.63.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fd1e3094f42d806d3d7c79162fc59e5910fcbe3a7360c385b8da969bc4493745", size = 2875338, upload-time = "2026-05-14T12:03:50.052Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/7dfa0c761cb3b2964e2a84c4dc986c926a87de0cb9fb60d5b28ded3f2914/fonttools-4.63.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6e528da43bc3791085f8cb6141b1d13e459226790240340fcbb4625649238b03", size = 2422661, upload-time = "2026-05-14T12:03:52.154Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/64cfa18a7a1621d17b7f4502b2b0ed8a135a90c3db51ea590ee99043e76b/fonttools-4.63.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b2248c5decb223562f7902ff6325077a073f608ee8e33e88ad88db734eb9f49", size = 5010526, upload-time = "2026-05-14T12:03:54.647Z" }, + { url = "https://files.pythonhosted.org/packages/36/e1/a8933a72c45a87177fbde2696e0d0755c8c9062f8c077a961c6215fa27b1/fonttools-4.63.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:308f957cdeaf8abe4e5f2f124902ef405448af92c90f80e302a3b771c2e6116b", size = 4923946, upload-time = "2026-05-14T12:03:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/872e6e233b8c5e8b41413796ff18b7fe479661bd40147e071b450dfad7a1/fonttools-4.63.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bf00f21eb5fb721dbaf73d1e9da6d02a1af7768f2ebcf9798be98beab8ba90f6", size = 4962489, upload-time = "2026-05-14T12:03:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/30/c4/83c24f2ec38b90cfda84bf4b1a1f49df80e84a1db4e7ac6e0d41bf23bc39/fonttools-4.63.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1aaa4b9c75798400ac043ce04d74e7830376c85095a5a6ed7cba2f17a266bf4", size = 5071870, upload-time = "2026-05-14T12:04:02.122Z" }, + { url = "https://files.pythonhosted.org/packages/de/40/3ae22b60ff1d41ce0bd044b31238cdc72cef99f28b976f1e128ebd618c9b/fonttools-4.63.0-cp314-cp314-win32.whl", hash = "sha256:22693918177bd9ceabec4736d338045f357769416fc6b0b2508eefef75b08616", size = 2295026, upload-time = "2026-05-14T12:04:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d4/98078064ccc76b45cb0f6c002452011e93c4bd26f6850344f0951cc1fe89/fonttools-4.63.0-cp314-cp314-win_amd64.whl", hash = "sha256:7d782fac32985914c351556f68ac0855391572bcd87de50e05970d3cd4c96fc5", size = 2347454, upload-time = "2026-05-14T12:04:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/49/4e/652d1580c5f4e39f7d103b0c793e4773129ad633dce4addd0cf4dfebde02/fonttools-4.63.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6db5140a60a5d731d21ec076745b40a310607731b0a565b50776393188649001", size = 2958152, upload-time = "2026-05-14T12:04:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/0e/55/ad864c9a9b219f552eb46b32cd7906c466e5a578ba0c3abfcc0fe7413eb6/fonttools-4.63.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d76edbff9014094dbf03bd2d074709dfa6ec7aba13d838c937a2b33d2d6a86e", size = 2460809, upload-time = "2026-05-14T12:04:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/0aa8db70f18cf52e49b4ed5ecec68547f981160bf5ded3b5aed6faa0a6f9/fonttools-4.63.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eac00b9118c3c2f87d272e45341871c5b3066baa3c86897fa634a7c3fb59096", size = 5148649, upload-time = "2026-05-14T12:04:12.747Z" }, + { url = "https://files.pythonhosted.org/packages/7f/63/18e4369c25043096f1048e0c9915951adc4f842bd81c6b18155824d6fa99/fonttools-4.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51394295f1a51de8b5f30bdb1e1b9a4231536c7064ef5c6e211eec19fa36036f", size = 4932147, upload-time = "2026-05-14T12:04:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/a1/3f/67f3eac2ffd8a98446c5022f8ed3864eac878a5ff7af8df4c8286dba16cc/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9e12f105d2b6342c559c298afb674006bb2893afc7102dcf8a1b55b0486b4e40", size = 5027237, upload-time = "2026-05-14T12:04:17.675Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ba/4e6214cb38a7b04779e97bb7636de9a5c7f20af7018d03dee0b64c08510a/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:796f27556dbe094c4824f75ca85267e4df776c79036c8441469a4df37038c196", size = 5053933, upload-time = "2026-05-14T12:04:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/34/3b/214dcc19ee31d3d38fb5ad2755c11ef0514e5dc300bbaf41c0b69f393799/fonttools-4.63.0-cp314-cp314t-win32.whl", hash = "sha256:948428a275741f0b64b113c955425a953314f4b9ab9997f73a72c83e68e569c8", size = 2359326, upload-time = "2026-05-14T12:04:24.22Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/3ff1a9b523058c2eeb6a9d50f5574e2a738200d0d94107d5bc4105e8da3f/fonttools-4.63.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6d4741eb179121cab9eea4cb2393d24492373a260d7945006358c08cfbf45419", size = 2425829, upload-time = "2026-05-14T12:04:26.829Z" }, + { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, +] + [[package]] name = "frozenlist" version = "1.8.0" @@ -1120,45 +1491,508 @@ wheels = [ ] [[package]] -name = "iniconfig" -version = "2.3.0" +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio2" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/c4/e4a38f579de4225a561305666f7541cdabb30075def2aa1ac17bd73c1fb5/ipykernel-7.3.0.tar.gz", hash = "sha256:9acaaaf97d16355166e4085afe9d225bfbdf2b7ef520f9df3be8f2b248275e09", size = 184899, upload-time = "2026-06-10T08:41:25.481Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/02/77b271f5dc58bfbc0b577c877b2365d1ffea2afe66a80c13f2312820348c/ipykernel-7.3.0-py3-none-any.whl", hash = "sha256:897eb64da762549ef610698fca5e9675195ec6ac8ec7f19d81ce1ca20c876057", size = 120583, upload-time = "2026-06-10T08:41:23.648Z" }, +] + +[[package]] +name = "ipython" +version = "9.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil", marker = "sys_platform != 'emscripten'" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e2/23/3a27530575643c8bb7bfc757a28e2e7ef80092afbf59a2bc5716320b6602/ipython-9.14.1.tar.gz", hash = "sha256:f913bf74df06d458e46ced84ca506c23797590d594b236fe60b14df213291e7b", size = 4433457, upload-time = "2026-06-05T08:12:34.921Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/22/58818a63eaf8982b67632b1bc20585c811611b15a8da19d6012323dc76a5/ipython-9.14.1-py3-none-any.whl", hash = "sha256:5d4a9ecaa3b10e6e5f269dd0948bdb58ca9cb851899cd23e07c320d3eb11613c", size = 627770, upload-time = "2026-06-05T08:12:33.045Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4c/ae/c5ce1edc1afe042eadb445e95b0671b03cee61895264357956e61c0d2ac0/ipywidgets-8.1.8.tar.gz", hash = "sha256:61f969306b95f85fba6b6986b7fe45d73124d1d9e3023a8068710d47a22ea668", size = 116739, upload-time = "2025-11-01T21:18:12.393Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/6d/0d9848617b9f753b87f214f1c682592f7ca42de085f564352f10f0843026/ipywidgets-8.1.8-py3-none-any.whl", hash = "sha256:ecaca67aed704a338f88f67b1181b58f821ab5dc89c1f0f5ef99db43c1c2921e", size = 139808, upload-time = "2025-11-01T21:18:10.956Z" }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jmespath" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" }, +] + +[[package]] +name = "json5" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/7d/05c46a96a78147ae3bf99c2f4169ce144a70220b8d6fcd56f6ec368b8ce9/json5-0.15.0.tar.gz", hash = "sha256:7424d1f1eb1d56da6e3d70643f53619862b4ce81440bdb8ecfd6f875e5ba4a71", size = 53278, upload-time = "2026-06-19T20:08:27.716Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/be/59527c99478aade6bb33a68d72e6e18dd4e6ff6eacfc7d01bdb15bc76912/json5-0.15.0-py3-none-any.whl", hash = "sha256:56636a30c0e8a4665fe2179c0212f32eae3796dea89ea6f649b9436ecdb39618", size = 36570, upload-time = "2026-06-19T20:08:26.748Z" }, +] + +[[package]] +name = "jsondiff" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/48/841137f1843fa215ea284834d1514b8e9e20962bda63a636c7417e02f8fb/jsondiff-2.2.1.tar.gz", hash = "sha256:658d162c8a86ba86de26303cd86a7b37e1b2c1ec98b569a60e2ca6180545f7fe", size = 26649, upload-time = "2024-08-29T04:09:06.201Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/94/a8066f84d62ab666d61ef97deba1a33126e3e5c0c0da2c458ada17053ed6/jsondiff-2.2.1-py3-none-any.whl", hash = "sha256:b1f0f7e2421881848b1d556d541ac01a91680cfcc14f51a9b62cdf4da0e56722", size = 13440, upload-time = "2024-08-29T04:09:04.955Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" }, +] + +[[package]] +name = "jupyter-builder" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/45/d0df8b43c10a61529c0f4a8af5e19ebe108f0c3af8f57e0fc358969907af/jupyter_builder-1.0.2.tar.gz", hash = "sha256:6155d78a5325010532a6419ffcba89eac643fd1aa56ea83115e661924d6f6aab", size = 968638, upload-time = "2026-06-12T02:33:25.767Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/b6/c418e0b3256f67c04933566b80bfce947350682db92c4b786a8653db32d6/jupyter_builder-1.0.2-py3-none-any.whl", hash = "sha256:b024f65d36e1d530542db597b00dd513261aa59842e0d0fbbb1015a9f1935e9c", size = 910789, upload-time = "2026-06-12T02:33:23.317Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/dc/5512503b088997c2250b8bf18258fba9d9ce5ead641183700960d3c9d342/jupyter_client-8.9.1.tar.gz", hash = "sha256:a58f730dd9e728ba16ba1d62ebccf7ffe1ebbdbce4e95cfae941b7321ae1f4fa", size = 359256, upload-time = "2026-06-09T13:15:01.033Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/6f/56d39bf385c5c27988aebaf0c18a2a17e960575740100973511018bd904e/jupyter_client-8.9.1-py3-none-any.whl", hash = "sha256:0b7a295bc46e8751e9adae84781f726c851c1d911bd793edc4a3bde942e3da81", size = 109828, upload-time = "2026-06-09T13:14:58.835Z" }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/f8/475c4241b2b75af0deaae453ed003c6c851766dbc44d332d8baf245dc931/jupyter_events-0.12.1.tar.gz", hash = "sha256:faff25f77218335752f35f23c5fe6e4a392a7bd99a5939ccb9b8fbf594636cf3", size = 62854, upload-time = "2026-04-20T23:17:50.66Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/6c/6fcde0c8f616ed360ffd3587f7db9e225a7e62b583a04494d2f069cf64ea/jupyter_events-0.12.1-py3-none-any.whl", hash = "sha256:c366585253f537a627da52fa7ca7410c5b5301fe893f511e7b077c2d93ec8bcf", size = 19512, upload-time = "2026-04-20T23:17:48.927Z" }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/ff/1e4a61f5170a9a1d978f3ac3872449de6c01fc71eaf89657824c878b1549/jupyter_lsp-2.3.1.tar.gz", hash = "sha256:fdf8a4aa7d85813976d6e29e95e6a2c8f752701f926f2715305249a3829805a6", size = 55677, upload-time = "2026-04-02T08:10:06.749Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/e8/9d61dcbd1dce8ef418f06befd4ac084b4720429c26b0b1222bc218685eff/jupyter_lsp-2.3.1-py3-none-any.whl", hash = "sha256:71b954d834e85ff3096400554f2eefaf7fe37053036f9a782b0f7c5e42dadb81", size = 77513, upload-time = "2026-04-02T08:10:01.753Z" }, +] + +[[package]] +name = "jupyter-server" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6b/dc/db3a582633170186f8c8b31298d7eb26ad0eb031a1f53476c258b64eed05/jupyter_server-2.20.0.tar.gz", hash = "sha256:b5778ba337d8015a3dc2b80803ecdd5ac18d3797fddf61a50ea5fb472b4ebe14", size = 756523, upload-time = "2026-06-17T12:09:09.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/71/8c002223e873a870f5c41dc69b0a7c922301123e4a31d5d01ecb700aef77/jupyter_server-2.20.0-py3-none-any.whl", hash = "sha256:c3b67c93c471e947c18b5026f04f21614218adb706df8f48227d3ee8e0a7cdcc", size = 393143, upload-time = "2026-06-17T12:09:07.234Z" }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" }, +] + +[[package]] +name = "jupyterlab" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-builder" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/3c/1ebd737b860cdbe61eed71536d06aab4e1781fbdcf07ecd5a1afe05b8adf/jupyterlab-4.6.0.tar.gz", hash = "sha256:6a8b88f2aae7ed4d012c634fc957c1a27f3aa217c32f0ced0175fac9ee17f9e5", size = 28181861, upload-time = "2026-06-18T13:52:56.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/eb/aa48075d0aa3d0188db34ba2704f53791757743c0bb02e18c4eef989b6de/jupyterlab-4.6.0-py3-none-any.whl", hash = "sha256:b6938cb8a1ef3d43860ff4745a680c62cc0a9385f9672295bb56cd2e7cfeebe2", size = 17143447, upload-time = "2026-06-18T13:52:51.42Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, ] [[package]] -name = "jinja2" -version = "3.1.6" +name = "jupyterlab-server" +version = "2.28.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markupsafe" }, + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, + { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" }, ] [[package]] -name = "jmespath" -version = "1.1.0" +name = "jupyterlab-widgets" +version = "3.0.16" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" } +sdist = { url = "https://files.pythonhosted.org/packages/26/2d/ef58fed122b268c69c0aa099da20bc67657cdfb2e222688d5731bd5b971d/jupyterlab_widgets-3.0.16.tar.gz", hash = "sha256:423da05071d55cf27a9e602216d35a3a65a3e41cdf9c5d3b643b814ce38c19e0", size = 897423, upload-time = "2025-11-01T21:11:29.724Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" }, + { url = "https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl", hash = "sha256:45fa36d9c6422cf2559198e4db481aa243c7a32d9926b500781c830c80f7ecf8", size = 914926, upload-time = "2025-11-01T21:11:28.008Z" }, ] [[package]] -name = "jsondiff" -version = "2.2.1" +name = "kiwisolver" +version = "1.5.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/35/48/841137f1843fa215ea284834d1514b8e9e20962bda63a636c7417e02f8fb/jsondiff-2.2.1.tar.gz", hash = "sha256:658d162c8a86ba86de26303cd86a7b37e1b2c1ec98b569a60e2ca6180545f7fe", size = 26649, upload-time = "2024-08-29T04:09:06.201Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, +] + +[[package]] +name = "lark" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/63/94/a8066f84d62ab666d61ef97deba1a33126e3e5c0c0da2c458ada17053ed6/jsondiff-2.2.1-py3-none-any.whl", hash = "sha256:b1f0f7e2421881848b1d556d541ac01a91680cfcc14f51a9b62cdf4da0e56722", size = 13440, upload-time = "2024-08-29T04:09:04.955Z" }, + { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, ] [[package]] @@ -1254,6 +2088,72 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, ] +[[package]] +name = "matplotlib" +version = "3.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/24/080c99d223d158d3a8902769269ab6da5b50f7a0e6e072513907e02b7a6c/matplotlib-3.11.0.tar.gz", hash = "sha256:68c0c7be01b30dcca3638934f7f591df73401235cbdbf0d1ab1c71e7db7f8b57", size = 33251176, upload-time = "2026-06-12T02:29:15.508Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/17/f5276b496c61477a6c4fc5e7401f4bfe1c2e5ef7c6cd67896f2ade3809cb/matplotlib-3.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:06b5872e9cf11adc8f589ded3ce11bc3e1061ad498259664fabc1f6615beb918", size = 9449976, upload-time = "2026-06-12T02:27:50.989Z" }, + { url = "https://files.pythonhosted.org/packages/82/34/bdd77418adb2178a1d59f044bd67bfebb115896e91b840b8a197eb3f4f4e/matplotlib-3.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0515d495124be3124340e59f164d901ed4484e2246a5b74cfa483cac3b80bd97", size = 9279307, upload-time = "2026-06-12T02:27:53.247Z" }, + { url = "https://files.pythonhosted.org/packages/94/95/7f522393c88313336b20d70fc849555757b2e5febc22b83b3a3f0fd4bce9/matplotlib-3.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be5f93a1d21981bfb802ded0d77a0caa92d4342a47d45754fac77e314a506344", size = 10031353, upload-time = "2026-06-12T02:27:55.215Z" }, + { url = "https://files.pythonhosted.org/packages/87/ce/8f25a0e3186aefd61913e7467d1b999465bcd0d0c03ac695c1b26ca559b7/matplotlib-3.11.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41635d7909d19e52e924a521dde6d8f670b0f53ab1d0e8c331fa831554f681d1", size = 10839232, upload-time = "2026-06-12T02:27:57.746Z" }, + { url = "https://files.pythonhosted.org/packages/85/c2/db15da2bbdf9e3ca66df7db8e2c33a1dfed67be24a24d2c878efaaff01d6/matplotlib-3.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:94f5000f67ca9faa300863ea17f8bce9175cb67b88bec4bc7780502d53dd7c9e", size = 10923899, upload-time = "2026-06-12T02:28:00.223Z" }, + { url = "https://files.pythonhosted.org/packages/e5/2f/a58a4443a4d052a4ea77557478336aefc26c7981f6408d37adba763aa758/matplotlib-3.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:ac6f1ef39f3d0f9e2463303013094992cdbe0f85f43bc54155bc472b2042768e", size = 9329528, upload-time = "2026-06-12T02:28:02.27Z" }, + { url = "https://files.pythonhosted.org/packages/61/0f/4b669589d47733b97ab9df4b58d6fc1e68acb5ea42a928dc7cbdd6bf5871/matplotlib-3.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:9dd11fb612ce7bc60b1de5b4fc87ff959d22317b5de42aabf392f66f97af22eb", size = 9003413, upload-time = "2026-06-12T02:28:04.49Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/aa47f156b061d14c98b906f76c428507397708ec63ff94f410ae1752b426/matplotlib-3.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6ce3b839b34ae1f430b4616893a2945a2999debaa7e94e7e29a2a8bbf286f7b5", size = 9450532, upload-time = "2026-06-12T02:28:06.769Z" }, + { url = "https://files.pythonhosted.org/packages/8c/4f/5a9eb0375e81413953febf8af7b012a6b6357f53438a15c4f5ad86c6bbb5/matplotlib-3.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:373db8f91214e8ccaf35ac833cc1dd59dd961e148bbd55dd027141591dde1313", size = 9279760, upload-time = "2026-06-12T02:28:09.152Z" }, + { url = "https://files.pythonhosted.org/packages/a4/c0/1117d53077e3ac3152503a84e9cf7a5c239576805ee71276e80c2aaa7471/matplotlib-3.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be152b7570324dc8d01574cc9474dd2d803237acf528bcbb5b211fa347461a09", size = 10031623, upload-time = "2026-06-12T02:28:11.26Z" }, + { url = "https://files.pythonhosted.org/packages/92/7e/e937138daffad65b71bf831a377809dcbc830fb4f31a31e067dc1faa2575/matplotlib-3.11.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:126f256df600652d7e4b394cf3164ff75210a00038f287c95a012a6f58d0e83f", size = 10839372, upload-time = "2026-06-12T02:28:14.102Z" }, + { url = "https://files.pythonhosted.org/packages/1d/c2/438ecc197ffb8023b6b9922915542f2172f5fd45b76703b0b4fc47322243/matplotlib-3.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:03acfeddf87b0dddb11b081ef7740ad445a3ca8bcb6b8e3011b08f2cf802b75c", size = 10924099, upload-time = "2026-06-12T02:28:16.383Z" }, + { url = "https://files.pythonhosted.org/packages/40/2e/395883da416f378b3ed2c9f3e843ac477eae1ce731b671b79adaa6f0bacd/matplotlib-3.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:ab3722f04f3ff34c23b5012c5873d2894174e06c3822fcdac3610965a5ac7d06", size = 9329727, upload-time = "2026-06-12T02:28:18.581Z" }, + { url = "https://files.pythonhosted.org/packages/61/82/2c388956abf8bf392dfb5b8917c502f1082df6a941b781ab8c8e5ba2474b/matplotlib-3.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:c945824670fb8915b4ac879e5e61f3c58e0913022f70a0de4c082b17372f8771", size = 9003506, upload-time = "2026-06-12T02:28:20.474Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c1/34454baa44da7975ada82e9aea37105ec47059514dc967d3be14426ba8dc/matplotlib-3.11.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3489c3dc487669b4a980bc3068f87856de7a1564248d3f6c629efb2a58b03f24", size = 9499838, upload-time = "2026-06-12T02:28:22.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c3/98fe79a398cf232219f090163a7fa7e6766e9f2e0ad26df54d6f8934d8ee/matplotlib-3.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6a98f5476ce784a50ce09998f4ae1e6a9f25043cef8a480c98949902eda74620", size = 9332298, upload-time = "2026-06-12T02:28:24.796Z" }, + { url = "https://files.pythonhosted.org/packages/95/e4/b4b7c33151e74e5c802f3cde1ba807ebfc38401e329b44e215a5888dd76d/matplotlib-3.11.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:565af866fd63e4bd3f987d580afe27c44c2552a3b3305f4ecbb85133601ea6f3", size = 10045491, upload-time = "2026-06-12T02:28:27.141Z" }, + { url = "https://files.pythonhosted.org/packages/71/28/394548efd68354110c1a1be11fe6b6e559e06d1a23da35908a0e316c55a9/matplotlib-3.11.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6b3e64dea5062c570f04358e2711859f3531b459f29516274fbad889079e4f3", size = 10857059, upload-time = "2026-06-12T02:28:29.222Z" }, + { url = "https://files.pythonhosted.org/packages/c8/44/e7922e6e2a4d63bdfbc9dc4a53e3850ab438d46cf42e6779bb15ec92c948/matplotlib-3.11.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:942b37c5db1899610bd1543ce8e13e4ecff9a4633e7f63bb6aa9205d2644ebd1", size = 10939576, upload-time = "2026-06-12T02:28:31.66Z" }, + { url = "https://files.pythonhosted.org/packages/3d/be/b1ca96003a441d619b727fee21d671fdff7a5ce2f1bb797b2521aa2f679a/matplotlib-3.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:c08e649a6313e1291e713623b97a38e5bb4aa580b2a100a94a3309bc6b9c8eb3", size = 9379519, upload-time = "2026-06-12T02:28:33.888Z" }, + { url = "https://files.pythonhosted.org/packages/e3/72/4bf3b91821c34596dd6a7bdac5836d94f744144c8208939ef49d8ec43f7e/matplotlib-3.11.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2746cd2c113742ff6ce37a864c5ac5fd7aa644568f445e66166e457ac78e40e0", size = 9055456, upload-time = "2026-06-12T02:28:35.878Z" }, + { url = "https://files.pythonhosted.org/packages/57/52/a94102ac99eb78e2fe9b826674f9ef9ee23327110ea6ab4776c1b4eb6209/matplotlib-3.11.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3338e3e3de128cf50d0d2fb92a122815daf9c755bd882a474343c05f8fd7ec79", size = 9452137, upload-time = "2026-06-12T02:28:37.93Z" }, + { url = "https://files.pythonhosted.org/packages/7c/03/b8cdb625a21f710dfa11bbca1f48fb4057d2c0286975f8b415bf80942c99/matplotlib-3.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:25c2e5455efd8d99f41fb79871a31feb7d301569642e332ec58d72cfe9282bc3", size = 9281514, upload-time = "2026-06-12T02:28:40.028Z" }, + { url = "https://files.pythonhosted.org/packages/b7/2d/4e1240ea82ee197dfb3851e71f71c87eeeb975f1753b56a0588e4e80739a/matplotlib-3.11.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9695457a467ff86d23f35037a43deb6f1134dd6d3e2ac8ce1e2087cff09ffb9", size = 10843005, upload-time = "2026-06-12T02:28:42.39Z" }, + { url = "https://files.pythonhosted.org/packages/29/dc/6377ecfaa5fef79430f74a1a16638b4e2aa30d4692bae2c19f9d76fe3b01/matplotlib-3.11.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19c16c61dea63b3582918503e6b294193961261d9daa806d4ae2151f1ad05430", size = 11127459, upload-time = "2026-06-12T02:28:44.483Z" }, + { url = "https://files.pythonhosted.org/packages/6f/41/795c405aa7560443a3b01309424cde4a1113b85c90b8a63417444a749617/matplotlib-3.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2d72ea8b7924f3cb955e61518d21e43b3df1e6c8a793b480a0c1214f185d30ba", size = 10925160, upload-time = "2026-06-12T02:28:46.564Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f7/3a9e6389a7cfaeff76c56e40c2dabcb13110e21e82f837228c834ebe748c/matplotlib-3.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:1c02da0a629dfa9debf52725ea06866b74c1fb70a895bae05e4493d34074f9f2", size = 9485186, upload-time = "2026-06-12T02:28:49.344Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c0/396478ee7cf2091d182db8b4a8695f6a37f1ddb978989cf9dbb84cd5c123/matplotlib-3.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:aa55d73b3117d4b07f959cd9eb6f69b375d8df3414139c479388e551aa5d999d", size = 9160349, upload-time = "2026-06-12T02:28:51.382Z" }, + { url = "https://files.pythonhosted.org/packages/c5/6f/1c3bd51bb2b34eaacdcf3c3d859dbb357f952fc8020c617dc118ad7c9e38/matplotlib-3.11.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a9d8c6e7cd2f0ddf11d8d92e520dd1d9d2abb0cf6ac8831e338666c81e905847", size = 9500921, upload-time = "2026-06-12T02:28:53.443Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/4d861d0121840cb1a3fd4a10deb211efd6fccd481ed23e553f31f4f4da4a/matplotlib-3.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:be050fcf32f729eda99f7f75a80bf67612ce16ab9ac1c23a387dcaede95cb70e", size = 9332190, upload-time = "2026-06-12T02:28:55.623Z" }, + { url = "https://files.pythonhosted.org/packages/4b/cb/22f6bc35711a0b5639a784e74e653e77c86210bd4304449dd399a482f74e/matplotlib-3.11.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfabef0230d0697aa0d717385194dd41162e00207a68bf4abf94c2bf4c27dca0", size = 10854181, upload-time = "2026-06-12T02:28:57.856Z" }, + { url = "https://files.pythonhosted.org/packages/3f/7e/9a9eaca731a2939589da520f0ebe8fd8753d0f51fca98c7d20af6dbe261a/matplotlib-3.11.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1644db30e759199443493ac5e5caec24fdb775a8f6123021f85ba47c4133c3cb", size = 11137715, upload-time = "2026-06-12T02:29:00.555Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f9/9b030b6088354acb0296871bb624b25befc1c42509d3c6cd17420c83a5b8/matplotlib-3.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:15b0d160079cb10699a0e98b5989c70677b2df7cacdc62af67c30f2facec46d9", size = 10939427, upload-time = "2026-06-12T02:29:02.527Z" }, + { url = "https://files.pythonhosted.org/packages/59/94/6b273eaee4ee250863567d100865da61a5c1527fa67f527b7ed22e0dd29c/matplotlib-3.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:446307e6b04b57b1f1239e228a1ec2af0d589a1008cebc3dfa3f5441d095cfb6", size = 9535809, upload-time = "2026-06-12T02:29:04.994Z" }, + { url = "https://files.pythonhosted.org/packages/60/95/1d36bddf2b7e2692c1540e78a6e5bc88bc1496b137e3e35a611f91b65ac3/matplotlib-3.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:652fb5696271d4c50f196d22a5ff4f8e4444c74f847423570d7dc0aa2bbd0159", size = 9209226, upload-time = "2026-06-12T02:29:07.033Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, +] + [[package]] name = "mdurl" version = "0.1.2" @@ -1289,6 +2189,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/76/8e/56ccb09c7232a55403a7637caa21922f3b65901a37f5e8bdb405d0de0946/mike-2.2.0-py3-none-any.whl", hash = "sha256:e1f4981c1152eec7c2490a3401142292cc47d686194188416db2648fdfe1d040", size = 34026, upload-time = "2026-04-14T04:59:02.602Z" }, ] +[[package]] +name = "mistune" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/04/5f/007786743f962224423753b78f7d7acb0f2ade46d1604f2e0fa2bedf9020/mistune-3.3.2.tar.gz", hash = "sha256:e12ee4f1e74336e91aa1141e35f913b337c40bdf7c0cc49f21fb853a27e8b62f", size = 111284, upload-time = "2026-06-23T00:29:28.568Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/43/894c2cbbcbdf53b57d1257a249811abe2ee9ab7ef76af301b40f1c054533/mistune-3.3.2-py3-none-any.whl", hash = "sha256:a678a56387d487db7368ede4647cb2ba1deff22ce61f92343e4ebe0ddfce4f2d", size = 61554, upload-time = "2026-06-23T00:29:27.088Z" }, +] + [[package]] name = "mkdocs" version = "1.6.1" @@ -1525,6 +2434,70 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, ] +[[package]] +name = "nbclient" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", hash = "sha256:ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895", size = 25288, upload-time = "2026-06-05T07:52:40.115Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[package]] +name = "nest-asyncio2" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b4/73/731debf26e27e0a0323d7bda270dc2f634b398e38f040a09da1f4351d0aa/nest_asyncio2-1.7.2.tar.gz", hash = "sha256:1921d70b92cc4612c374928d081552efb59b83d91b2b789d935c665fa01729a8", size = 14743, upload-time = "2026-02-13T00:34:04.386Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/3c/3179b85b0e1c3659f0369940200cd6d0fa900e6cefcc7ea0bc6dd0e29ffb/nest_asyncio2-1.7.2-py3-none-any.whl", hash = "sha256:f5dfa702f3f81f6a03857e9a19e2ba578c0946a4ad417b4c50a24d7ba641fe01", size = 7843, upload-time = "2026-02-13T00:34:02.691Z" }, +] + [[package]] name = "nodeenv" version = "1.10.0" @@ -1534,6 +2507,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, ] +[[package]] +name = "notebook" +version = "7.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-builder" }, + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/44/d5c65783f490298473bb1c05722e05ee2256231389559c2c5ae0a3e5d975/notebook-7.6.0.tar.gz", hash = "sha256:ea13e79e601bf273074895fdfb17dd3f2da916d3c045e0b9c47d18b16ab62481", size = 5497344, upload-time = "2026-06-18T16:18:55.202Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d1/e617c40db57ff40e75f43a7d4d1c305e3a54c053ab5cb0534a6c314664f9/notebook-7.6.0-py3-none-any.whl", hash = "sha256:98aa2811b54ac191321d5dfce12ca700f8a511a33a26e4de2fa106a357c43d6a", size = 5544575, upload-time = "2026-06-18T16:18:52.551Z" }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, +] + [[package]] name = "numcodecs" version = "0.16.5" @@ -1793,6 +2795,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/2b/f8434233fab2bd66a02ec014febe4e5adced20e2693e0e90a07d118ed30e/pandas-3.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:5371b72c2d4d415d08765f32d689217a43227484e81b2305b52076e328f6f482", size = 9455341, upload-time = "2026-03-31T06:48:28.418Z" }, ] +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + [[package]] name = "partd" version = "1.4.2" @@ -1815,6 +2835,87 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, ] +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, +] + [[package]] name = "platformdirs" version = "4.9.6" @@ -1849,6 +2950,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" }, ] +[[package]] +name = "prometheus-client" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/fb/d9aa83ffe43ce1f19e557c0971d04b90561b0cfd50762aafb01968285553/prometheus_client-0.25.0.tar.gz", hash = "sha256:5e373b75c31afb3c86f1a52fa1ad470c9aace18082d39ec0d2f918d11cc9ba28", size = 86035, upload-time = "2026-04-09T19:53:42.359Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/9b/d4b1e644385499c8346fa9b622a3f030dce14cd6ef8a1871c221a17a67e7/prometheus_client-0.25.0-py3-none-any.whl", hash = "sha256:d5aec89e349a6ec230805d0df882f3807f74fd6c1a2fa86864e3c2279059fed1", size = 64154, upload-time = "2026-04-09T19:53:41.324Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + [[package]] name = "propcache" version = "0.4.1" @@ -1961,6 +3083,33 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, ] +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + [[package]] name = "pydantic" version = "2.13.4" @@ -2294,6 +3443,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, ] +[[package]] +name = "python-json-logger" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f7/ff/3cc9165fd44106973cd7ac9facb674a65ed853494592541d339bdc9a30eb/python_json_logger-4.1.0.tar.gz", hash = "sha256:b396b9e3ed782b09ff9d6e4f1683d46c83ad0d35d2e407c09a9ebbf038f88195", size = 17573, upload-time = "2026-03-29T04:39:56.805Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/be/0631a861af4d1c875f096c07d34e9a63639560a717130e7a87cbc82b7e3f/python_json_logger-4.1.0-py3-none-any.whl", hash = "sha256:132994765cf75bf44554be9aa49b06ef2345d23661a96720262716438141b6b2", size = 15021, upload-time = "2026-03-29T04:39:55.266Z" }, +] + [[package]] name = "pytokens" version = "0.4.1" @@ -2323,6 +3481,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" }, ] +[[package]] +name = "pywinpty" +version = "3.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/ef/2d27f30c59a67be7025b2d7858c8c2d282b74d66544b2384730b82de74fd/pywinpty-3.0.5.tar.gz", hash = "sha256:61db0db063de9865adbea66db294628f8577f608d9764a4c7d3384eeacc4e81b", size = 16223484, upload-time = "2026-06-11T00:11:58.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/34/942cc95ca4e26489875aa8a95192766247a687379ec29543eebe73ec945f/pywinpty-3.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:d62946adf14b15b54c0b8d785f93fe18b04da23f4ad59e2e8c4612646e9abd23", size = 2090915, upload-time = "2026-06-10T23:43:14.98Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/5b9053004844139ea8bd86209c57ade12b134b2782f383a095784c8531ec/pywinpty-3.0.5-cp312-cp312-win_arm64.whl", hash = "sha256:e9391c05fbfa7a992a97e831fc6849887b4014a614192e3d984a7ca59592b376", size = 815934, upload-time = "2026-06-10T23:41:42.384Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f4/2a464b9893cceb3b3f416356e94fdc3e1bca9476993927e4e6d99fe95382/pywinpty-3.0.5-cp313-cp313-win_amd64.whl", hash = "sha256:48db1b0ad9d0a1b81dcaaa7163a99a7808deaceb0c1b2344716dc1fc090c3c4c", size = 2090471, upload-time = "2026-06-10T23:42:11.071Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2c/a138491a0afbdb50eb79395577bd326d4b0fbde7209417d1a8087ff2493a/pywinpty-3.0.5-cp313-cp313-win_arm64.whl", hash = "sha256:2c6008fb2d3774b48693b2fcb7f2cc317ade9dc581289a964ffeeaf81307c9b5", size = 815518, upload-time = "2026-06-10T23:42:02.363Z" }, + { url = "https://files.pythonhosted.org/packages/6f/15/54400049a380582acd1282665c70fcf11e0bd3713679aca78e24c3aae738/pywinpty-3.0.5-cp313-cp313t-win_amd64.whl", hash = "sha256:22ce1b780d89821cc52daf6eac0708af22d93d000ce9c7c07e37489db8594598", size = 2089920, upload-time = "2026-06-10T23:44:13.395Z" }, + { url = "https://files.pythonhosted.org/packages/94/0c/6f24f3c0799f502259b24bdf841a99ad2b0d59df5c2525b4e2a286d14be2/pywinpty-3.0.5-cp313-cp313t-win_arm64.whl", hash = "sha256:9c2919a81bc5cfb09b86fc5a002112b2de95ca4304a07413cbeeb746a1307a5c", size = 814520, upload-time = "2026-06-10T23:43:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/e9/23/f3cd1b1e5fc56517f54452c49f92049e7dd9ffc8a63de22a495581f50d04/pywinpty-3.0.5-cp314-cp314-win_amd64.whl", hash = "sha256:03bb3c16d691d9242267201830bcd0e64a9b663170e9042bc84b210da9de15ac", size = 2090663, upload-time = "2026-06-10T23:43:59.845Z" }, + { url = "https://files.pythonhosted.org/packages/9d/dd/96d6cbfc6d9ddab5c1c2f92c26545ae8997446a2ba7ee2024cd43c81f49b/pywinpty-3.0.5-cp314-cp314-win_arm64.whl", hash = "sha256:89c5c6ef08997a3b4b277b214a35fe15cab4dd6d119f0140aa71df5b1168fdbc", size = 815700, upload-time = "2026-06-10T23:40:50.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/36/d98087bce0acaa4cce7f196103cfa7be3f63ce65f52473bb3e38784ae5d9/pywinpty-3.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7b566165e0c5fdd6abe167a5ac8b954be6a843eb55a85946576d6bc1dea03d6d", size = 2090093, upload-time = "2026-06-10T23:40:58.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/fd/fe2b0db922ba052ce3976a08f3fc05d0c05047c8b4ebb6102e832b8ef563/pywinpty-3.0.5-cp314-cp314t-win_arm64.whl", hash = "sha256:24366280a8aa677323da87bec729cb3ea3b35367386cece0978bdc6e4695c690", size = 814517, upload-time = "2026-06-10T23:42:34.946Z" }, +] + [[package]] name = "pyyaml" version = "6.0.3" @@ -2381,6 +3557,49 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" }, ] +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, +] + [[package]] name = "rasterio" version = "1.5.0" @@ -2428,6 +3647,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6e/d1/8b017856e63ccaff3cbd0e82490dbb01363a42f3a462a41b1d8a391e1443/rasterio-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:f4b9c2c3b5f10469eb9588f105086e68f0279e62cc9095c4edd245e3f9b88c8a", size = 29418321, upload-time = "2026-01-05T16:06:44.758Z" }, ] +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + [[package]] name = "requests" version = "2.33.1" @@ -2443,6 +3676,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" }, ] +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, +] + [[package]] name = "rich" version = "15.0.0" @@ -2494,6 +3760,116 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3f/dd/0b2c68495331ba36af783139baaa94693ef310d484d458c11dfa1357287d/rioxarray-0.22.0-py3-none-any.whl", hash = "sha256:db0aa55cd36a95060968f2e6574107829def29d43a563560b90bc642d0bd6a3b", size = 72018, upload-time = "2026-03-06T17:10:58.965Z" }, ] +[[package]] +name = "rpds-py" +version = "2026.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2e/43/25a8dcd3feedd735039a8f0b5b7e3b118232b5eae288c4fd9ab200d41094/rpds_py-2026.5.1.tar.gz", hash = "sha256:07b24fea40541e28570e5b795a4a38fbdcd12550c06bd0748005ecc8116ca256", size = 64459, upload-time = "2026-05-28T12:02:13.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/e7/a78582dc57caa592dcc7d4fb69b61390561e908eb3d2f5df5928a8e354c0/rpds_py-2026.5.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3abe24a66e57adcfa645d718063a5fa5103ecc71ddbf26d78af8f9368018ff1d", size = 353040, upload-time = "2026-05-28T11:59:12.531Z" }, + { url = "https://files.pythonhosted.org/packages/a3/43/35e3f136343aef451e545ce8c38d36c2f93c0ed88703db8b64ba2b205c68/rpds_py-2026.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58b1d94308ddf0b1982f61f2eb54bf92997c9ece8a8093ef014250f4a517906c", size = 345775, upload-time = "2026-05-28T11:59:13.827Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/0f2160c5982d3157734d5cb3ed63d8b2d583a73c9864f77b666449f32cf8/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fa92420128dadce7f54bd73ba1825a273e9268fe9e35dbf7e6362890efa4e08", size = 376329, upload-time = "2026-05-28T11:59:15.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/11/ee0ba42aff83bf4effdbc576673c6be64c5e173978c3f6d537e94482f77d/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ca653c6546386227cd9800d1bef6a348099acf8db4250341da6d90f663d6dfcb", size = 383539, upload-time = "2026-05-28T11:59:16.665Z" }, + { url = "https://files.pythonhosted.org/packages/11/df/d94aa6a499d4ac40afe2d7620f2c597fd3c0f182e854ad7cf3f596a81cb6/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66c93681c4729e4e3ecba31b8179fae083ff3118841672835140338b4b9867c1", size = 494674, upload-time = "2026-05-28T11:59:17.991Z" }, + { url = "https://files.pythonhosted.org/packages/1f/75/33d30f43bb2f458de11979486a591b1bf6e5651765ed1704c6197c2dc773/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40ff257542e04796880e011e15cd4dc21c2599975df2aaa8f2c8495ca574e1a5", size = 389268, upload-time = "2026-05-28T11:59:19.434Z" }, + { url = "https://files.pythonhosted.org/packages/f4/1e/2c9096fc19d5fd084b0184ca2b651e659aa0a37e6fdbecf6ece47f147fe1/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6825cc329b290e93c5f6a9be2393118a763f6ccf6abd83704e0c102ca583644", size = 376280, upload-time = "2026-05-28T11:59:21Z" }, + { url = "https://files.pythonhosted.org/packages/b9/e5/61ec9f8be8211ea7f48448195549e4aaf02004083475493b0e137702ecb2/rpds_py-2026.5.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:de42116e69cb53b911cc34aee5ab98f36c597b822545045d49e938818b99e5e4", size = 387233, upload-time = "2026-05-28T11:59:22.454Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ca/bcec1005c4f4a234f92a29078631fee49206c7265ccae966f18fd332e80e/rpds_py-2026.5.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c0f920015df2a504bebaba6d4c31ccf3fcf942f92655c086da30b671aad19aa6", size = 405009, upload-time = "2026-05-28T11:59:23.845Z" }, + { url = "https://files.pythonhosted.org/packages/72/e6/4d5718c5cf26c522dc7c9999e238da1e77380b81d0c5d1df11e271ddfeb1/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0408a24e44feb919423dc6d9da677cb5cddb894d2ca9e763967d156d9c60fab4", size = 553113, upload-time = "2026-05-28T11:59:25.184Z" }, + { url = "https://files.pythonhosted.org/packages/d4/25/2ee807bdb3e1f0b7eddf7782acd5665a8b5205a331a7d7244a52c4812fd9/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cea68bcd53467561ae2f96a6bdad1544299ba97b5b0ddcd5ac3d376e5c781c24", size = 618838, upload-time = "2026-05-28T11:59:26.749Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c1/7d4c26f167f8c41501cc073d30ee22082b16ce358cf5b00ec97cbc7804ea/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4be8b1d2a705cc37d08256004e1d07de143fa0075c8e85a3df020b776f62b732", size = 582436, upload-time = "2026-05-28T11:59:28.11Z" }, + { url = "https://files.pythonhosted.org/packages/04/1d/9d12b0a337bab46f4769f8857f4007e3b2d639e14f9a44a0efe157696e64/rpds_py-2026.5.1-cp312-cp312-win32.whl", hash = "sha256:6736718bd4fc49cbcb538ba30516fdbef161522acefb739657d48b97bd864fed", size = 212734, upload-time = "2026-05-28T11:59:29.689Z" }, + { url = "https://files.pythonhosted.org/packages/c5/93/e4116f2de7f56bc7406a76033dc501811ddeb22b7f056b92d632871ebb0c/rpds_py-2026.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:0a7d1eec967df0e9b22614a5e177622e0c89611d03727fa0cb48e45028907870", size = 229045, upload-time = "2026-05-28T11:59:31.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/53/6c3419d85eb2ec5938a37627c585b42d76a63bb731d6e42ed4b079ebf486/rpds_py-2026.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:1841d067089e117142d79b98aa0df2f08b52f2ecc1819dd2700636c0db74a473", size = 223967, upload-time = "2026-05-28T11:59:32.318Z" }, + { url = "https://files.pythonhosted.org/packages/6c/32/14c961ad295f490eb0849ada8b79683e93a59b9de3afdd983eaf55fa6867/rpds_py-2026.5.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:efef4ac29c6ff495531eb17ee705b62841ecaa291b7c7077e848ea03e237164d", size = 352787, upload-time = "2026-05-28T11:59:33.655Z" }, + { url = "https://files.pythonhosted.org/packages/ca/bb/d1b85117967c11191441a7274ae616c65d93901d082c588f89a50a8da5ae/rpds_py-2026.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c39f5b67a8a2e67179ada2a954227d670fe65fa9098457f698f56ddf248709b3", size = 345179, upload-time = "2026-05-28T11:59:35Z" }, + { url = "https://files.pythonhosted.org/packages/7c/46/d84105f062e626a1b233f863907288a4708c2d833b8b4c6fb2764bc080c0/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5c30f3f04eef4fbd362226a6f31d7c8895ca4fbb6e0b790f6890a98d8da8559", size = 376173, upload-time = "2026-05-28T11:59:36.43Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/469d7959ce5b1201e1de135dc735b86db3b35dd0d1734f6a44246d5f061c/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:277f6c82f0580848796c7ecc8a7173aa3bfb928e4ff831261c2f60a81dc270db", size = 383162, upload-time = "2026-05-28T11:59:37.995Z" }, + { url = "https://files.pythonhosted.org/packages/dc/a2/57853d31a1116a561aa072794602ad3f6341e18d70a8523f1bd5b9fc1e5a/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:63c2c4c213f1a4e3f3de28ecab029dbdee976324e729c0d7a55211be72576b02", size = 495093, upload-time = "2026-05-28T11:59:39.453Z" }, + { url = "https://files.pythonhosted.org/packages/99/63/3a8eabcad9314b7daf5c65f451d2c33d989235cd8a5762186cf2c3f5a4f8/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3350ec808fb538fe71a1f94dfaa0e29c598dfad805ce49f0caec5ae3183c652b", size = 389829, upload-time = "2026-05-28T11:59:40.896Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/05678d97fc25e2622df14dc530fb82023174ecfff6733991ed0d78f167bd/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1b964e3ab599e718dc46c018d104b1ebc007cbc6567d827c94a687fca56d77e", size = 374786, upload-time = "2026-05-28T11:59:42.626Z" }, + { url = "https://files.pythonhosted.org/packages/88/d1/8c90b6431e80a3b91b284a5c7c8c0c4f9c006444d90477a740d6e0f9c694/rpds_py-2026.5.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:19cb09fab7b7fc96b2a6e28f2e34b72a3705ff27b37edb77455316e5d3f3dc9b", size = 386920, upload-time = "2026-05-28T11:59:44.124Z" }, + { url = "https://files.pythonhosted.org/packages/ff/99/4638f672ab356682d633ee0da9255f5b67ce6efd0b85eb94ad3e255e65a5/rpds_py-2026.5.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:abe76bcdba31e576cb83eeb8797aa0d882b738fef6dc65d0601fc753806a5b46", size = 405059, upload-time = "2026-05-28T11:59:47.177Z" }, + { url = "https://files.pythonhosted.org/packages/66/3f/3546524b6eb4cc2e1f363a3d638fa52f6c24faae3500c25fb488b02f1740/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8bff7073db3899158fff55ebf57b113a67030af26f80a18978f9f0aa60250ddf", size = 553030, upload-time = "2026-05-28T11:59:48.603Z" }, + { url = "https://files.pythonhosted.org/packages/c6/c3/7b3388c796fcf471bd17194242d4dc1a7608567c0fa422bcc1c5e79f9c1e/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8ba264fa49be666cd9cc56bf34ec7002fb3d27a4aee5bcb4d43d0d18feb1bb6f", size = 618975, upload-time = "2026-05-28T11:59:50.314Z" }, + { url = "https://files.pythonhosted.org/packages/61/1e/a3cb07f2795075d1d88efddae2f541359fde5f08c81ee114c29c2949c90a/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4860b603ddda0475a8885499b3729e90229d480105b42651962a5397d995fa89", size = 581178, upload-time = "2026-05-28T11:59:51.673Z" }, + { url = "https://files.pythonhosted.org/packages/a1/74/e758c03a5ef46f04c37f2651a2893db846d569ba8a7bca469d4b58939bcd/rpds_py-2026.5.1-cp313-cp313-win32.whl", hash = "sha256:7944270ae71383f6e2657dd7d5ce4eeb4ac2d0059a6738f0510583d462ab4842", size = 212481, upload-time = "2026-05-28T11:59:53.148Z" }, + { url = "https://files.pythonhosted.org/packages/70/ec/a2aca432db9c7359b40fa393eeeaa0d166c2f70175be956e75fa24197c44/rpds_py-2026.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:88647f43a73c4e01be19b04ceef0c8d3a1958153604d13c773becd8016f2a0cf", size = 228519, upload-time = "2026-05-28T11:59:54.505Z" }, + { url = "https://files.pythonhosted.org/packages/29/60/a73bfdd45b096574556acf303bbd9fa9eed36ca8a818b514e2a5d5fe2b9d/rpds_py-2026.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:453895624ecf7db7063b1004e44037522bbaef9ff6a945e59bc71662d7a03abd", size = 223446, upload-time = "2026-05-28T11:59:56.081Z" }, + { url = "https://files.pythonhosted.org/packages/18/e2/408105fd611823f00882aea810f3989a30d26b1bab8b6beb20f98c724e0e/rpds_py-2026.5.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:b4e4bc98639ec915f512fde3aa7a95e0041d95d9c3cc86eea841fa63cb1e8600", size = 355287, upload-time = "2026-05-28T11:59:57.448Z" }, + { url = "https://files.pythonhosted.org/packages/8d/58/5c4a43436843c90d0f6d19f82c200c80e3843ca9fa07b237623327f6d384/rpds_py-2026.5.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cacedb7a6e167680acba45ad5716e89067d225dc80da0d7040cae8c81d4572fa", size = 347033, upload-time = "2026-05-28T11:59:58.881Z" }, + { url = "https://files.pythonhosted.org/packages/fb/c2/1a71acdacaf4e259b10278fb87b039ded3cf80041bcd89dd8a3ea702ded6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68700371c5d7ae1412862ddfa719090925c93ecf351c566d66f09d04b136ea00", size = 376891, upload-time = "2026-05-28T12:00:00.516Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c8/535f3d9b65addd8e28aa87b83c6e526799c3717a88273db8ea795beeef7a/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:296c799becfa849c779c8725494fe9ed94959ed886787df4364b058465bad7f0", size = 385646, upload-time = "2026-05-28T12:00:02.394Z" }, + { url = "https://files.pythonhosted.org/packages/1c/91/dc033f313345c354ade914dbe73cdb90b615a4409ea02430d5356794f3d8/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d3858b908218ee108d0bbfb2095ccc237648053c9bf98affad7cb079acaf1d97", size = 498830, upload-time = "2026-05-28T12:00:04.189Z" }, + { url = "https://files.pythonhosted.org/packages/27/fc/90fcbea459dbb8ddc18a2e0fd1de9412b48bc84ffff2db771cf714bacfd6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4fb8d2e7cb2f850b169806d61d1b991738acec96500a75c30f49caf064ce7cef", size = 392830, upload-time = "2026-05-28T12:00:05.797Z" }, + { url = "https://files.pythonhosted.org/packages/b2/1d/46cd11a228c9750684a798d98f878be6f614aa762438da7378f035e79e35/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27b74c10ed6a8f190f4287f53bcfea348b92a84a9c9f70d30183d1e6172d580d", size = 379613, upload-time = "2026-05-28T12:00:07.433Z" }, + { url = "https://files.pythonhosted.org/packages/24/4a/d9b0c6af3a1de03eb93741bbe8be2bdce84d8fda8224f3005451d86df389/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:b9a6528956191c48c52294a592dbd4a8386d7048bdb25c0efcb6b966466c6d83", size = 388183, upload-time = "2026-05-28T12:00:09.227Z" }, + { url = "https://files.pythonhosted.org/packages/c5/b4/db7aaabdda6d020afc87d981bcc2f57a434c7dec60ecfc2ab3dd50b20351/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:af03e34e860047bc7a352b842856fcf78798fbb81132cc98bd2f907ab4eb9cd2", size = 408578, upload-time = "2026-05-28T12:00:10.779Z" }, + { url = "https://files.pythonhosted.org/packages/08/d6/070f6a41cbb343e2ac4171859bf3f3623e0ab002f72619d6d505313ec2de/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fea6e836d10abbe191d557d33bd58bd5987725fe63aa1eefe557d230209855bd", size = 553573, upload-time = "2026-05-28T12:00:12.443Z" }, + { url = "https://files.pythonhosted.org/packages/75/ab/1a71ea3589c4345dac0a0518f0e6a031cb42689277851b683c46d27463a5/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:fc0c0f878ea770a0a8a462456c5ad36fc9fe6358e6b76fdadc7f17575e0b8bf1", size = 620861, upload-time = "2026-05-28T12:00:14.09Z" }, + { url = "https://files.pythonhosted.org/packages/8a/22/9bf80a56069c0c443fcfefac639a86a744550a2898817a6dfd3e26654924/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e0b360f316d966b048b085857630b3cc51f3db2f07b06f440eac8f695374d1e3", size = 585633, upload-time = "2026-05-28T12:00:15.66Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/3b2c0a75c9e04125696f84ebdbbf304acf5a40b58ba4481cdb98a922c3ba/rpds_py-2026.5.1-cp313-cp313t-win32.whl", hash = "sha256:a2999883eedf72fdfb7520b92c7d4ec2572a71ff40239377aa604cc529eecafc", size = 210074, upload-time = "2026-05-28T12:00:17.291Z" }, + { url = "https://files.pythonhosted.org/packages/e7/8b/609157d5a25d37d4f29f92840ba531f416907c34ae5c5739dd21fc2bef98/rpds_py-2026.5.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e07be2a9d7122bd6e82dea89814ef8dc893feb1aae97fec1630f3263bbb30e55", size = 228635, upload-time = "2026-05-28T12:00:18.73Z" }, + { url = "https://files.pythonhosted.org/packages/d4/6f/19c1918a4b590d8de87e712e4abe4b3875771eff60216fb6153cf6665c68/rpds_py-2026.5.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1f2c391c3059798093b65df23aca2cac150460ae9c630d99dec83d703d9485b9", size = 349756, upload-time = "2026-05-28T12:00:20.217Z" }, + { url = "https://files.pythonhosted.org/packages/e5/60/a06fe7da34eca79dacbf958a2ba0c6eea85bc2b29de20080bf40f72f66fa/rpds_py-2026.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:413b424f7c4ee65ab5e5be91f5731be0f8b41a1ee2b12dfe810d716312e95a78", size = 343831, upload-time = "2026-05-28T12:00:21.711Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ec/b2333b97b90e2a6ef6ca8ad386ee284968e74bcfe113b3f1a8d9036429a9/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c595a1d9255dce0599e13130d1440ab2506654f2b50294226ee06402f8fef63", size = 375127, upload-time = "2026-05-28T12:00:23.326Z" }, + { url = "https://files.pythonhosted.org/packages/14/7f/e00aae54067f2b488c4637961d5f58204d470795fc791085fa3f15060d2e/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c27c5f6102eac8c03e7595a00827a53b271ba40a53b59ff8709170e0855ea4a", size = 379034, upload-time = "2026-05-28T12:00:24.89Z" }, + { url = "https://files.pythonhosted.org/packages/be/cc/423999bbb8ae8dc93c77fc1d5e984ade5eb89d237d3bb884ccfa72ae2890/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c7fcf61d44cacecaf3aea542b0e053db77972a4573e7ceda16fb2b399161195", size = 490823, upload-time = "2026-05-28T12:00:26.676Z" }, + { url = "https://files.pythonhosted.org/packages/0f/aa/c671bf660f12e68d3c52ff86c7066ed1372df5a0f4f2ff584e419b8207e7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2c817a189d4ee14290420e5ff051e4dd6baa13f3edf84685071dee07a6d538ee", size = 388144, upload-time = "2026-05-28T12:00:28.577Z" }, + { url = "https://files.pythonhosted.org/packages/19/c8/d63bb75b68afe77b229e3021c6031bcaf01da5db5b0e69d0d10f9ba679a7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21846aac0ed2e0589f38c12dc44e77bb64e494b771eadbcf169cba00566ba7ba", size = 371959, upload-time = "2026-05-28T12:00:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/82/35/c51122014d8274ff37dc606d60049c3db7d83da02b5b282511e5a906a9a6/rpds_py-2026.5.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b317c87a13f769a4e787819bd508aaa5d69aa09b0880de9af6d3a8a54571cdec", size = 383558, upload-time = "2026-05-28T12:00:31.764Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f9/2790cb99c136a5363acdeacf5c27c56f3de0d4118a1f48fca83404c99c89/rpds_py-2026.5.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce87129d9f2c14fa6c4a8601fb80eb4488c80d38a20cd13758ef11123e14995d", size = 402789, upload-time = "2026-05-28T12:00:33.247Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1b/e4fb584f8c75d35c38150ff6a332cda949e6f97acba1f4fd123b14ab56fe/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9cdddb6c1207d284d94fd1530adf57fbd797fe7c4b8704ba85f49414f2557e7d", size = 551405, upload-time = "2026-05-28T12:00:34.819Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f7/a6731b4216cb3793ea1af5391da240f5683dacc0d13e034fe5fc3503f240/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:4e237e139f94d3c036fd28eb9f564c99055476ff4ff05cd42be55ce349b5aa02", size = 616975, upload-time = "2026-05-28T12:00:36.268Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/2e051a81d95d8e63f4b35a1c463a87e8766bc3d083c067c5dfb6bf220747/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ed0954b524873214369184a9c82b0eaa45a3fbb9a798cd95b17e0d98499e7ea0", size = 578701, upload-time = "2026-05-28T12:00:37.82Z" }, + { url = "https://files.pythonhosted.org/packages/65/56/b5f6fdb2083e32bca8a8993d89e70db114b4756c9e2c38421328126689d2/rpds_py-2026.5.1-cp314-cp314-win32.whl", hash = "sha256:2d88621d6a7d4dfa633d21abe90f280bb205274e16b1d1e61c6ad4640b2453b7", size = 209806, upload-time = "2026-05-28T12:00:39.492Z" }, + { url = "https://files.pythonhosted.org/packages/fb/80/65a5aa96c155e611d1ed844e4e1f57f3e36b021f396d9f8585d756e6b90d/rpds_py-2026.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:cef8ac28d26f4dda3533060c20fbf80a325458fa9fd23ea72a73cdfa8e978838", size = 225985, upload-time = "2026-05-28T12:00:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/27/7c/ad185212e87b05f196daef92bc5f3caf07298eb47c295b5585c3dd3093ac/rpds_py-2026.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:eaaea962c68cdc68d4a533ba985ab8e9484277910bbfaa2ab3ef7732667bfed8", size = 221219, upload-time = "2026-05-28T12:00:43.15Z" }, + { url = "https://files.pythonhosted.org/packages/23/58/e14ae18759020334646b031e708ab4158d653a938822bfb7b95ef2e93aa3/rpds_py-2026.5.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:21942f52dbbd5f8758bf021213d28bd45c39e873e65e2407faf5f1846f5761ad", size = 352148, upload-time = "2026-05-28T12:00:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/31/9b/5f4a1e2f960bca3ac5d052b139dd31eed97b259f9d909173821760d542e8/rpds_py-2026.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f414556f6e3958300ff941e40c9f97e3dc9774ddd1b3434c475d73dd354bbed3", size = 345196, upload-time = "2026-05-28T12:00:46.14Z" }, + { url = "https://files.pythonhosted.org/packages/1a/71/1d9574d6a2fa20ab60eaa55c7467f5aa20cbc770f341a05f09c0876f59e2/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ef1013a8625c74043210190b246f5b1551e09757c1f356c6e4160ef96c5bc081", size = 374981, upload-time = "2026-05-28T12:00:47.531Z" }, + { url = "https://files.pythonhosted.org/packages/0c/9a/37e99f4915a80aa71670263c1267f7ae0af95f53a3f61e6c3bdc016d4515/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cc68e231a77a5f0d774ae278a1f8e55c0456501820847c1e4efb3829f3441df6", size = 379961, upload-time = "2026-05-28T12:00:49.216Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ff/6e73f74b89d2e0715e0fc86b7dde893f9a61ae2f9b256ff3bdfe41ac4e94/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9baffb505aff33acc69b422a19f77806680f3c8632227d79f48de8a810d1c2c5", size = 495965, upload-time = "2026-05-28T12:00:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/ea/e0/425faba25f59d74d4638b267f7c7a80e8649d2ef4db10a19b0c4a71e6e6f/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8d2f912928d426e8cfa396f7f3f8d29a59e6689c86dcca3c420730c1096322b", size = 389526, upload-time = "2026-05-28T12:00:52.77Z" }, + { url = "https://files.pythonhosted.org/packages/c6/76/7a41960e3fddae47fab43a28684d5da981401dffd88253de0944148654cb/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90f628283be835db980c941767d41c9a27b5239e54ba0a9c1335247e82406964", size = 376190, upload-time = "2026-05-28T12:00:54.215Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/5f38dc70824fc6951b51d35377e577a3a3a4c81a6769cc5a2de25ebe0ad1/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:1ebb2f0ab7e16132995a72de805170e0203df0c3dd22e1ef1cd1fdd90bd7a131", size = 383921, upload-time = "2026-05-28T12:00:55.673Z" }, + { url = "https://files.pythonhosted.org/packages/60/1a/d60a38caa1505f4b9483c3fbbde12c94e1079154f4f401a6da96f7e77621/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f3df3d16ded76f1f8c9cdebd0e1ea55fdf4c23b812de189814da7cf229c22a81", size = 404766, upload-time = "2026-05-28T12:00:57.518Z" }, + { url = "https://files.pythonhosted.org/packages/87/ff/602fd3f174d6425f0bce05ad0dfbec0e96b38d0f7d08a79af5aa20083885/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9af8905b8f854990e40d5206aa5ac58d9b0fe0b7f351ff2bb086c20f6c8c6a47", size = 551343, upload-time = "2026-05-28T12:00:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c1/1be13327acdbead3eca1fde03b6a34dbb011f1e864e217f0d32cc1779a7f/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:036a36a87fb1cd3b214d11c4b3c4f7d2ddad933625dca1c900b56a057c07740a", size = 618502, upload-time = "2026-05-28T12:01:00.656Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d7/afb49b49d7f2be8b7ba1a9f0977fa5168003437b93086726f066544e8351/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ae3853454fe9ef283a03c96c2d835d39e84b14643a9d62c82ef0fb87d702ca", size = 581916, upload-time = "2026-05-28T12:01:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/dbef8c1f8a10f07beb62b5f054e20099fd9924b3ec001b8f0b6ac7813a85/rpds_py-2026.5.1-cp314-cp314t-win32.whl", hash = "sha256:6c3d771a46ec18b12af06ce36243a9a80b07a5d0515236332d90863ca8bb326a", size = 207855, upload-time = "2026-05-28T12:01:03.821Z" }, + { url = "https://files.pythonhosted.org/packages/2a/72/bfa4e61ab8e7dc1c8adf397e05e6cbdd4239357bd72b248d3de662f23915/rpds_py-2026.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c93c629be4636cf54337bd5f06c104d55e42ced54d681f6fe21ae510a65116f6", size = 225422, upload-time = "2026-05-28T12:01:05.194Z" }, + { url = "https://files.pythonhosted.org/packages/27/3a/7b5da92b640f67b6717ccafc83cdd06bfa7ff2395c3685c68922bb54d703/rpds_py-2026.5.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:3574b55c604b8f75dacb007136508bbc0db406e626301778096a133327e7f2fb", size = 349576, upload-time = "2026-05-28T12:01:06.722Z" }, + { url = "https://files.pythonhosted.org/packages/d7/8a/2aafd7ad355a1bd48ca76e2262b74b15e6432b5a1efe150efd4d779cd55d/rpds_py-2026.5.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:94068eb3ae6d43f5a786b7db96a406a34e6d5c24489feef32fd6e8946ea7b291", size = 343640, upload-time = "2026-05-28T12:01:08.441Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7d/6c9523c1abbe840a1b7fba3c516d48e1d3487cc80fea4366c4071cf56784/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a5b10e8ce894825f380a8f1b6444cf73c294dfea62afbb2d13e3a9e630cec1", size = 375322, upload-time = "2026-05-28T12:01:09.934Z" }, + { url = "https://files.pythonhosted.org/packages/5a/5d/0b7b03fb1dc509321f01de3149784ab773e34c8573022029af8076afcb9c/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fc09f82e63d4bcd58149572f857a431bae851dc747e313c3b5bdf7abb907fda8", size = 379066, upload-time = "2026-05-28T12:01:11.48Z" }, + { url = "https://files.pythonhosted.org/packages/d7/e2/8ef6012999ebf1cb1c22f876d9ce5e63d960fd4631d2af3202d3f480aa25/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e10464d17df3b582745c25cec695cb9558bca2cb6ddb631aee1787fc72c767b2", size = 494586, upload-time = "2026-05-28T12:01:13.051Z" }, + { url = "https://files.pythonhosted.org/packages/80/af/1eeb029bec67582c226b7809172207cd005073af4ebd906e65ff494f4983/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ba05adbf15d994c38ec0b7ab32e858e5110c21e9009a00a86545fd220f84e038", size = 388415, upload-time = "2026-05-28T12:01:14.631Z" }, + { url = "https://files.pythonhosted.org/packages/18/23/ffbe10711c4d766c1cab0557d6906c074f795814863c67b351355d29354a/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77c004fdc7b891967106f78ddfd7b076bfe6813c6139c6fff6aed3bcaa960b26", size = 372427, upload-time = "2026-05-28T12:01:16.153Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3a/30ba4a6ad457e5b070c18d742a33fb77d8d922b565cc881f8a5313d63bfe/rpds_py-2026.5.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:83bcf894486c9d78dd290d3c0124ff6dd8875d3025e2090a8ec49fcc37c55fdd", size = 383615, upload-time = "2026-05-28T12:01:17.809Z" }, + { url = "https://files.pythonhosted.org/packages/d3/69/62e242b53ce39c0814bd24e1a6e6eba6c92be716277745f317f9540a2e7b/rpds_py-2026.5.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c3df104083952a0e0c6f10de33e440eabe98fb6317d23e1a58c68f6df08d01b9", size = 402786, upload-time = "2026-05-28T12:01:19.419Z" }, + { url = "https://files.pythonhosted.org/packages/38/c1/a770b9c186928a1ed0f7e6d7ae50e7f3950ed23e3f9e366dbc8e38cb55de/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:980450826cf22e133c57e0835070bdd0dd3f73b9b708c3ce223def2cb9469e14", size = 551583, upload-time = "2026-05-28T12:01:21.013Z" }, + { url = "https://files.pythonhosted.org/packages/21/7c/68e8579b95375b70d2a963103c42e705856cdb98569258bd807f4423891c/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:205dde846f24332ab0c1188699a043b8d165b79bb84529ce272c45048ff6be01", size = 616941, upload-time = "2026-05-28T12:01:22.548Z" }, + { url = "https://files.pythonhosted.org/packages/70/a1/a6135aed5730ff03ab957182259987ac11e55fb392a28dc6f0592048a280/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:3966b82dd563176396df030f3dd52a6e54cb69b718e95e78bd555ed3d1e0185d", size = 578349, upload-time = "2026-05-28T12:01:24.118Z" }, + { url = "https://files.pythonhosted.org/packages/09/6e/f24201a76a84e6c49d0bdfdfcb735210e21701e9b21c5bfc0ba497dd62f6/rpds_py-2026.5.1-cp315-cp315-win32.whl", hash = "sha256:7818f8d0a415be74d2be3590b0a1c1f463a642f4d0217e7d10602dceef5b79aa", size = 209922, upload-time = "2026-05-28T12:01:25.522Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e4/966bc240bb0485fc265278f6de44d05834bf0b3618886e0b22e33d54c49a/rpds_py-2026.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:b3cc20c0d800af78fd0fac68086e28c1856cec51ea528bb81ea851aa40d39325", size = 226003, upload-time = "2026-05-28T12:01:27.062Z" }, + { url = "https://files.pythonhosted.org/packages/5c/5c/a15a59269cd5e74472734516c73795c15eccfc841b3d4b0228c3f53f19d0/rpds_py-2026.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:3609e9939a8a76cd904cf98a3f1f13b5dc7e150adeaee89e0ea09652ea213e16", size = 221245, upload-time = "2026-05-28T12:01:28.51Z" }, + { url = "https://files.pythonhosted.org/packages/e0/22/135ce03804e179a71ceb13be095deda4a279bc88f7a6b8fa161c5ad44e12/rpds_py-2026.5.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:5d333a7127d4b307601ac37792bee01bb95c867cbfacf21b6375b804d6bbd723", size = 352015, upload-time = "2026-05-28T12:01:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/3b/5f/f1f6d2652eb9d848f6eb369d8db83a2da6249bb49ad2c2a48f45d54538d3/rpds_py-2026.5.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:b5f077b44a4f7808520f66dae234988d867deb9aed9be5da057ce9ba831b2a41", size = 345016, upload-time = "2026-05-28T12:01:31.656Z" }, + { url = "https://files.pythonhosted.org/packages/88/66/b74182775691ea2290c99e52ac8d5db844e56fbec90ce421f107658c8314/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55d8f9b7b78c9538fc9e04e82ec0e888ff0c3cffcfad152c77e57cd09351a98a", size = 374775, upload-time = "2026-05-28T12:01:33.136Z" }, + { url = "https://files.pythonhosted.org/packages/ff/8f/15e5a61d9f0a43902d36561d4f07cae6ae9f4716be825159fd72717f33af/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e3a8ae58895ac107ed934a6bf51e5846f95c53b9b940c2c6d310838fd5846358", size = 380270, upload-time = "2026-05-28T12:01:34.574Z" }, + { url = "https://files.pythonhosted.org/packages/02/c3/f859b12763a80540cdf2af0f15b19904cf756a71d7bdd3f82ff3e5b1bbf9/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0957cf3c2b8632ec7aaebffebea8005b353cc2a237b6e2ae3c2cac0820704cfb", size = 495285, upload-time = "2026-05-28T12:01:36.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c7/ff27c2ac8411d30b03b1829fd88cae8dad1a4d0da48dd25e57c4038042e6/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c396c1304de421050b3681ea70f371874b54d41b0151e96109758144c231e30b", size = 389581, upload-time = "2026-05-28T12:01:37.635Z" }, + { url = "https://files.pythonhosted.org/packages/6e/67/fe92ee32a6cc05c77228a2f8b1762e7124f386ec20ff83d0757b762d58d0/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aad1bff7f666b9598e573815affd666aac6a13a585dde336f843e33350c7fadc", size = 376041, upload-time = "2026-05-28T12:01:39.307Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/b4d6685c27aba55bd82f25b278be8237038117d05f9659a6213ad3408130/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:656a042550878f12d45752452d47094b7cfe5ad1e9d7b87b5a22ad3ae5ff8015", size = 383946, upload-time = "2026-05-28T12:01:41.043Z" }, + { url = "https://files.pythonhosted.org/packages/bd/79/2c1d832a53c8e0f8e98fc970ec257b950fecd4f62be2ab7182b500a0cbc8/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:73c4bd4f70294737b5206a3e8e30ccadbf8a60301831c8ea23eec5dbeea1ecfa", size = 405526, upload-time = "2026-05-28T12:01:43.032Z" }, + { url = "https://files.pythonhosted.org/packages/78/c4/c98117b03c6a8581ab2c2dfccfe9a5ad82bd8128a3c28b46a6ad2d97c393/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:43bca78665423cabae77146f2fe7ce55272b6c8d55d82cca83effd42c7e13972", size = 551165, upload-time = "2026-05-28T12:01:44.648Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c1/bc479ca069200af730881b1bd525e3114b2b391a351509fcb1b772f28086/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:42d0f20e85e549c870749d0e247f0c10d318a45b7e9676d575d2dcb04a1b2e66", size = 618778, upload-time = "2026-05-28T12:01:46.337Z" }, + { url = "https://files.pythonhosted.org/packages/77/65/38ab2f90df44c2febfb63cc10ced40763d9b4bc94d173e734528663fe7f5/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b1be5c35683684d5331b93600c210e8367c254683d8a6df6bd21bd2da3a334fb", size = 581839, upload-time = "2026-05-28T12:01:48.109Z" }, + { url = "https://files.pythonhosted.org/packages/15/2d/ce1f605fe036aadd460e5822e578c6c7ec3a860936cca37d6e0f299daa77/rpds_py-2026.5.1-cp315-cp315t-win32.whl", hash = "sha256:75808f6c38ce7749bb68cc2770161aae5045e6c6f6781a9782e74b93304399df", size = 207866, upload-time = "2026-05-28T12:01:49.648Z" }, + { url = "https://files.pythonhosted.org/packages/79/cb/966040123eb102371559746908ef2c9471f4d43e17ec9a645a2258dab64b/rpds_py-2026.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:90bd6630002a1c7f09e7843dd79f0d24f3d2897cc25a753480917865d14f15b3", size = 225441, upload-time = "2026-05-28T12:01:51.408Z" }, +] + [[package]] name = "ruff" version = "0.15.12" @@ -2545,6 +3921,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/87/72/c6c32d2b657fa3dad1de340254e14390b1e334ce38268b7ad51abda3c8c2/s3transfer-0.17.0-py3-none-any.whl", hash = "sha256:ce3801712acf4ad3e89fb9990df97b4972e93f4b3b0004d214be5bce12814c20", size = 86811, upload-time = "2026-04-29T22:07:34.966Z" }, ] +[[package]] +name = "send2trash" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, +] + [[package]] name = "simplejson" version = "4.1.1" @@ -2616,6 +4001,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, ] +[[package]] +name = "soupsieve" +version = "2.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/2c/0a5f6f8ee0d5589e48c7640213ed5175d52cf540a06725b628cc1a45d6ce/soupsieve-2.8.4.tar.gz", hash = "sha256:e121fd02e975c695e4e9e8774a5ee35d74714b59307868dcc5319ad2d9e3328e", size = 121110, upload-time = "2026-05-24T13:55:57.154Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + [[package]] name = "starlette" version = "1.0.0" @@ -2669,6 +4077,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/02/be/5d2d47b1fb58943194fb59dcf222f7c4e35122ec0ffe8c36e18b5d728f0b/tblib-3.2.2-py3-none-any.whl", hash = "sha256:26bdccf339bcce6a88b2b5432c988b266ebbe63a4e593f6b578b1d2e723d2b76", size = 12893, upload-time = "2025-11-12T12:21:14.407Z" }, ] +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" }, +] + [[package]] name = "titiler-core" version = "2.0.2" @@ -2733,6 +4167,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/c8/876602cbc96469911f0939f703453c1157b0c826ecb05bdd32e023397d4e/tornado-6.5.5-cp39-abi3-win_arm64.whl", hash = "sha256:2c9a876e094109333f888539ddb2de4361743e5d21eece20688e3e351e4990a6", size = 448016, upload-time = "2026-03-10T21:31:00.43Z" }, ] +[[package]] +name = "traitlets" +version = "5.15.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/a9/a2584b8313b89f94869ddb3c4074617a691de1812a614d2d50e32ca5a7a6/traitlets-5.15.1.tar.gz", hash = "sha256:7b1c07854fe25acb39e009bae49f11b79ff6cbb2f27999104e9110e7a6b53722", size = 163344, upload-time = "2026-06-03T12:26:06.181Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/8d/1080ee4c231f361b6ce4470d556c8c435b67c7e0753aaa641497ee92f88b/traitlets-5.15.1-py3-none-any.whl", hash = "sha256:770a53705f84b81ac107e83a1b3328ff2dae16094d8fc3cfc004e4b22dfd8e92", size = 85858, upload-time = "2026-06-03T12:26:04.395Z" }, +] + [[package]] name = "typing-extensions" version = "4.15.0" @@ -2763,6 +4206,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, ] +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, +] + [[package]] name = "urllib3" version = "2.7.0" @@ -2820,6 +4272,51 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" }, ] +[[package]] +name = "wcwidth" +version = "0.8.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/b4/51fe890511f0f242d07cb1ebe6a5b6db417262b9d2568b460347c57d95cc/wcwidth-0.8.1.tar.gz", hash = "sha256:faf5b4a5366a72dc49cad48cdf21f52bdf63bdda995178e483ba247ff79089b9", size = 1466072, upload-time = "2026-06-08T05:57:23.146Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/6e/95b0e537de1f4d4301f76f944642c6da50d1511cc7b3d64dc418a66c7509/wcwidth-0.8.1-py3-none-any.whl", hash = "sha256:f453740b1e4a4f3291faa37944c555d71056c4da08d59809b307ef4feba695c8", size = 323092, upload-time = "2026-06-08T05:57:21.413Z" }, +] + +[[package]] +name = "webcolors" +version = "25.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, +] + +[[package]] +name = "websocket-client" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/f4/c67440c7fb409a71b7404b7aefcd7569a9c0d6bd071299bf4198ae7a5d95/widgetsnbextension-4.0.15.tar.gz", hash = "sha256:de8610639996f1567952d763a5a41af8af37f2575a41f9852a38f947eb82a3b9", size = 1097402, upload-time = "2025-11-01T21:15:55.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" }, +] + [[package]] name = "wrapt" version = "2.1.2" @@ -3026,11 +4523,15 @@ cast-value-rs = [ [[package]] name = "zarr-cm" -version = "0.4.1.dev13+ge94a3ee8d" -source = { git = "https://github.com/zarr-conventions/zarr-cm.git?rev=main#e94a3ee8db52689883753f5b928f8331c3d01b15" } +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] +sdist = { url = "https://files.pythonhosted.org/packages/f9/c6/51d38cafa07bdf725c77a67719647eea43255f925fda062b40799bbb361d/zarr_cm-0.4.1.tar.gz", hash = "sha256:693d24ca2b8e3a7230e1ed448c2c57f98833b81e5899607b6cb4a7ac31f94002", size = 50839, upload-time = "2026-06-21T19:20:36.277Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/14/3de8976647909b2f6764b8d0c9add0a961667ef4ab46f3f99e12d7a522fa/zarr_cm-0.4.1-py3-none-any.whl", hash = "sha256:2c7f36383af2e6f75eb274a797a13154fd5c5827390de7c79294dfeb9f0543ee", size = 33005, upload-time = "2026-06-21T19:20:35.05Z" }, +] [[package]] name = "zict"