diff --git a/clio-agentic-search/README.md b/clio-agentic-search/README.md index d2e7ee00..614ddf37 100644 --- a/clio-agentic-search/README.md +++ b/clio-agentic-search/README.md @@ -11,7 +11,7 @@ Part of [**CLIO Kit**](https://github.com/iowarp/clio-kit) — the IoWarp platfo --- -Hybrid retrieval engine for scientific computing corpora. Indexes documents into namespace-specific backends and supports lexical (BM25), vector, graph, metadata, and scientific-operator retrieval in one pipeline. DuckDB storage, FastAPI server, async job queue, OpenTelemetry tracing, Prometheus metrics. +Agentic hybrid retrieval engine for scientific computing corpora. Indexes documents into namespace-specific backends and supports lexical (BM25), vector, graph, metadata, and scientific-operator retrieval in one pipeline, with an optional multi-hop agentic loop that rewrites queries and adapts to each corpus. DuckDB storage, FastAPI server, async job queue, OpenTelemetry tracing, Prometheus metrics. ## Quick start @@ -33,15 +33,68 @@ uv run clio query --namespace local_fs --q "pressure > 200 kPa" uv run clio index --namespace local_fs ``` +### Optional extras + +The core install is lightweight; heavier or backend-specific dependencies ship as extras (`uv sync --extra `): + +| Extra | Pulls in | Enables | +|-------|----------|---------| +| `semantic` | sentence-transformers | Transformer embeddings (otherwise a hash embedder is used) | +| `ann` | numpy, hnswlib | Approximate nearest-neighbour vector backend (`CLIO_ANN_BACKEND=hnsw`) | +| `hdf5` | h5py | HDF5 connector (`hdf5_data` namespace) | +| `netcdf` | xarray, netCDF4 | NetCDF connector (`netcdf_data` namespace) | +| `llm` | anthropic, openai | LLM-based query rewriting (`--llm-rewrite`); without it, a rule-based fallback is used | +| `telemetry` | opentelemetry, prometheus-client | Tracing + `/metrics` exposition | +| `eval` | claude-agent-sdk, anthropic | SC26 evaluation harness | + ## Features - **Multi-namespace registry** with runtime/auth config bundles -- **Connectors**: filesystem + DuckDB (`local_fs`), S3 object store, Qdrant vector store, Neo4j graph, Redis KV log +- **Hybrid retrieval** across lexical (BM25), vector, graph and metadata branches in one pipeline - **Scientific retrieval operators**: numeric range (`unit`, `min`, `max`), unit matching, formula targeting (normalized signatures) +- **Agentic retrieval**: optional multi-hop loop with LLM query rewriting (with a no-LLM fallback) and SI-unit variant inference +- **Corpus-adaptive strategy**: schema/metadata profiling drives per-query branch selection and content-quality filtering +- **Structured ingestion**: CSV/tabular detection and table-aware chunking alongside text +- **Nine connectors** spanning POSIX, object, vector, graph, KV and science formats — see [Connectors](#connectors) - **Background indexing** job API with cancellation tokens and per-namespace serialized execution - **Retry/backoff** wrappers for connect/index operations - **Telemetry**: OpenTelemetry tracing (opt-in), Prometheus metrics at `/metrics` +## Retrieval pipeline + +``` +Query → Namespace registry → Retrieval coordinator → parallel branches + ├── Lexical (BM25) + ├── Vector (embeddings; hash or transformer) + ├── Graph (BFS) + ├── Metadata (schema-aware filters) + └── Scientific (SI unit conversion + formula normalization) + → Merge + rerank → Citations + trace events +``` + +With `--agentic`, the coordinator runs inside an observe–decide–act loop: it +inspects results, rewrites the query (LLM or rule-based), and re-runs branches +until it converges or hits `--max-hops`. A corpus profiler inspects what +metadata each namespace actually provides and adapts branch selection and +quality filtering per query. + +## Connectors + +| Connector | Namespace | Default registry | Extra required | +|-----------|-----------|:---------------:|----------------| +| Filesystem + DuckDB | `local_fs` | ✅ | — | +| S3 object store | `object_s3` | ✅ | — | +| Qdrant vector store | `vector_qdrant` | ✅ | — | +| HDF5 | `hdf5_data` | ✅ | `hdf5` (h5py is also a core dep) | +| NetCDF | `netcdf_data` | ✅ | `netcdf` | +| Neo4j graph | (configurable) | — | — | +| Redis KV log | (configurable) | — | — | +| IOWarp content store | (configurable) | — | `iowarp_core` wheel | +| NDP datasets | (configurable) | — | `mcp` (for MCP-backed discovery) | + +`build_default_registry()` provisions the first five namespaces; the remaining +connectors are available to register explicitly. + ## API endpoints | Method | Path | Description | @@ -59,12 +112,76 @@ uv run clio index --namespace local_fs | Command | Description | |---------|-------------| -| `clio query` | Run retrieval queries against a namespace | +| `clio query` | Run retrieval queries against a namespace (add `--agentic --max-hops N` for the multi-hop loop, `--llm-rewrite` for LLM query rewriting) | | `clio index` | Index documents into a namespace | | `clio list` | List indexed documents | | `clio seed` | Seed sample data for testing | | `clio serve` | Start the FastAPI server | +Agentic retrieval is opt-in — a plain `clio query` behaves exactly as before: + +```bash +# Single-shot (default) +clio query --namespace local_fs --q "pressure 200 kPa" + +# Multi-hop agentic loop (max 3 hops), with LLM query rewriting +clio query --namespace local_fs --q "pressure 200 kPa" --agentic --max-hops 3 --llm-rewrite +``` + +## Examples + +Point the filesystem connector at a folder, index it, then run the queries below. + +```bash +export CLIO_LOCAL_ROOT=./docs # folder of .txt/.md/.csv files +export CLIO_STORAGE_PATH=./clio.duckdb +clio index --namespace local_fs # build the index +clio list --namespace local_fs # show indexed docs + chunk counts +``` + +**Scientific numeric-range** — match by real unit math, not keywords. Only +documents whose measurements fall in the range are returned: + +```bash +# "pressure between 300 and 400 kPa" +clio query --namespace local_fs --q "pressure" --numeric-range "300:400:kPa" + +# Same physical range expressed in Pa — finds the same 320 kPa document, +# because values are canonicalized to SI base units before matching. +clio query --namespace local_fs --q "pressure" --numeric-range "300000:400000:Pa" +``` + +**Formula targeting** — match normalized equation signatures: + +```bash +clio query --namespace local_fs --q "newton law" --formula "F=ma" +``` + +**Agentic multi-hop** — the loop rewrites/expands the query between hops +(here, `kPa` is auto-expanded to its SI variants): + +```bash +clio query --namespace local_fs --q "pressure 320 kPa" --agentic --max-hops 3 +``` + +**Science-format connectors** — index HDF5 / NetCDF datasets: + +```bash +CLIO_HDF5_ROOT=./h5_files clio index --namespace hdf5_data +CLIO_NETCDF_ROOT=./nc_files clio index --namespace netcdf_data # needs the `netcdf` extra +clio query --namespace hdf5_data --q "compressor pressure" +``` + +**HTTP API** — start the server and query over HTTP: + +```bash +clio serve & # FastAPI on :8000 +curl -s localhost:8000/health +curl -s -X POST localhost:8000/query \ + -H "Content-Type: application/json" \ + -d '{"namespace":"local_fs","query":"turbine pressure","top_k":3}' +``` + ## Environment variables | Variable | Default | Description | diff --git a/clio-agentic-search/pyproject.toml b/clio-agentic-search/pyproject.toml index b4aa4629..db479ebc 100644 --- a/clio-agentic-search/pyproject.toml +++ b/clio-agentic-search/pyproject.toml @@ -13,6 +13,10 @@ dependencies = [ "fastapi>=0.115.0,<1.0.0", "uvicorn>=0.30.0,<1.0.0", "tenacity>=8.2.0,<10.0.0", + "httpx>=0.28.1", + "h5py>=3.16.0", + "aiohttp>=3.13.5", + "matplotlib>=3.10.8", ] [project.scripts] @@ -31,6 +35,22 @@ ann = [ "numpy>=1.26.0", "hnswlib>=0.8.0", ] +hdf5 = ["h5py>=3.10.0"] +netcdf = [ + "xarray>=2024.1.0", + "netCDF4>=1.6.0", +] +llm = ["anthropic>=0.40.0", "openai>=1.0.0"] +eval = [ + # Evaluation harness for the SC26 submission: Claude Agent SDK, + # Anthropic API client. The ndp-mcp server is installed separately + # from the clio-kit repository (not on PyPI) via + # uv add /path/to/clio-kit/clio-kit-mcp-servers/ndp + "claude-agent-sdk>=0.1.56", + "anthropic>=0.87.0", + "aiohttp>=3.10.0", + "matplotlib>=3.8.0", +] telemetry = [ "opentelemetry-api>=1.20.0", "opentelemetry-sdk>=1.20.0", @@ -75,6 +95,11 @@ python_version = "3.11" strict = true mypy_path = "src" packages = ["clio_agentic_search"] +# Optional-backend imports carry `# type: ignore` that is needed when the +# typed package is installed (dev/all-extras) but unused when it is absent +# (CI/--ignore-missing-imports). Tolerate both so `mypy src/` is clean in +# either environment. +warn_unused_ignores = false [[tool.mypy.overrides]] module = [ @@ -82,5 +107,13 @@ module = [ "sentence_transformers", "opentelemetry.*", "prometheus_client", + "h5py", + "xarray", + "netCDF4", + "anthropic", + "openai", + "clio_cte_core_ext", + "iowarp_core", ] ignore_missing_imports = true + diff --git a/clio-agentic-search/src/clio_agentic_search/cli/main.py b/clio-agentic-search/src/clio_agentic_search/cli/main.py index ec61f172..b9e99270 100644 --- a/clio-agentic-search/src/clio_agentic_search/cli/main.py +++ b/clio-agentic-search/src/clio_agentic_search/cli/main.py @@ -77,6 +77,22 @@ def build_parser() -> argparse.ArgumentParser: default="", help="Formula-targeted retrieval expression.", ) + query_parser.add_argument( + "--agentic", + action="store_true", + help="Enable multi-hop agentic retrieval with query rewriting.", + ) + query_parser.add_argument( + "--max-hops", + type=int, + default=3, + help="Maximum retrieval hops in agentic mode (default: 3).", + ) + query_parser.add_argument( + "--llm-rewrite", + action="store_true", + help="Use LLM-based query rewriting (requires anthropic). Falls back to SI expansion.", + ) seed_parser = subparsers.add_parser("seed", help="Seed explicit demo/test records.") seed_parser.add_argument( @@ -138,6 +154,9 @@ def _run_query( numeric_range: str, unit_match: str, formula: str, + agentic: bool = False, + max_hops: int = 3, + llm_rewrite: bool = False, ) -> int: registry = build_default_registry() filters = _parse_filters(filter_pairs) @@ -175,7 +194,54 @@ def _run_query( ) coordinator = RetrievalCoordinator() - if len(connectors) == 1: + + if agentic: + from clio_agentic_search.retrieval.agentic import AgenticRetriever + from clio_agentic_search.retrieval.query_rewriter import ( + FallbackQueryRewriter, + QueryRewriter, + ) + + if llm_rewrite: + try: + rewriter: QueryRewriter | FallbackQueryRewriter = QueryRewriter() + except RuntimeError: + print( + "Warning: anthropic not installed, falling back to SI expansion", + file=sys.stderr, + ) + rewriter = FallbackQueryRewriter() + else: + rewriter = FallbackQueryRewriter() + + agentic_retriever = AgenticRetriever( + coordinator=coordinator, + rewriter=rewriter, + max_hops=max_hops, + ) + if len(connectors) == 1: + agentic_result = agentic_retriever.query( + connector=connectors[0], + query=text, + top_k=top_k, + metadata_filters=filters, + scientific_operators=scientific_operators, + ) + else: + agentic_result = agentic_retriever.query_namespaces( + connectors=connectors, + query=text, + top_k=top_k, + metadata_filters=filters, + scientific_operators=scientific_operators, + ) + result_namespaces = agentic_result.namespace.split(",") + citations = agentic_result.citations + trace = agentic_result.trace + print( + f"agentic_hops={agentic_result.total_hops},final_query={agentic_result.final_query}" + ) + elif len(connectors) == 1: result = coordinator.query( connector=connectors[0], query=text, @@ -407,6 +473,9 @@ def main(argv: Sequence[str] | None = None) -> int: numeric_range=args.numeric_range, unit_match=args.unit_match, formula=args.formula, + agentic=args.agentic, + max_hops=args.max_hops, + llm_rewrite=args.llm_rewrite, ) except ValueError as error: print(str(error), file=sys.stderr) diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/filesystem/connector.py b/clio-agentic-search/src/clio_agentic_search/connectors/filesystem/connector.py index d396ef3f..f1c4d722 100644 --- a/clio-agentic-search/src/clio_agentic_search/connectors/filesystem/connector.py +++ b/clio-agentic-search/src/clio_agentic_search/connectors/filesystem/connector.py @@ -41,6 +41,7 @@ ) from clio_agentic_search.retrieval.ann import ANNAdapter, AnnResult, build_ann_adapter from clio_agentic_search.retrieval.capabilities import ScoredChunk +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile, build_corpus_profile from clio_agentic_search.retrieval.scientific import ( ScientificQueryOperators, score_scientific_metadata, @@ -365,7 +366,7 @@ def search_lexical(self, query: str, top_k: int) -> list[ScoredChunk]: chunk_id=match.chunk.chunk_id, document_id=match.chunk.document_id, text=match.chunk.text, - lexical_score=match.overlap_count / len(query_tokens), + lexical_score=match.bm25_score, ) for match in matches ] @@ -453,6 +454,12 @@ def search_scientific( candidate_ids: set[str] | None = None + # When a quality filter is active, push the acceptable-flag list down + # to the SQL layer so we skip bad/missing rows without loading them. + acceptable_quality: tuple[str, ...] | None = None + if operators.quality_filter is not None: + acceptable_quality = operators.quality_filter.acceptable_strings() + if operators.numeric_range is not None: try: canonical_min = None @@ -469,7 +476,11 @@ def search_scientific( except ValueError: return [] range_chunks = self.storage.query_chunks_by_measurement_range( - self.namespace, canonical_unit, canonical_min, canonical_max + self.namespace, + canonical_unit, + canonical_min, + canonical_max, + acceptable_quality=acceptable_quality, ) range_ids = {c.chunk_id for c in range_chunks} candidate_ids = range_ids if candidate_ids is None else candidate_ids & range_ids @@ -520,6 +531,11 @@ def build_citation(self, chunk: ScoredChunk) -> CitationRecord: score=round(chunk.combined_score, 6), ) + def corpus_profile(self) -> CorpusProfile: + """Return a statistical profile of the indexed namespace.""" + self._ensure_connected() + return build_corpus_profile(self.storage, self.namespace) + def _build_chunks(self, *, document_id: str, text: str) -> ScientificChunkPlan: return build_structure_aware_chunk_plan( namespace=self.namespace, diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/hdf5/__init__.py b/clio-agentic-search/src/clio_agentic_search/connectors/hdf5/__init__.py new file mode 100644 index 00000000..5042365f --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/connectors/hdf5/__init__.py @@ -0,0 +1,5 @@ +"""HDF5 connector package.""" + +from clio_agentic_search.connectors.hdf5.connector import HDF5Connector + +__all__ = ["HDF5Connector"] diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/hdf5/connector.py b/clio-agentic-search/src/clio_agentic_search/connectors/hdf5/connector.py new file mode 100644 index 00000000..9860cbe0 --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/connectors/hdf5/connector.py @@ -0,0 +1,707 @@ +"""HDF5 namespace connector with incremental indexing.""" + +from __future__ import annotations + +import hashlib +import os +import threading +import time +from concurrent.futures import Future, ThreadPoolExecutor +from dataclasses import dataclass, field +from pathlib import Path + +from clio_agentic_search.core.connectors import ( + IndexReport, + NamespaceAuthConfig, + NamespaceRuntimeConfig, +) +from clio_agentic_search.indexing.lexical import ( + DEFAULT_STOPWORDS, + LexicalIngestionConfig, + LexicalPostingsIngestor, +) +from clio_agentic_search.indexing.scientific import ( + ScientificChunkPlan, + build_structure_aware_chunk_plan, + canonicalize_measurement, + normalize_formula, +) +from clio_agentic_search.indexing.text_features import ( + Embedder, + HashEmbedder, + tokenize, +) +from clio_agentic_search.models.contracts import ( + ChunkRecord, + CitationRecord, + DocumentRecord, + EmbeddingRecord, + MetadataRecord, + NamespaceDescriptor, +) +from clio_agentic_search.retrieval.ann import ANNAdapter, AnnResult, build_ann_adapter +from clio_agentic_search.retrieval.capabilities import ScoredChunk +from clio_agentic_search.retrieval.scientific import ( + ScientificQueryOperators, + score_scientific_metadata, +) +from clio_agentic_search.storage.contracts import DocumentBundle, FileIndexState, StorageAdapter + +try: + import h5py + + HAS_H5PY = True +except ImportError: + HAS_H5PY = False + +HDF5_SUFFIXES: frozenset[str] = frozenset({".h5", ".hdf5", ".hdf", ".he5", ".nc"}) + + +def _extract_hdf5_text(file_path: Path) -> str: + """Walk an HDF5 file and produce a text representation of its structure. + + For each group and dataset the output includes the path, shape, dtype, + and any HDF5 attributes (especially ``units``, ``long_name``, and + ``description``). + """ + sections: list[str] = [] + + def _visitor(name: str, obj: h5py.Dataset | h5py.Group) -> None: + lines: list[str] = [] + if isinstance(obj, h5py.Dataset): + lines.append(f"Dataset: /{name}") + lines.append(f"Shape: {obj.shape}") + lines.append(f"Dtype: {obj.dtype}") + else: + lines.append(f"Group: /{name}") + + if obj.attrs: + lines.append("Attributes:") + for attr_name in sorted(obj.attrs): + attr_value = obj.attrs[attr_name] + # Decode bytes-like attribute values when possible. + if isinstance(attr_value, bytes): + attr_value = attr_value.decode("utf-8", errors="replace") + lines.append(f" {attr_name}: {attr_value}") + sections.append("\n".join(lines)) + + with h5py.File(file_path, "r") as f: + # Emit root-level attributes first. + if f.attrs: + root_lines = ["Group: /", "Attributes:"] + for attr_name in sorted(f.attrs): + attr_value = f.attrs[attr_name] + if isinstance(attr_value, bytes): + attr_value = attr_value.decode("utf-8", errors="replace") + root_lines.append(f" {attr_name}: {attr_value}") + sections.append("\n".join(root_lines)) + f.visititems(_visitor) + + return "\n\n".join(sections) + + +@dataclass(slots=True) +class HDF5Connector: + """Connector that indexes HDF5 files with hybrid search capabilities. + + Walks a directory tree for HDF5 files, extracts group/dataset hierarchy, + shapes, dtypes, and attributes, then indexes the resulting text through + the scientific chunk pipeline. + """ + + namespace: str + root: Path + storage: StorageAdapter + embedder: Embedder = field(default_factory=HashEmbedder) + embedding_model: str = "hash16-v1" + chunk_size: int = 400 + reindex_delay_seconds: float = 0.0 + _runtime_config: NamespaceRuntimeConfig = field( + default_factory=lambda: NamespaceRuntimeConfig(options={}) + ) + _auth_config: NamespaceAuthConfig | None = None + ann_backend: str = "exact" + cache_shards: int = 16 + warmup_async: bool = True + document_batch_size: int = 32 + lexical_batch_size: int = 50_000 + lexical_df_prune_threshold: float = 0.98 + lexical_df_prune_min_chunks: int = 200 + lexical_max_tokens_per_chunk: int = 96 + lexical_prune_stopwords: bool = True + stopwords: frozenset[str] = DEFAULT_STOPWORDS + lexical_postings_compression: str = "none" + _connected: bool = False + _ann_index: ANNAdapter | None = field(default=None, init=False, repr=False) + _warmup_executor: ThreadPoolExecutor | None = field(default=None, init=False, repr=False) + _warmup_future: Future[None] | None = field(default=None, init=False, repr=False) + _runtime_lock: threading.RLock = field(default_factory=threading.RLock, init=False, repr=False) + + # ------------------------------------------------------------------ + # Configuration + # ------------------------------------------------------------------ + + def configure( + self, + *, + runtime_config: NamespaceRuntimeConfig, + auth_config: NamespaceAuthConfig | None, + ) -> None: + self._runtime_config = runtime_config + self._auth_config = auth_config + if "root" in runtime_config.options: + self.root = Path(runtime_config.options["root"]) + ann_backend = runtime_config.options.get("ann_backend") + if ann_backend: + self.ann_backend = ann_backend + cache_shards = runtime_config.options.get("cache_shards") + if cache_shards: + self.cache_shards = max(1, int(cache_shards)) + warmup_async = runtime_config.options.get("warmup_async") + if warmup_async: + self.warmup_async = _parse_bool(warmup_async) + document_batch_size = runtime_config.options.get("document_batch_size") + if document_batch_size: + self.document_batch_size = max(1, int(document_batch_size)) + if os.environ.get("CLIO_ANN_BACKEND"): + self.ann_backend = os.environ["CLIO_ANN_BACKEND"] + if os.environ.get("CLIO_CACHE_SHARDS"): + self.cache_shards = max(1, int(os.environ["CLIO_CACHE_SHARDS"])) + if os.environ.get("CLIO_VECTOR_WARMUP_ASYNC"): + self.warmup_async = _parse_bool(os.environ["CLIO_VECTOR_WARMUP_ASYNC"]) + if os.environ.get("CLIO_INDEX_DOCUMENT_BATCH_SIZE"): + self.document_batch_size = max(1, int(os.environ["CLIO_INDEX_DOCUMENT_BATCH_SIZE"])) + if os.environ.get("CLIO_LEXICAL_BATCH_SIZE"): + self.lexical_batch_size = max(1, int(os.environ["CLIO_LEXICAL_BATCH_SIZE"])) + if os.environ.get("CLIO_LEXICAL_DF_PRUNE_THRESHOLD"): + self.lexical_df_prune_threshold = float(os.environ["CLIO_LEXICAL_DF_PRUNE_THRESHOLD"]) + if os.environ.get("CLIO_LEXICAL_DF_PRUNE_MIN_CHUNKS"): + self.lexical_df_prune_min_chunks = max( + 1, + int(os.environ["CLIO_LEXICAL_DF_PRUNE_MIN_CHUNKS"]), + ) + if os.environ.get("CLIO_LEXICAL_MAX_TOKENS_PER_CHUNK"): + self.lexical_max_tokens_per_chunk = max( + 0, + int(os.environ["CLIO_LEXICAL_MAX_TOKENS_PER_CHUNK"]), + ) + if os.environ.get("CLIO_LEXICAL_PRUNE_STOPWORDS"): + self.lexical_prune_stopwords = _parse_bool(os.environ["CLIO_LEXICAL_PRUNE_STOPWORDS"]) + postings_compression = runtime_config.options.get("lexical_postings_compression") + if postings_compression: + self.lexical_postings_compression = _parse_postings_compression(postings_compression) + if os.environ.get("CLIO_LEXICAL_POSTINGS_COMPRESSION"): + self.lexical_postings_compression = _parse_postings_compression( + os.environ["CLIO_LEXICAL_POSTINGS_COMPRESSION"] + ) + + # ------------------------------------------------------------------ + # NamespaceConnector protocol + # ------------------------------------------------------------------ + + def descriptor(self) -> NamespaceDescriptor: + return NamespaceDescriptor( + name=self.namespace, + connector_type="hdf5", + root_uri=str(self.root.resolve()), + ) + + def connect(self) -> None: + if not HAS_H5PY: + raise RuntimeError( + "h5py is required for HDF5Connector but is not installed. " + "Install it with: pip install h5py" + ) + self.storage.connect() + self._connected = True + self._schedule_warmup() + + def teardown(self) -> None: + self._connected = False + self._stop_warmup_worker() + self.storage.teardown() + with self._runtime_lock: + self._ann_index = None + + def index(self, *, full_rebuild: bool = False) -> IndexReport: + self._ensure_connected() + start = time.perf_counter() + + if full_rebuild: + self.storage.clear_namespace(self.namespace) + + scanned_files = 0 + indexed_files = 0 + skipped_files = 0 + existing_paths: set[str] = set() + pending_bundles: list[DocumentBundle] = [] + lexical_ingestor = LexicalPostingsIngestor( + LexicalIngestionConfig( + batch_size=self.lexical_batch_size, + df_prune_threshold=self.lexical_df_prune_threshold, + df_prune_min_chunks=self.lexical_df_prune_min_chunks, + max_tokens_per_chunk=self.lexical_max_tokens_per_chunk, + prune_stopwords=self.lexical_prune_stopwords, + stopwords=self.stopwords, + postings_compression=self.lexical_postings_compression, + ) + ) + + try: + for file_path in sorted( + path + for path in self.root.rglob("*") + if path.is_file() and path.suffix.lower() in HDF5_SUFFIXES + ): + relative_path = file_path.relative_to(self.root).as_posix() + existing_paths.add(relative_path) + scanned_files += 1 + + content_bytes = file_path.read_bytes() + content_hash = hashlib.sha256(content_bytes).hexdigest() + mtime_ns = file_path.stat().st_mtime_ns + + if not full_rebuild: + previous = self.storage.get_file_state(self.namespace, relative_path) + if ( + previous is not None + and previous.mtime_ns == mtime_ns + and previous.content_hash == content_hash + ): + skipped_files += 1 + continue + + if self.reindex_delay_seconds > 0: + time.sleep(self.reindex_delay_seconds) + + document_id = hashlib.sha1(f"{self.namespace}:{relative_path}".encode()).hexdigest() + + text = _extract_hdf5_text(file_path) + if not text.strip(): + skipped_files += 1 + continue + + document = DocumentRecord( + namespace=self.namespace, + document_id=document_id, + uri=relative_path, + checksum=content_hash, + modified_at_ns=mtime_ns, + ) + chunk_plan = self._build_chunks(document_id=document_id, text=text) + chunks = chunk_plan.chunks + embeddings = [ + EmbeddingRecord( + namespace=self.namespace, + chunk_id=chunk.chunk_id, + model=self.embedding_model, + vector=self.embedder.embed(chunk.text), + ) + for chunk in chunks + ] + metadata = self._build_metadata( + relative_path=relative_path, + document_id=document_id, + chunks=chunks, + chunk_metadata=chunk_plan.metadata_by_chunk_id, + ) + file_state = FileIndexState( + namespace=self.namespace, + path=relative_path, + document_id=document_id, + mtime_ns=mtime_ns, + content_hash=content_hash, + ) + + pending_bundles.append( + DocumentBundle( + document=document, + chunks=chunks, + embeddings=embeddings, + metadata=metadata, + file_state=file_state, + ) + ) + if len(pending_bundles) >= self.document_batch_size: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + pending_bundles = [] + lexical_ingestor.add_chunks(chunks) + indexed_files += 1 + + if pending_bundles: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + removed_files = ( + 0 + if full_rebuild + else self.storage.remove_missing_paths(self.namespace, existing_paths) + ) + lexical_ingestor.flush(namespace=self.namespace, storage=self.storage) + finally: + lexical_ingestor.close() + + if full_rebuild or indexed_files > 0 or removed_files > 0: + self._refresh_vector_index() + elif self._ann_index is None: + self._schedule_warmup() + + elapsed_seconds = time.perf_counter() - start + return IndexReport( + scanned_files=scanned_files, + indexed_files=indexed_files, + skipped_files=skipped_files, + removed_files=removed_files, + elapsed_seconds=elapsed_seconds, + ) + + # ------------------------------------------------------------------ + # LexicalSearchCapable + # ------------------------------------------------------------------ + + def search_lexical(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + query_tokens = tuple(sorted(set(tokenize(query)))) + if not query_tokens: + return [] + + matches = self.storage.query_chunks_lexical( + namespace=self.namespace, + query_tokens=query_tokens, + limit=top_k, + ) + return [ + ScoredChunk( + chunk_id=match.chunk.chunk_id, + document_id=match.chunk.document_id, + text=match.chunk.text, + lexical_score=match.bm25_score, + ) + for match in matches + ] + + # ------------------------------------------------------------------ + # VectorSearchCapable + # ------------------------------------------------------------------ + + def search_vector(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + self._ensure_vector_index_ready() + with self._runtime_lock: + ann_index = self._ann_index + if ann_index is None: + return [] + query_vector = self.embedder.embed(query) + + candidate_ids: set[str] | None = None + if isinstance(self.embedder, HashEmbedder): + query_tokens = tuple(sorted(set(tokenize(query)))) + if query_tokens: + prefilter_limit = max(top_k * 40, 512) + candidate_ids = { + match.chunk.chunk_id + for match in self.storage.query_chunks_lexical( + namespace=self.namespace, + query_tokens=query_tokens, + limit=prefilter_limit, + ) + } + if not candidate_ids: + candidate_ids = None + neighbors = ann_index.query( + query_vector=query_vector, + top_k=top_k, + candidate_ids=candidate_ids, + ) + return self._neighbors_to_scored_chunks(neighbors) + + # ------------------------------------------------------------------ + # MetadataFilterCapable + # ------------------------------------------------------------------ + + def filter_metadata( + self, + candidates: list[ScoredChunk], + required: dict[str, str], + ) -> list[ScoredChunk]: + self._ensure_connected() + if not required: + return candidates + + filtered: list[ScoredChunk] = [] + for candidate in candidates: + metadata = self.storage.get_chunk_metadata(self.namespace, candidate.chunk_id) + if all(metadata.get(key) == value for key, value in required.items()): + filtered.append( + ScoredChunk( + chunk_id=candidate.chunk_id, + document_id=candidate.document_id, + text=candidate.text, + lexical_score=candidate.lexical_score, + vector_score=candidate.vector_score, + metadata_score=1.0, + ) + ) + return filtered + + # ------------------------------------------------------------------ + # ScientificSearchCapable + # ------------------------------------------------------------------ + + def search_scientific( + self, + query: str, + top_k: int, + operators: ScientificQueryOperators, + ) -> list[ScoredChunk]: + self._ensure_connected() + del query + if not operators.is_active(): + return [] + + candidate_ids: set[str] | None = None + + if operators.numeric_range is not None: + try: + canonical_min = None + canonical_max = None + canonical_unit = canonicalize_measurement(0.0, operators.numeric_range.unit)[1] + if operators.numeric_range.minimum is not None: + canonical_min = canonicalize_measurement( + operators.numeric_range.minimum, + operators.numeric_range.unit, + )[0] + if operators.numeric_range.maximum is not None: + canonical_max = canonicalize_measurement( + operators.numeric_range.maximum, + operators.numeric_range.unit, + )[0] + except ValueError: + return [] + range_chunks = self.storage.query_chunks_by_measurement_range( + self.namespace, canonical_unit, canonical_min, canonical_max + ) + range_ids = {c.chunk_id for c in range_chunks} + candidate_ids = range_ids if candidate_ids is None else candidate_ids & range_ids + + if operators.formula: + sig = normalize_formula(operators.formula) + formula_chunks = self.storage.query_chunks_by_formula(self.namespace, sig) + formula_ids = {c.chunk_id for c in formula_chunks} + candidate_ids = formula_ids if candidate_ids is None else candidate_ids & formula_ids + + if candidate_ids is not None: + chunks = [self.storage.get_chunk(self.namespace, cid) for cid in sorted(candidate_ids)] + else: + chunks = self.storage.list_chunks(self.namespace) + + scored: list[ScoredChunk] = [] + for chunk in chunks: + metadata = self.storage.get_chunk_metadata(self.namespace, chunk.chunk_id) + score = score_scientific_metadata(metadata, operators) + if score <= 0.0: + continue + scored.append( + ScoredChunk( + chunk_id=chunk.chunk_id, + document_id=chunk.document_id, + text=chunk.text, + metadata_score=score, + ) + ) + + scored.sort(key=lambda candidate: (-candidate.metadata_score, candidate.chunk_id)) + return scored[:top_k] + + # ------------------------------------------------------------------ + # Citation + # ------------------------------------------------------------------ + + def build_citation(self, chunk: ScoredChunk) -> CitationRecord: + stored_chunk = self.storage.get_chunk(self.namespace, chunk.chunk_id) + metadata = self.storage.get_chunk_metadata(self.namespace, stored_chunk.chunk_id) + uri = self.storage.get_document_uri(self.namespace, stored_chunk.document_id) + fragment = metadata.get("citation.fragment", "") + if fragment: + uri = f"{uri}#{fragment}" + snippet = stored_chunk.text.strip()[:160] + return CitationRecord( + namespace=self.namespace, + document_id=stored_chunk.document_id, + chunk_id=stored_chunk.chunk_id, + uri=uri, + snippet=snippet, + score=round(chunk.combined_score, 6), + ) + + # ------------------------------------------------------------------ + # Internal helpers + # ------------------------------------------------------------------ + + def _build_chunks(self, *, document_id: str, text: str) -> ScientificChunkPlan: + return build_structure_aware_chunk_plan( + namespace=self.namespace, + document_id=document_id, + text=text, + chunk_size=self.chunk_size, + ) + + def _build_metadata( + self, + *, + relative_path: str, + document_id: str, + chunks: list[ChunkRecord], + chunk_metadata: dict[str, dict[str, str]], + ) -> list[MetadataRecord]: + suffix = Path(relative_path).suffix.lower() + records: list[MetadataRecord] = [ + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="path", + value=relative_path, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="suffix", + value=suffix, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="format", + value="hdf5", + ), + ] + + for chunk in chunks: + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key="path", + value=relative_path, + ) + ) + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key="suffix", + value=suffix, + ) + ) + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key="format", + value="hdf5", + ) + ) + for key, value in sorted(chunk_metadata.get(chunk.chunk_id, {}).items()): + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key=key, + value=value, + ) + ) + return records + + def _ensure_connected(self) -> None: + if not self._connected: + raise RuntimeError("Connector is not connected") + + def _refresh_vector_index(self) -> None: + if not self._connected: + return + embeddings = self.storage.list_embeddings(self.namespace, self.embedding_model) + ann_index = build_ann_adapter( + backend=self.ann_backend, + dimensions=self.embedder.dimensions, + shard_count=max(1, self.cache_shards), + ) + ann_index.build(embeddings) + with self._runtime_lock: + if not self._connected: + return + self._ann_index = ann_index + + def _schedule_warmup(self) -> None: + if not self.warmup_async: + self._refresh_vector_index() + return + with self._runtime_lock: + if self._warmup_future is not None and not self._warmup_future.done(): + return + if self._warmup_executor is None: + self._warmup_executor = ThreadPoolExecutor( + max_workers=1, + thread_name_prefix=f"clio-warmup-{self.namespace}", + ) + self._warmup_future = self._warmup_executor.submit(self._refresh_vector_index) + + def _ensure_vector_index_ready(self) -> None: + with self._runtime_lock: + ann_index = self._ann_index + warmup_future = self._warmup_future + if ann_index is not None: + return + if warmup_future is not None: + warmup_future.result() + with self._runtime_lock: + if self._ann_index is not None: + return + self._refresh_vector_index() + + def _stop_warmup_worker(self) -> None: + with self._runtime_lock: + executor = self._warmup_executor + self._warmup_executor = None + self._warmup_future = None + if executor is not None: + executor.shutdown(wait=True, cancel_futures=True) + + def _neighbors_to_scored_chunks(self, neighbors: list[AnnResult]) -> list[ScoredChunk]: + scored: list[ScoredChunk] = [] + for neighbor in neighbors: + chunk = self.storage.get_chunk(self.namespace, neighbor.chunk_id) + scored.append( + ScoredChunk( + chunk_id=neighbor.chunk_id, + document_id=chunk.document_id, + text=chunk.text, + vector_score=neighbor.score, + ) + ) + return scored + + +def _parse_bool(value: str) -> bool: + return value.strip().lower() in {"1", "true", "yes", "on"} + + +def _parse_postings_compression(value: str) -> str: + normalized = value.strip().lower() + if normalized in {"", "none"}: + return "none" + if normalized in {"gzip", "gz"}: + return "gzip" + raise ValueError("Unsupported lexical postings compression; expected one of: none, gzip") diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/iowarp/__init__.py b/clio-agentic-search/src/clio_agentic_search/connectors/iowarp/__init__.py new file mode 100644 index 00000000..3512fe90 --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/connectors/iowarp/__init__.py @@ -0,0 +1 @@ +"""IOWarp CTE connector — indexes and searches blobs stored in IOWarp.""" diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/iowarp/connector.py b/clio-agentic-search/src/clio_agentic_search/connectors/iowarp/connector.py new file mode 100644 index 00000000..02ff7c0a --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/connectors/iowarp/connector.py @@ -0,0 +1,818 @@ +"""IOWarp CTE namespace connector. + +Bridges CLIO's retrieval pipeline to IOWarp's Context Transfer Engine. +Blobs live in CTE (managed by the clio_runtime / Chimaera runtime); this +connector: + + 1. Enumerates blobs via ``BlobQuery`` / ``Tag.GetContainedBlobs`` + 2. Reads blob content via ``Tag.GetBlob`` + 3. Indexes text + scientific metadata into CLIO's DuckDB store + 4. Searches using CLIO's standard lexical, vector, and scientific branches + +This lets CLIO's science-aware operators (SI unit conversion, formula +normalization, corpus profiling) run on data that physically resides in +IOWarp's tiered blob storage — the integration point the paper needs. + +The low-level CTE Python module is imported with backward compatibility: +clio-core v2.0.0+ (``pip install iowarp-core``) exposes it as the top-level +``clio_cte_core_ext``; older builds shipped it as +``iowarp_core.wrp_cte_core_ext``. The blob/tag API +(``get_cte_client``/``Tag``/``BlobQuery``/``GetContainedBlobs``/``GetBlob``) +is identical across both, so only the import path differs. +""" + +from __future__ import annotations + +import csv as _csv +import hashlib +import io as _io +import json as _json +import os +import time +from dataclasses import dataclass, field +from typing import Any + +try: + # clio-core v2.0.0+ (pip install iowarp-core): top-level module. + import clio_cte_core_ext as cte + + HAS_IOWARP = True +except ImportError: + try: + # Legacy iowarp_core wheel (pre-rebrand). + from iowarp_core import wrp_cte_core_ext as cte + + HAS_IOWARP = True + except ImportError: + HAS_IOWARP = False + cte = None + +from clio_agentic_search.core.connectors import IndexReport +from clio_agentic_search.indexing.lexical import ( + DEFAULT_STOPWORDS, + LexicalIngestionConfig, + LexicalPostingsIngestor, +) +from clio_agentic_search.indexing.scientific import ( + build_structure_aware_chunk_plan, + canonicalize_measurement, + normalize_formula, +) +from clio_agentic_search.indexing.text_features import Embedder, HashEmbedder, tokenize +from clio_agentic_search.models.contracts import ( + CitationRecord, + EmbeddingRecord, + MetadataRecord, + NamespaceDescriptor, +) +from clio_agentic_search.retrieval.ann import ANNAdapter, build_ann_adapter +from clio_agentic_search.retrieval.capabilities import ScoredChunk +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile, build_corpus_profile +from clio_agentic_search.retrieval.scientific import ( + ScientificQueryOperators, + score_scientific_metadata, +) +from clio_agentic_search.storage.contracts import DocumentBundle, FileIndexState, StorageAdapter + +# Whether the clio-core CTE client has been initialised in this process. +_CTE_CLIENT_READY = False + + +def _ensure_cte_client() -> None: + """Initialise the clio-core CTE client once per process. + + clio-core requires the Chimaera client and the CTE subsystem to be + initialised before ``get_cte_client()``/``Tag`` operations; skipping this + segfaults on the first ``Tag`` call against a live runtime. This mirrors + the official client bring-up sequence (``chimaera_init`` followed by + ``initialize_cte``). It is idempotent and a no-op on the legacy + ``wrp_cte_core_ext`` module, which does not expose these entry points. + + Honoured environment variables: + ``CLIO_SERVER_CONF`` runtime YAML path (default ``~/.clio/clio.yaml``) + ``CHI_WITH_RUNTIME`` ``1`` to start an in-process runtime (single-node); + otherwise the client attaches to an external + ``clio_run`` daemon. + """ + global _CTE_CLIENT_READY + if _CTE_CLIENT_READY: + return + chimaera_init = getattr(cte, "chimaera_init", None) + chimaera_mode = getattr(cte, "ChimaeraMode", None) + if chimaera_init is None or chimaera_mode is None: + # Legacy module: the client is initialised by the host process. + _CTE_CLIENT_READY = True + return + with_runtime = os.environ.get("CHI_WITH_RUNTIME", "0").strip().lower() in ("1", "true", "yes") + if not chimaera_init(chimaera_mode.kClient, with_runtime): + raise RuntimeError("Failed to initialise the IOWarp Chimaera client (chimaera_init)") + initialize_cte = getattr(cte, "initialize_cte", None) + if initialize_cte is not None: + config_path = os.environ.get("CLIO_SERVER_CONF") or os.path.expanduser("~/.clio/clio.yaml") + if not initialize_cte(config_path, cte.PoolQuery.Dynamic()): + raise RuntimeError( + "Failed to initialise the IOWarp CTE subsystem " + f"(initialize_cte, config={config_path})" + ) + _CTE_CLIENT_READY = True + + +@dataclass(slots=True) +class IOWarpConnector: + """CLIO connector for IOWarp CTE blob storage. + + Parameters + ---------- + namespace: + Logical namespace name used in CLIO's index. + tag_pattern: + Regex pattern for CTE tags to include (default ``".*"`` = all). + blob_pattern: + Regex pattern for blob names to include (default ``".*"`` = all). + storage: + A CLIO ``StorageAdapter`` (typically DuckDB) for the local index. + max_blobs_per_query: + Upper limit passed to ``BlobQuery`` during enumeration. + """ + + namespace: str + storage: StorageAdapter + tag_pattern: str = ".*" + blob_pattern: str = ".*" + max_blobs_per_query: int = 2_000_000 + embedder: Embedder = field(default_factory=HashEmbedder) + embedding_model: str = "hash16-v1" + chunk_size: int = 400 + ann_backend: str = "exact" + cache_shards: int = 16 + _connected: bool = False + _cte_client: Any = field(default=None, init=False, repr=False) + _ann_index: ANNAdapter | None = field(default=None, init=False, repr=False) + _tag_cache: dict[str, object] = field(default_factory=dict, init=False, repr=False) + + def descriptor(self) -> NamespaceDescriptor: + return NamespaceDescriptor( + name=self.namespace, + connector_type="iowarp", + root_uri=f"cte://{self.tag_pattern}", + ) + + def connect(self) -> None: + if not HAS_IOWARP: + raise RuntimeError( + "IOWarp CTE bindings are not installed. Install clio-core " + "(pip install iowarp-core), which provides the clio_cte_core_ext module." + ) + _ensure_cte_client() + self._cte_client = cte.get_cte_client() + self.storage.connect() + self._connected = True + + def teardown(self) -> None: + self._connected = False + self._ann_index = None + self._tag_cache.clear() + self.storage.teardown() + + def index( + self, + *, + full_rebuild: bool = False, + known_tag_names: list[str] | None = None, + ) -> IndexReport: + """Enumerate blobs from CTE, extract scientific metadata, build index. + + Parameters + ---------- + full_rebuild: + Clear the namespace before indexing. + known_tag_names: + Optional explicit list of tag names to enumerate. When provided, + uses ``Tag.GetContainedBlobs()`` on each tag — avoiding + ``BlobQuery`` (which hangs in iowarp_core 0.6.4 due to a + Broadcast-dispatch bug on aarch64 64KB-page systems like DeltaAI + GH200). When *not* provided, falls back to ``BlobQuery`` (works + on x86 and iowarp_core 1.0.3+). + """ + self._ensure_connected() + start = time.perf_counter() + + if full_rebuild: + self.storage.clear_namespace(self.namespace) + + # Discover blobs. + # known_tag_names fast path: use Tag.GetContainedBlobs() per tag. + # This avoids BlobQuery which hangs on iowarp_core 0.6.4 aarch64 + # (Broadcast dispatch deadlock). + if known_tag_names is not None: + raw_results: list[tuple[str, str]] = [] + import re as _re + + blob_re = _re.compile(self.blob_pattern) + for tag_name in known_tag_names: + tag_obj = self._get_or_create_tag(tag_name) + for blob_name in tag_obj.GetContainedBlobs(): + if blob_re.fullmatch(blob_name): + raw_results.append((tag_name, blob_name)) + else: + # BlobQuery path (iowarp_core 1.0.3+ / x86). + # Support both iowarp_core 0.6.4+ (requires MemContext as first + # arg) and 1.0.3 (no MemContext). + if hasattr(cte, "MemContext"): + _mctx = cte.MemContext() + raw_results = list( + self._cte_client.BlobQuery( + _mctx, + self.tag_pattern, + self.blob_pattern, + self.max_blobs_per_query, + cte.PoolQuery.Dynamic(), + ) + ) + else: + raw_results = list( + self._cte_client.BlobQuery( + self.tag_pattern, + self.blob_pattern, + self.max_blobs_per_query, + cte.PoolQuery.Dynamic(), + ) + ) + + scanned = len(raw_results) + indexed = 0 + skipped = 0 + pending_bundles: list[DocumentBundle] = [] + lexical_ingestor = LexicalPostingsIngestor( + LexicalIngestionConfig( + batch_size=50_000, + df_prune_threshold=0.98, + df_prune_min_chunks=200, + max_tokens_per_chunk=96, + prune_stopwords=True, + stopwords=DEFAULT_STOPWORDS, + postings_compression="none", + ) + ) + + try: + for item in raw_results: + # Each item is (tag_name, blob_name) or similar tuple + if isinstance(item, (list, tuple)) and len(item) >= 2: + tag_name, blob_name = str(item[0]), str(item[1]) + else: + tag_name, blob_name = str(item), str(item) + + # Read blob content from CTE + tag_obj = self._get_or_create_tag(tag_name) + try: + blob_size = tag_obj.GetBlobSize(blob_name) + if blob_size <= 0: + skipped += 1 + continue + content_bytes = tag_obj.GetBlob(blob_name, blob_size, 0) + except Exception: + skipped += 1 + continue + + raw = ( + content_bytes + if isinstance(content_bytes, bytes) + else str(content_bytes).encode() + ) + text = self._parse_blob_content(raw) + if not text.strip(): + skipped += 1 + continue + + # Build CLIO document from blob + blob_uri = f"cte://{tag_name}/{blob_name}" + content_hash = hashlib.sha256(raw).hexdigest() + document_id = hashlib.sha1(f"{self.namespace}:{blob_uri}".encode()).hexdigest() + + from clio_agentic_search.models.contracts import DocumentRecord + + document = DocumentRecord( + namespace=self.namespace, + document_id=document_id, + uri=blob_uri, + checksum=content_hash, + modified_at_ns=int(time.time_ns()), + ) + + chunk_plan = build_structure_aware_chunk_plan( + namespace=self.namespace, + document_id=document_id, + text=text, + chunk_size=self.chunk_size, + ) + chunks = chunk_plan.chunks + embeddings = [ + EmbeddingRecord( + namespace=self.namespace, + chunk_id=chunk.chunk_id, + model=self.embedding_model, + vector=self.embedder.embed(chunk.text), + ) + for chunk in chunks + ] + metadata = self._build_metadata( + blob_uri=blob_uri, + tag_name=tag_name, + blob_name=blob_name, + document_id=document_id, + chunks=chunks, + chunk_metadata=chunk_plan.metadata_by_chunk_id, + ) + file_state = FileIndexState( + namespace=self.namespace, + path=blob_uri, + document_id=document_id, + mtime_ns=int(time.time_ns()), + content_hash=content_hash, + ) + + pending_bundles.append( + DocumentBundle( + document=document, + chunks=chunks, + embeddings=embeddings, + metadata=metadata, + file_state=file_state, + ) + ) + if len(pending_bundles) >= 32: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + pending_bundles = [] + lexical_ingestor.add_chunks(chunks) + indexed += 1 + + if pending_bundles: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + lexical_ingestor.flush(namespace=self.namespace, storage=self.storage) + finally: + lexical_ingestor.close() + + # Build vector index + self._refresh_vector_index() + + elapsed = time.perf_counter() - start + return IndexReport( + scanned_files=scanned, + indexed_files=indexed, + skipped_files=skipped, + removed_files=0, + elapsed_seconds=elapsed, + ) + + def index_from_texts( + self, blob_texts: dict[str, str], *, full_rebuild: bool = False + ) -> IndexReport: + """Index blobs from pre-loaded text content. + + This avoids per-blob CTE reads during indexing — suitable when blobs + are ingested and indexed in the same pipeline (the production path). + ``blob_texts`` maps ``cte://tag/blob`` URIs to their text content. + """ + self._ensure_connected() + start = time.perf_counter() + + if full_rebuild: + self.storage.clear_namespace(self.namespace) + + indexed = 0 + skipped = 0 + pending_bundles: list[DocumentBundle] = [] + lexical_ingestor = LexicalPostingsIngestor( + LexicalIngestionConfig( + batch_size=50_000, + df_prune_threshold=0.98, + df_prune_min_chunks=200, + max_tokens_per_chunk=96, + prune_stopwords=True, + stopwords=DEFAULT_STOPWORDS, + postings_compression="none", + ) + ) + + try: + for blob_uri, text in blob_texts.items(): + if not text.strip(): + skipped += 1 + continue + + # Parse tag/blob from URI: cte://tag_name/blob_name + parts = blob_uri.replace("cte://", "").split("/", 1) + tag_name = parts[0] if len(parts) > 0 else "unknown" + blob_name = parts[1] if len(parts) > 1 else "unknown" + + content_hash = hashlib.sha256(text.encode()).hexdigest() + document_id = hashlib.sha1(f"{self.namespace}:{blob_uri}".encode()).hexdigest() + + from clio_agentic_search.models.contracts import DocumentRecord + + document = DocumentRecord( + namespace=self.namespace, + document_id=document_id, + uri=blob_uri, + checksum=content_hash, + modified_at_ns=int(time.time_ns()), + ) + + chunk_plan = build_structure_aware_chunk_plan( + namespace=self.namespace, + document_id=document_id, + text=text, + chunk_size=self.chunk_size, + ) + chunks = chunk_plan.chunks + embeddings = [ + EmbeddingRecord( + namespace=self.namespace, + chunk_id=chunk.chunk_id, + model=self.embedding_model, + vector=self.embedder.embed(chunk.text), + ) + for chunk in chunks + ] + metadata = self._build_metadata( + blob_uri=blob_uri, + tag_name=tag_name, + blob_name=blob_name, + document_id=document_id, + chunks=chunks, + chunk_metadata=chunk_plan.metadata_by_chunk_id, + ) + file_state = FileIndexState( + namespace=self.namespace, + path=blob_uri, + document_id=document_id, + mtime_ns=int(time.time_ns()), + content_hash=content_hash, + ) + + pending_bundles.append( + DocumentBundle( + document=document, + chunks=chunks, + embeddings=embeddings, + metadata=metadata, + file_state=file_state, + ) + ) + if len(pending_bundles) >= 500: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + pending_bundles = [] + lexical_ingestor.add_chunks(chunks) + indexed += 1 + + if pending_bundles: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + lexical_ingestor.flush(namespace=self.namespace, storage=self.storage) + finally: + lexical_ingestor.close() + + self._refresh_vector_index() + + elapsed = time.perf_counter() - start + return IndexReport( + scanned_files=len(blob_texts), + indexed_files=indexed, + skipped_files=skipped, + removed_files=0, + elapsed_seconds=elapsed, + ) + + def search_lexical(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + query_tokens = tuple(sorted(set(tokenize(query)))) + if not query_tokens: + return [] + matches = self.storage.query_chunks_lexical( + namespace=self.namespace, + query_tokens=query_tokens, + limit=top_k, + ) + return [ + ScoredChunk( + chunk_id=match.chunk.chunk_id, + document_id=match.chunk.document_id, + text=match.chunk.text, + lexical_score=match.bm25_score, + ) + for match in matches + ] + + def search_vector(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + if self._ann_index is None: + return [] + query_vector = self.embedder.embed(query) + candidate_ids: set[str] | None = None + if isinstance(self.embedder, HashEmbedder): + query_tokens = tuple(sorted(set(tokenize(query)))) + if query_tokens: + prefilter_limit = max(top_k * 40, 512) + candidate_ids = { + match.chunk.chunk_id + for match in self.storage.query_chunks_lexical( + namespace=self.namespace, + query_tokens=query_tokens, + limit=prefilter_limit, + ) + } + if not candidate_ids: + candidate_ids = None + neighbors = self._ann_index.query( + query_vector=query_vector, + top_k=top_k, + candidate_ids=candidate_ids, + ) + scored: list[ScoredChunk] = [] + for neighbor in neighbors: + chunk = self.storage.get_chunk(self.namespace, neighbor.chunk_id) + scored.append( + ScoredChunk( + chunk_id=neighbor.chunk_id, + document_id=chunk.document_id, + text=chunk.text, + vector_score=neighbor.score, + ) + ) + return scored + + def search_scientific( + self, + query: str, + top_k: int, + operators: ScientificQueryOperators, + ) -> list[ScoredChunk]: + self._ensure_connected() + del query + if not operators.is_active(): + return [] + + candidate_ids: set[str] | None = None + + if operators.numeric_range is not None: + try: + canonical_unit = canonicalize_measurement(0.0, operators.numeric_range.unit)[1] + canonical_min = ( + canonicalize_measurement( + operators.numeric_range.minimum, operators.numeric_range.unit + )[0] + if operators.numeric_range.minimum is not None + else None + ) + canonical_max = ( + canonicalize_measurement( + operators.numeric_range.maximum, operators.numeric_range.unit + )[0] + if operators.numeric_range.maximum is not None + else None + ) + except ValueError: + return [] + range_chunks = self.storage.query_chunks_by_measurement_range( + self.namespace, + canonical_unit, + canonical_min, + canonical_max, + ) + range_ids = {c.chunk_id for c in range_chunks} + candidate_ids = range_ids if candidate_ids is None else candidate_ids & range_ids + + if operators.formula: + sig = normalize_formula(operators.formula) + formula_chunks = self.storage.query_chunks_by_formula(self.namespace, sig) + formula_ids = {c.chunk_id for c in formula_chunks} + candidate_ids = formula_ids if candidate_ids is None else candidate_ids & formula_ids + + if candidate_ids is not None: + chunks = [self.storage.get_chunk(self.namespace, cid) for cid in sorted(candidate_ids)] + else: + chunks = self.storage.list_chunks(self.namespace) + + scored: list[ScoredChunk] = [] + for chunk in chunks: + metadata = self.storage.get_chunk_metadata(self.namespace, chunk.chunk_id) + score = score_scientific_metadata(metadata, operators) + if score <= 0.0: + continue + scored.append( + ScoredChunk( + chunk_id=chunk.chunk_id, + document_id=chunk.document_id, + text=chunk.text, + metadata_score=score, + ) + ) + + scored.sort(key=lambda c: (-c.metadata_score, c.chunk_id)) + return scored[:top_k] + + def filter_metadata( + self, + candidates: list[ScoredChunk], + required: dict[str, str], + ) -> list[ScoredChunk]: + self._ensure_connected() + if not required: + return candidates + filtered: list[ScoredChunk] = [] + for candidate in candidates: + metadata = self.storage.get_chunk_metadata(self.namespace, candidate.chunk_id) + if all(metadata.get(key) == value for key, value in required.items()): + filtered.append( + ScoredChunk( + chunk_id=candidate.chunk_id, + document_id=candidate.document_id, + text=candidate.text, + lexical_score=candidate.lexical_score, + vector_score=candidate.vector_score, + metadata_score=1.0, + ) + ) + return filtered + + def build_citation(self, chunk: ScoredChunk) -> CitationRecord: + stored_chunk = self.storage.get_chunk(self.namespace, chunk.chunk_id) + uri = self.storage.get_document_uri(self.namespace, stored_chunk.document_id) + snippet = stored_chunk.text.strip()[:160] + return CitationRecord( + namespace=self.namespace, + document_id=stored_chunk.document_id, + chunk_id=stored_chunk.chunk_id, + uri=uri, + snippet=snippet, + score=round(chunk.combined_score, 6), + ) + + def corpus_profile(self) -> CorpusProfile: + self._ensure_connected() + return build_corpus_profile(self.storage, self.namespace) + + # ------------------------------------------------------------------ + # Internal helpers + # ------------------------------------------------------------------ + + def _get_or_create_tag(self, tag_name: str) -> Any: + if tag_name not in self._tag_cache: + self._tag_cache[tag_name] = cte.Tag(tag_name) + return self._tag_cache[tag_name] + + def _build_metadata( + self, + *, + blob_uri: str, + tag_name: str, + blob_name: str, + document_id: str, + chunks: list[Any], + chunk_metadata: dict[str, dict[str, str]], + ) -> list[MetadataRecord]: + records: list[MetadataRecord] = [ + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="path", + value=blob_uri, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="cte_tag", + value=tag_name, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="cte_blob", + value=blob_name, + ), + ] + for chunk in chunks: + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key="path", + value=blob_uri, + ) + ) + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key="cte_tag", + value=tag_name, + ) + ) + for key, value in sorted(chunk_metadata.get(chunk.chunk_id, {}).items()): + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key=key, + value=value, + ) + ) + return records + + def _refresh_vector_index(self) -> None: + if not self._connected: + return + embeddings = self.storage.list_embeddings(self.namespace, self.embedding_model) + ann_index = build_ann_adapter( + backend=self.ann_backend, + dimensions=self.embedder.dimensions, + shard_count=max(1, self.cache_shards), + ) + ann_index.build(embeddings) + self._ann_index = ann_index + + def _parse_blob_content(self, content_bytes: bytes) -> str: + """Parse blob bytes into indexable text regardless of format. + + Tries formats in order: JSON → CSV → UTF-8 text → binary summary. + Synthesizes measurement-friendly text so CLIO's SI unit extraction + works even when blobs carry no external metadata — CLIO reads what + is *inside* the blob to build the index. + """ + # --- Try JSON --- + try: + data = _json.loads(content_bytes) + return self._json_to_measurement_text(data) + except (_json.JSONDecodeError, UnicodeDecodeError, ValueError): + pass + + # --- Try CSV --- + try: + text = content_bytes.decode("utf-8") + lines = text.splitlines() + if len(lines) >= 2 and "," in lines[0]: + return self._csv_to_measurement_text(text) + except UnicodeDecodeError: + pass + + # --- Try plain UTF-8 text --- + try: + return content_bytes.decode("utf-8") + except UnicodeDecodeError: + pass + + # --- Binary fallback --- + return f"binary blob {len(content_bytes)} bytes" + + def _json_to_measurement_text(self, data: object) -> str: + """Flatten JSON to measurement-friendly text. + + Concatenates all string values and numeric values so that patterns + like ``"23.15 degC"`` appear adjacent in the output and can be + picked up by CLIO's measurement extraction regex. + """ + if not isinstance(data, dict): + return str(data) + parts: list[str] = [] + for value in data.values(): + if isinstance(value, str): + parts.append(value) + elif isinstance(value, (int, float)): + parts.append(str(value)) + elif isinstance(value, (list, dict)): + parts.append(self._json_to_measurement_text(value)) + return " ".join(parts) + + def _csv_to_measurement_text(self, text: str) -> str: + """Parse CSV, synthesize measurement text from header + all data rows.""" + reader = _csv.DictReader(_io.StringIO(text)) + parts: list[str] = [] + for row in reader: + parts.extend(f"{k} {v}" for k, v in row.items() if v.strip()) + return " | ".join(parts) + + def _ensure_connected(self) -> None: + if not self._connected: + raise RuntimeError("IOWarpConnector is not connected — call connect() first") diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/ndp/__init__.py b/clio-agentic-search/src/clio_agentic_search/connectors/ndp/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/ndp/connector.py b/clio-agentic-search/src/clio_agentic_search/connectors/ndp/connector.py new file mode 100644 index 00000000..df7e14e5 --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/connectors/ndp/connector.py @@ -0,0 +1,633 @@ +"""NDP (National Data Platform) connector for dataset discovery via CKAN API. + +This connector implements the Discover stage of the CLIO Search agentic pipeline: +it queries the NDP CKAN API to discover scientific datasets, extracts metadata +(titles, descriptions, resources, organizations), and indexes them into the +CLIO Search pipeline for science-aware retrieval. +""" + +from __future__ import annotations + +import hashlib +import time +from dataclasses import dataclass, field +from typing import Any + +import httpx + +from clio_agentic_search.indexing.scientific import ( + Measurement, + build_structure_aware_chunk_plan, + canonicalize_measurement, + normalize_formula, +) +from clio_agentic_search.indexing.text_features import Embedder, HashEmbedder, tokenize +from clio_agentic_search.models.contracts import ( + ChunkRecord, + CitationRecord, + DocumentRecord, + EmbeddingRecord, + MetadataRecord, + NamespaceDescriptor, +) +from clio_agentic_search.retrieval.ann import ANNAdapter, build_ann_adapter +from clio_agentic_search.retrieval.capabilities import ScoredChunk +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile, build_corpus_profile +from clio_agentic_search.retrieval.scientific import ( + ScientificQueryOperators, + score_scientific_metadata, +) +from clio_agentic_search.storage.contracts import FileIndexState, StorageAdapter + +NDP_BASE_URL = "http://155.101.6.191:8003" + + +@dataclass(slots=True) +class NDPConnector: + """Connector that discovers and indexes datasets from the NDP CKAN API.""" + + namespace: str + storage: StorageAdapter + base_url: str = NDP_BASE_URL + server: str = "global" + embedder: Embedder = field(default_factory=HashEmbedder) + embedding_model: str = "hash16-v1" + chunk_size: int = 400 + _connected: bool = False + _ann_index: ANNAdapter | None = field(default=None, init=False, repr=False) + + def descriptor(self) -> NamespaceDescriptor: + return NamespaceDescriptor( + name=self.namespace, + connector_type="ndp", + root_uri=self.base_url, + ) + + def connect(self) -> None: + self.storage.connect() + self._connected = True + + def teardown(self) -> None: + self.storage.teardown() + self._connected = False + + def _ensure_connected(self) -> None: + if not self._connected: + raise RuntimeError("NDPConnector not connected. Call connect() first.") + + def discover_datasets( + self, + search_terms: list[str] | None = None, + search_term: str | None = None, + limit: int = 50, + ) -> list[dict[str, Any]]: + """Query NDP API to discover datasets. Returns raw dataset dicts.""" + self._ensure_connected() + with httpx.Client(timeout=30.0) as client: + if search_terms: + params: dict[str, Any] = { + "terms": search_terms[0], + "server": self.server, + } + resp = client.get(f"{self.base_url}/search", params=params) + elif search_term: + data = {"search_term": search_term, "server": self.server} + resp = client.post(f"{self.base_url}/search", json=data) + else: + params = {"terms": "", "server": self.server} + resp = client.get(f"{self.base_url}/search", params=params) + + resp.raise_for_status() + datasets = resp.json() + + if isinstance(datasets, list): + return datasets[:limit] + return [] + + def index_datasets(self, datasets: list[dict[str, Any]]) -> int: + """Index discovered NDP datasets into the CLIO Search storage.""" + self._ensure_connected() + indexed = 0 + + for ds in datasets: + ds_id = ds.get("id", "") + ds_name = ds.get("name", ds_id) + ds_title = ds.get("title", ds_name) + ds_notes = ds.get("notes", "") or "" + ds_org = ds.get("owner_org", "") or "" + resources = ds.get("resources", []) + + # Build document text as a SINGLE flat paragraph (no sub-headings) + # to prevent the chunker from splitting resources into fake datasets. + text_parts = [f"# {ds_title}", ""] + if ds_org: + text_parts.append(f"Organization: {ds_org}") + if ds_notes: + text_parts.append(ds_notes) + + # Flatten resources into a single "Resources:" block — one line each. + if resources: + text_parts.append("") + text_parts.append("Resources:") + for i, res in enumerate(resources): + res_name = res.get("name", f"Resource {i + 1}") + res_fmt = res.get("format", "") or "" + res_url = res.get("url", "") or "" + res_desc = res.get("description", "") or "" + line = f"- {res_name}" + if res_fmt: + line += f" [{res_fmt}]" + if res_desc: + line += f": {res_desc[:100]}" + if res_url: + line += f" ({res_url})" + text_parts.append(line) + + text = "\n".join(text_parts) + + # Build structured metadata for URLs, formats, DOIs, organization + resource_urls = "; ".join(r.get("url", "") for r in resources if r.get("url")) + resource_formats = "; ".join( + sorted({r.get("format", "") for r in resources if r.get("format")}) + ) + # Try to find DOI in notes or resource URLs + doi = "" + if "doi.org" in (ds_notes or ""): + import re as _re + + m = _re.search(r"(10\.\d{4,}[-._;()/:A-Za-z0-9]+)", ds_notes or "") + if m: + doi = m.group(1) + if not text.strip(): + continue + + document_id = f"ndp_{ds_id[:12]}" if ds_id else f"ndp_{ds_name}" + uri = f"ndp://{self.server}/{ds_name}" + checksum = hashlib.sha256(text.encode()).hexdigest() + + doc = DocumentRecord( + namespace=self.namespace, + document_id=document_id, + uri=uri, + checksum=checksum, + modified_at_ns=time.time_ns(), + ) + + # Build chunks using science-aware chunking + plan = build_structure_aware_chunk_plan( + namespace=self.namespace, + document_id=document_id, + text=text, + chunk_size=self.chunk_size, + ) + + # Build embeddings + embeddings = [ + EmbeddingRecord( + namespace=self.namespace, + chunk_id=chunk.chunk_id, + model=self.embedding_model, + vector=self.embedder.embed(chunk.text), + ) + for chunk in plan.chunks + ] + + # Build metadata (preserve URLs, formats, DOI for result display) + metadata_records: list[MetadataRecord] = [ + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="source", + value="ndp", + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="organization", + value=ds_org, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="ndp_id", + value=ds_id, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="title", + value=ds_title, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="resource_urls", + value=resource_urls, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="resource_formats", + value=resource_formats, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="doi", + value=doi, + ), + ] + + # Add chunk-level scientific metadata + for chunk in plan.chunks: + chunk_meta = plan.metadata_by_chunk_id.get(chunk.chunk_id, {}) + for key, value in sorted(chunk_meta.items()): + metadata_records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key=key, + value=value, + ) + ) + + file_state = FileIndexState( + namespace=self.namespace, + path=uri, + document_id=document_id, + mtime_ns=time.time_ns(), + content_hash=checksum, + ) + + self.storage.upsert_document_bundle( + document=doc, + chunks=plan.chunks, + embeddings=embeddings, + metadata=metadata_records, + file_state=file_state, + ) + indexed += 1 + + # Build ANN index from stored embeddings + embeddings_map = self.storage.list_embeddings(self.namespace, self.embedding_model) + if embeddings_map: + sample_vec = next(iter(embeddings_map.values())) + dims = len(sample_vec) + ann = build_ann_adapter(backend="exact", dimensions=dims, shard_count=4) + ann.build(embeddings_map) + self._ann_index = ann + + return indexed + + # ------------------------------------------------------------------ + # CSV row ingestion — indexes actual measurement rows from CSV resources + # linked in NDP datasets, so that scientific_measurements has real + # canonical values for query_chunks_by_measurement_range(). + # ------------------------------------------------------------------ + + def index_csv_resources( + self, + datasets: list[dict[str, Any]], + *, + max_csvs: int = 5, + max_rows_per_csv: int = 5000, + max_download_bytes: int = 50 * 1024 * 1024, + timeout_s: float = 60.0, + ) -> dict[str, Any]: + """Download CSV resources from NDP datasets and index row-level data. + + For each CSV found in the datasets' resource lists: + 1. Download the CSV (bounded by *max_download_bytes*) + 2. Parse with ``parse_scientific_csv`` (extracts measurements, + canonicalises units via SI registry, tags quality flags) + 3. Group rows into chunks (~20 rows each), build metadata with + ``encode_measurements``, upsert into DuckDB + + Returns a stats dict: csvs_processed, rows_indexed, measurements_found. + """ + from clio_agentic_search.indexing.csv_parser import parse_scientific_csv + from clio_agentic_search.indexing.scientific import encode_measurements + + self._ensure_connected() + + csv_urls: list[dict[str, str]] = [] + seen_urls: set[str] = set() + for ds in datasets: + ds_title = ds.get("title", ds.get("name", "?")) + for res in ds.get("resources", []): + fmt = (res.get("format") or "").upper() + url = res.get("url") or "" + if fmt == "CSV" and url.startswith("http"): + if "all_stations" in url.lower(): + continue + if url in seen_urls: + continue + seen_urls.add(url) + csv_urls.append( + { + "url": url, + "dataset_title": ds_title, + "resource_name": res.get("name", "resource"), + "dataset_id": ds.get("id", "")[:12], + } + ) + # Cap at max_csvs after scanning ALL datasets + csv_urls = csv_urls[:max_csvs] + + stats: dict[str, Any] = { + "csvs_attempted": len(csv_urls), + "csvs_processed": 0, + "rows_indexed": 0, + "measurements_found": 0, + "errors": [], + } + + rows_per_chunk = 20 + for csv_info in csv_urls: + url = csv_info["url"] + try: + with httpx.Client(timeout=timeout_s) as client: + resp = client.get(url, follow_redirects=True) + resp.raise_for_status() + if len(resp.content) > max_download_bytes: + stats["errors"].append(f"Too large: {url}") + continue + csv_text = resp.text + except Exception as e: + stats["errors"].append(f"Download failed {url}: {e}") + continue + + parsed = parse_scientific_csv(csv_text, max_rows=max_rows_per_csv) + if not parsed.schema.measurement_columns: + continue # no measurable columns detected + + # Build chunks of ~rows_per_chunk rows each + doc_id = f"csv_{csv_info['dataset_id']}_{csv_info['resource_name'][:20]}" + doc_id = doc_id.replace(" ", "_").replace("/", "_")[:60] + uri = f"ndp-csv://{url}" + doc_checksum = hashlib.sha256(url.encode()).hexdigest() + + doc = DocumentRecord( + namespace=self.namespace, + document_id=doc_id, + uri=uri, + checksum=doc_checksum, + modified_at_ns=time.time_ns(), + ) + + chunks: list[ChunkRecord] = [] + embeddings: list[EmbeddingRecord] = [] + metadata_records: list[MetadataRecord] = [ + MetadataRecord( + namespace=self.namespace, + record_id=doc_id, + scope="document", + key="source", + value="ndp-csv", + ), + MetadataRecord( + namespace=self.namespace, + record_id=doc_id, + scope="document", + key="title", + value=csv_info["dataset_title"][:200], + ), + MetadataRecord( + namespace=self.namespace, + record_id=doc_id, + scope="document", + key="csv_url", + value=url, + ), + ] + + all_measurements_in_doc = 0 + for batch_start in range(0, len(parsed.rows), rows_per_chunk): + batch = parsed.rows[batch_start : batch_start + rows_per_chunk] + # Build chunk text from the compact data rows. + data_lines = [] + batch_measurements: list[Measurement] = [] + for row in batch: + # Rebuild the row text from context + measurements + parts = [] + for k, v in row.context.items(): + parts.append(f"{k}={v}") + for m in row.measurements: + parts.append(f"{m.raw_value} {m.raw_unit}") + batch_measurements.append(m) + data_lines.append("; ".join(parts)) + + chunk_text = f"[{csv_info['dataset_title'][:80]}]\n" + "\n".join( + data_lines[:rows_per_chunk] + ) + chunk_idx = batch_start // rows_per_chunk + chunk_id = hashlib.sha1(f"{doc_id}_c{chunk_idx}".encode()).hexdigest() + + chunk = ChunkRecord( + namespace=self.namespace, + chunk_id=chunk_id, + document_id=doc_id, + chunk_index=chunk_idx, + text=chunk_text, + start_offset=batch_start, + end_offset=batch_start + len(batch), + ) + chunks.append(chunk) + + emb = EmbeddingRecord( + namespace=self.namespace, + chunk_id=chunk_id, + model=self.embedding_model, + vector=self.embedder.embed(chunk_text), + ) + embeddings.append(emb) + + # Store scientific measurements as chunk metadata + if batch_measurements: + encoded = encode_measurements(batch_measurements) + metadata_records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk_id, + scope="chunk", + key="scientific.measurements", + value=encoded, + ) + ) + all_measurements_in_doc += len(batch_measurements) + + if not chunks: + continue + + file_state = FileIndexState( + namespace=self.namespace, + path=uri, + document_id=doc_id, + mtime_ns=time.time_ns(), + content_hash=doc_checksum, + ) + + self.storage.upsert_document_bundle( + document=doc, + chunks=chunks, + embeddings=embeddings, + metadata=metadata_records, + file_state=file_state, + ) + + stats["csvs_processed"] += 1 + stats["rows_indexed"] += len(parsed.rows) + stats["measurements_found"] += all_measurements_in_doc + + # Rebuild ANN index to include new CSV chunks + embeddings_map = self.storage.list_embeddings( + self.namespace, + self.embedding_model, + ) + if embeddings_map: + sample_vec = next(iter(embeddings_map.values())) + dims = len(sample_vec) + ann = build_ann_adapter(backend="exact", dimensions=dims, shard_count=4) + ann.build(embeddings_map) + self._ann_index = ann + + return stats + + def search_lexical(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + query_tokens = tuple(sorted(set(tokenize(query)))) + if not query_tokens: + return [] + matches = self.storage.query_chunks_lexical( + namespace=self.namespace, query_tokens=query_tokens, limit=top_k + ) + return [ + ScoredChunk( + chunk_id=m.chunk.chunk_id, + document_id=m.chunk.document_id, + text=m.chunk.text, + lexical_score=m.bm25_score, + ) + for m in matches + ] + + def search_vector(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + if self._ann_index is None: + return [] + query_vec = self.embedder.embed(query) + results = self._ann_index.query(query_vector=query_vec, top_k=top_k) + chunks = [] + for r in results: + stored = self.storage.get_chunk(self.namespace, r.chunk_id) + if stored: + chunks.append( + ScoredChunk( + chunk_id=r.chunk_id, + document_id=stored.document_id, + text=stored.text, + vector_score=r.score, + ) + ) + return chunks + + def search_scientific( + self, query: str, top_k: int, operators: ScientificQueryOperators + ) -> list[ScoredChunk]: + self._ensure_connected() + if not operators.is_active(): + return [] + + candidate_ids: set[str] | None = None + + if operators.numeric_range is not None: + try: + canonical_unit = canonicalize_measurement(0.0, operators.numeric_range.unit)[1] + canonical_min = None + canonical_max = None + if operators.numeric_range.minimum is not None: + canonical_min = canonicalize_measurement( + operators.numeric_range.minimum, operators.numeric_range.unit + )[0] + if operators.numeric_range.maximum is not None: + canonical_max = canonicalize_measurement( + operators.numeric_range.maximum, operators.numeric_range.unit + )[0] + + range_chunks = self.storage.query_chunks_by_measurement_range( + self.namespace, + canonical_unit=canonical_unit, + minimum=canonical_min, + maximum=canonical_max, + ) + candidate_ids = {c.chunk_id for c in range_chunks} + except (KeyError, ValueError): + candidate_ids = set() + + if operators.formula is not None: + norm = normalize_formula(operators.formula) + formula_chunks = self.storage.query_chunks_by_formula( + self.namespace, + formula_signature=norm, + ) + formula_ids = {c.chunk_id for c in formula_chunks} + if candidate_ids is None: + candidate_ids = formula_ids + else: + candidate_ids &= formula_ids + + if candidate_ids is None: + return [] + + results: list[ScoredChunk] = [] + for chunk_id in list(candidate_ids)[:top_k]: + stored = self.storage.get_chunk(self.namespace, chunk_id) + if stored: + meta = self.storage.get_chunk_metadata(self.namespace, chunk_id) + sci_score = score_scientific_metadata(meta, operators) + results.append( + ScoredChunk( + chunk_id=chunk_id, + document_id=stored.document_id, + text=stored.text, + metadata_score=sci_score, + ) + ) + return sorted(results, key=lambda c: -c.metadata_score)[:top_k] + + def filter_metadata( + self, candidates: list[ScoredChunk], required: dict[str, str] + ) -> list[ScoredChunk]: + if not required: + return candidates + filtered = [] + for c in candidates: + meta = self.storage.get_chunk_metadata(self.namespace, c.chunk_id) + if all(meta.get(k) == v for k, v in required.items()): + filtered.append(c) + return filtered + + def corpus_profile(self) -> CorpusProfile: + self._ensure_connected() + return build_corpus_profile(self.storage, self.namespace) + + def build_citation(self, chunk: ScoredChunk) -> CitationRecord: + self._ensure_connected() + meta = self.storage.get_chunk_metadata(self.namespace, chunk.chunk_id) + uri = meta.get("path", f"ndp://{self.namespace}/{chunk.document_id}") + return CitationRecord( + namespace=self.namespace, + document_id=chunk.document_id, + chunk_id=chunk.chunk_id, + uri=uri, + snippet=chunk.text.strip()[:160], + score=round(chunk.combined_score, 6), + ) diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/ndp/mcp_client.py b/clio-agentic-search/src/clio_agentic_search/connectors/ndp/mcp_client.py new file mode 100644 index 00000000..1d5e7e6c --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/connectors/ndp/mcp_client.py @@ -0,0 +1,107 @@ +"""NDP-MCP client: CLIO talks to the NDP MCP server as an MCP client. + +This is how CLIO integrates with the NDP-MCP server from clio-kit: + - CLIO spawns ndp-mcp as a subprocess (stdio transport) + - CLIO calls its tools via the MCP protocol (list_tools, call_tool) + - CLIO processes the results through its own pipeline (profile, index, search) + +This is the "correct" architecture: CLIO is the agentic layer that USES MCPs. +""" + +from __future__ import annotations + +import json +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager +from typing import Any + +from mcp import ClientSession, StdioServerParameters +from mcp.client.stdio import stdio_client + + +class NDPMCPClient: + """MCP client that talks to the NDP-MCP server via stdio.""" + + def __init__(self, ndp_mcp_binary: str = "ndp-mcp"): + self.binary = ndp_mcp_binary + self._session: ClientSession | None = None + self._context = None + + @asynccontextmanager + async def connect(self) -> AsyncIterator[NDPMCPClient]: + """Connect to NDP-MCP server as a subprocess.""" + params = StdioServerParameters( + command=self.binary, + args=["--transport", "stdio"], + ) + async with stdio_client(params) as (read, write): + async with ClientSession(read, write) as session: + await session.initialize() + self._session = session + try: + yield self + finally: + self._session = None + + async def list_tools(self) -> list[str]: + """List tools exposed by NDP-MCP.""" + if self._session is None: + raise RuntimeError("Not connected") + result = await self._session.list_tools() + return [t.name for t in result.tools] + + async def search_datasets( + self, + search_terms: list[str], + server: str = "global", + limit: int = 20, + ) -> list[dict[str, Any]]: + """Call NDP-MCP's search_datasets tool.""" + if self._session is None: + raise RuntimeError("Not connected") + + all_datasets: list[dict[str, Any]] = [] + seen_ids: set[str] = set() + + for term in search_terms: + try: + result = await self._session.call_tool( + "search_datasets", + arguments={ + "search_terms": [term], + "server": server, + "limit": str(limit), + }, + ) + # result.content is a list of content blocks + for block in result.content: + if hasattr(block, "text"): + try: + data = json.loads(block.text) + if isinstance(data, dict) and "datasets" in data: + for ds in data["datasets"]: + if ds.get("id") not in seen_ids: + all_datasets.append(ds) + seen_ids.add(ds.get("id")) + except (json.JSONDecodeError, KeyError): + pass + except Exception: + pass + + return all_datasets + + async def list_organizations(self, server: str = "global") -> list[str]: + """Call NDP-MCP's list_organizations tool.""" + if self._session is None: + raise RuntimeError("Not connected") + result = await self._session.call_tool("list_organizations", arguments={"server": server}) + for block in result.content: + if hasattr(block, "text"): + try: + data = json.loads(block.text) + if isinstance(data, dict) and "organizations" in data: + organizations: list[str] = data["organizations"] + return organizations + except json.JSONDecodeError: + pass + return [] diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/netcdf/__init__.py b/clio-agentic-search/src/clio_agentic_search/connectors/netcdf/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/netcdf/connector.py b/clio-agentic-search/src/clio_agentic_search/connectors/netcdf/connector.py new file mode 100644 index 00000000..487e68c1 --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/connectors/netcdf/connector.py @@ -0,0 +1,802 @@ +"""NetCDF namespace connector with incremental indexing.""" + +from __future__ import annotations + +import hashlib +import os +import threading +import time +from concurrent.futures import Future, ThreadPoolExecutor +from dataclasses import dataclass, field +from pathlib import Path + +from clio_agentic_search.core.connectors import ( + IndexReport, + NamespaceAuthConfig, + NamespaceRuntimeConfig, +) +from clio_agentic_search.indexing.lexical import ( + DEFAULT_STOPWORDS, + LexicalIngestionConfig, + LexicalPostingsIngestor, +) +from clio_agentic_search.indexing.scientific import ( + ScientificChunkPlan, + build_structure_aware_chunk_plan, + canonicalize_measurement, + normalize_formula, +) +from clio_agentic_search.indexing.text_features import ( + Embedder, + HashEmbedder, + tokenize, +) +from clio_agentic_search.models.contracts import ( + ChunkRecord, + CitationRecord, + DocumentRecord, + EmbeddingRecord, + MetadataRecord, + NamespaceDescriptor, +) +from clio_agentic_search.retrieval.ann import ANNAdapter, AnnResult, build_ann_adapter +from clio_agentic_search.retrieval.capabilities import ScoredChunk +from clio_agentic_search.retrieval.scientific import ( + ScientificQueryOperators, + score_scientific_metadata, +) +from clio_agentic_search.storage.contracts import ( + DocumentBundle, + FileIndexState, + StorageAdapter, +) + +try: + import xarray as xr + + HAS_XARRAY = True +except ImportError: + xr = None # type: ignore[assignment] + HAS_XARRAY = False + +NETCDF_SUFFIXES: frozenset[str] = frozenset({".nc", ".nc4", ".netcdf", ".cdf"}) + +_GLOBAL_ATTR_KEYS: tuple[str, ...] = ( + "title", + "history", + "Conventions", + "conventions", + "institution", + "source", + "references", + "comment", +) + + +def _format_coord_range(coord_values: object) -> str: + """Return a human-readable summary of a coordinate's range.""" + import numpy as np + + arr = np.asarray(coord_values) + if arr.size == 0: + return "(empty)" + first = arr.flat[0] + last = arr.flat[-1] + steps = arr.size + # numpy datetime64 prints nicely via str(); scalars too + return f"{first} to {last} ({steps} steps)" + + +def _extract_netcdf_text(file_path: Path) -> str: + """Open a NetCDF file with xarray and build a textual metadata summary.""" + if not HAS_XARRAY: + raise RuntimeError( + "xarray is required for the NetCDF connector. " + "Install it with: pip install xarray netCDF4" + ) + + ds = xr.open_dataset(file_path, engine="netcdf4") + try: + return _dataset_to_text(ds, file_path.name) + finally: + ds.close() + + +def _dataset_to_text(ds: object, filename: str) -> str: + """Convert an xarray Dataset into a structured text description.""" + lines: list[str] = [f"NetCDF Dataset: {filename}"] + + # Global attributes + attrs: dict[str, object] = dict(getattr(ds, "attrs", {})) + for key in _GLOBAL_ATTR_KEYS: + value = attrs.get(key) + if value is not None: + lines.append(f"{key.title()}: {value}") + + # Remaining global attributes not in the standard list + seen = {k.lower() for k in _GLOBAL_ATTR_KEYS} + for key, value in sorted(attrs.items()): + if key.lower() not in seen: + lines.append(f"{key}: {value}") + + lines.append("") + + # Data variables (non-coordinate) + data_vars = getattr(ds, "data_vars", {}) + for var_name in sorted(data_vars): + var = data_vars[var_name] + lines.append(f"Variable: {var_name}") + var_attrs: dict[str, object] = dict(getattr(var, "attrs", {})) + units = var_attrs.get("units") + if units is not None: + lines.append(f" Units: {units}") + long_name = var_attrs.get("long_name") + if long_name is not None: + lines.append(f" Long Name: {long_name}") + standard_name = var_attrs.get("standard_name") + if standard_name is not None: + lines.append(f" Standard Name: {standard_name}") + dims = getattr(var, "dims", ()) + shape = getattr(var, "shape", ()) + dtype = getattr(var, "dtype", "unknown") + lines.append(f" Dimensions: {dims}") + lines.append(f" Shape: {shape}") + lines.append(f" Dtype: {dtype}") + # Additional CF attributes + for cf_key in ("cell_methods", "coordinates", "grid_mapping", "ancillary_variables"): + cf_val = var_attrs.get(cf_key) + if cf_val is not None: + lines.append(f" {cf_key}: {cf_val}") + lines.append("") + + # Coordinates + coords = getattr(ds, "coords", {}) + if coords: + lines.append("Coordinates:") + for coord_name in sorted(coords): + coord = coords[coord_name] + try: + range_str = _format_coord_range(coord.values) + except Exception: + range_str = f"({getattr(coord, 'size', '?')} values)" + lines.append(f" {coord_name}: {range_str}") + lines.append("") + + # Dimensions summary + dims = getattr(ds, "dims", {}) + if dims: + lines.append("Dimensions:") + for dim_name in sorted(dims): + lines.append(f" {dim_name}: {dims[dim_name]}") + + return "\n".join(lines) + + +@dataclass(slots=True) +class NetCDFConnector: + """Connector that indexes NetCDF files for hybrid scientific search.""" + + namespace: str + root: Path + storage: StorageAdapter + embedder: Embedder = field(default_factory=HashEmbedder) + embedding_model: str = "hash16-v1" + chunk_size: int = 400 + reindex_delay_seconds: float = 0.0 + netcdf_suffixes: frozenset[str] = NETCDF_SUFFIXES + _runtime_config: NamespaceRuntimeConfig = field( + default_factory=lambda: NamespaceRuntimeConfig(options={}) + ) + _auth_config: NamespaceAuthConfig | None = None + ann_backend: str = "exact" + cache_shards: int = 16 + warmup_async: bool = True + document_batch_size: int = 32 + lexical_batch_size: int = 50_000 + lexical_df_prune_threshold: float = 0.98 + lexical_df_prune_min_chunks: int = 200 + lexical_max_tokens_per_chunk: int = 96 + lexical_prune_stopwords: bool = True + stopwords: frozenset[str] = DEFAULT_STOPWORDS + lexical_postings_compression: str = "none" + _connected: bool = False + _ann_index: ANNAdapter | None = field(default=None, init=False, repr=False) + _warmup_executor: ThreadPoolExecutor | None = field(default=None, init=False, repr=False) + _warmup_future: Future[None] | None = field(default=None, init=False, repr=False) + _runtime_lock: threading.RLock = field(default_factory=threading.RLock, init=False, repr=False) + + # ------------------------------------------------------------------ + # Configuration + # ------------------------------------------------------------------ + + def configure( + self, + *, + runtime_config: NamespaceRuntimeConfig, + auth_config: NamespaceAuthConfig | None, + ) -> None: + self._runtime_config = runtime_config + self._auth_config = auth_config + if "root" in runtime_config.options: + self.root = Path(runtime_config.options["root"]) + ann_backend = runtime_config.options.get("ann_backend") + if ann_backend: + self.ann_backend = ann_backend + cache_shards = runtime_config.options.get("cache_shards") + if cache_shards: + self.cache_shards = max(1, int(cache_shards)) + warmup_async = runtime_config.options.get("warmup_async") + if warmup_async: + self.warmup_async = _parse_bool(warmup_async) + document_batch_size = runtime_config.options.get("document_batch_size") + if document_batch_size: + self.document_batch_size = max(1, int(document_batch_size)) + if os.environ.get("CLIO_ANN_BACKEND"): + self.ann_backend = os.environ["CLIO_ANN_BACKEND"] + if os.environ.get("CLIO_CACHE_SHARDS"): + self.cache_shards = max(1, int(os.environ["CLIO_CACHE_SHARDS"])) + if os.environ.get("CLIO_VECTOR_WARMUP_ASYNC"): + self.warmup_async = _parse_bool(os.environ["CLIO_VECTOR_WARMUP_ASYNC"]) + if os.environ.get("CLIO_INDEX_DOCUMENT_BATCH_SIZE"): + self.document_batch_size = max(1, int(os.environ["CLIO_INDEX_DOCUMENT_BATCH_SIZE"])) + if os.environ.get("CLIO_LEXICAL_BATCH_SIZE"): + self.lexical_batch_size = max(1, int(os.environ["CLIO_LEXICAL_BATCH_SIZE"])) + if os.environ.get("CLIO_LEXICAL_DF_PRUNE_THRESHOLD"): + self.lexical_df_prune_threshold = float(os.environ["CLIO_LEXICAL_DF_PRUNE_THRESHOLD"]) + if os.environ.get("CLIO_LEXICAL_DF_PRUNE_MIN_CHUNKS"): + self.lexical_df_prune_min_chunks = max( + 1, int(os.environ["CLIO_LEXICAL_DF_PRUNE_MIN_CHUNKS"]) + ) + if os.environ.get("CLIO_LEXICAL_MAX_TOKENS_PER_CHUNK"): + self.lexical_max_tokens_per_chunk = max( + 0, int(os.environ["CLIO_LEXICAL_MAX_TOKENS_PER_CHUNK"]) + ) + if os.environ.get("CLIO_LEXICAL_PRUNE_STOPWORDS"): + self.lexical_prune_stopwords = _parse_bool(os.environ["CLIO_LEXICAL_PRUNE_STOPWORDS"]) + postings_compression = runtime_config.options.get("lexical_postings_compression") + if postings_compression: + self.lexical_postings_compression = _parse_postings_compression(postings_compression) + if os.environ.get("CLIO_LEXICAL_POSTINGS_COMPRESSION"): + self.lexical_postings_compression = _parse_postings_compression( + os.environ["CLIO_LEXICAL_POSTINGS_COMPRESSION"] + ) + + # ------------------------------------------------------------------ + # NamespaceConnector protocol + # ------------------------------------------------------------------ + + def descriptor(self) -> NamespaceDescriptor: + return NamespaceDescriptor( + name=self.namespace, + connector_type="netcdf", + root_uri=str(self.root.resolve()), + ) + + def connect(self) -> None: + self.storage.connect() + self._connected = True + self._schedule_warmup() + + def teardown(self) -> None: + self._connected = False + self._stop_warmup_worker() + self.storage.teardown() + with self._runtime_lock: + self._ann_index = None + + def index(self, *, full_rebuild: bool = False) -> IndexReport: + self._ensure_connected() + start = time.perf_counter() + + if full_rebuild: + self.storage.clear_namespace(self.namespace) + + scanned_files = 0 + indexed_files = 0 + skipped_files = 0 + existing_paths: set[str] = set() + pending_bundles: list[DocumentBundle] = [] + lexical_ingestor = LexicalPostingsIngestor( + LexicalIngestionConfig( + batch_size=self.lexical_batch_size, + df_prune_threshold=self.lexical_df_prune_threshold, + df_prune_min_chunks=self.lexical_df_prune_min_chunks, + max_tokens_per_chunk=self.lexical_max_tokens_per_chunk, + prune_stopwords=self.lexical_prune_stopwords, + stopwords=self.stopwords, + postings_compression=self.lexical_postings_compression, + ) + ) + + try: + for file_path in sorted( + path + for path in self.root.rglob("*") + if path.is_file() and path.suffix.lower() in self.netcdf_suffixes + ): + relative_path = file_path.relative_to(self.root).as_posix() + existing_paths.add(relative_path) + scanned_files += 1 + + content_bytes = file_path.read_bytes() + content_hash = hashlib.sha256(content_bytes).hexdigest() + mtime_ns = file_path.stat().st_mtime_ns + + if not full_rebuild: + previous = self.storage.get_file_state(self.namespace, relative_path) + if ( + previous is not None + and previous.mtime_ns == mtime_ns + and previous.content_hash == content_hash + ): + skipped_files += 1 + continue + + if self.reindex_delay_seconds > 0: + time.sleep(self.reindex_delay_seconds) + + try: + text = _extract_netcdf_text(file_path) + except Exception: + skipped_files += 1 + continue + + document_id = hashlib.sha1(f"{self.namespace}:{relative_path}".encode()).hexdigest() + document = DocumentRecord( + namespace=self.namespace, + document_id=document_id, + uri=relative_path, + checksum=content_hash, + modified_at_ns=mtime_ns, + ) + chunk_plan = self._build_chunks(document_id=document_id, text=text) + chunks = chunk_plan.chunks + embeddings = [ + EmbeddingRecord( + namespace=self.namespace, + chunk_id=chunk.chunk_id, + model=self.embedding_model, + vector=self.embedder.embed(chunk.text), + ) + for chunk in chunks + ] + metadata = self._build_metadata( + relative_path=relative_path, + document_id=document_id, + chunks=chunks, + chunk_metadata=chunk_plan.metadata_by_chunk_id, + file_path=file_path, + ) + file_state = FileIndexState( + namespace=self.namespace, + path=relative_path, + document_id=document_id, + mtime_ns=mtime_ns, + content_hash=content_hash, + ) + + pending_bundles.append( + DocumentBundle( + document=document, + chunks=chunks, + embeddings=embeddings, + metadata=metadata, + file_state=file_state, + ) + ) + if len(pending_bundles) >= self.document_batch_size: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + pending_bundles = [] + lexical_ingestor.add_chunks(chunks) + indexed_files += 1 + + if pending_bundles: + self.storage.upsert_document_bundles( + pending_bundles, + include_lexical_postings=False, + skip_prior_delete=full_rebuild, + ) + removed_files = ( + 0 + if full_rebuild + else self.storage.remove_missing_paths(self.namespace, existing_paths) + ) + lexical_ingestor.flush(namespace=self.namespace, storage=self.storage) + finally: + lexical_ingestor.close() + + if full_rebuild or indexed_files > 0 or removed_files > 0: + self._refresh_vector_index() + elif self._ann_index is None: + self._schedule_warmup() + + elapsed_seconds = time.perf_counter() - start + return IndexReport( + scanned_files=scanned_files, + indexed_files=indexed_files, + skipped_files=skipped_files, + removed_files=removed_files, + elapsed_seconds=elapsed_seconds, + ) + + def build_citation(self, chunk: ScoredChunk) -> CitationRecord: + stored_chunk = self.storage.get_chunk(self.namespace, chunk.chunk_id) + metadata = self.storage.get_chunk_metadata(self.namespace, stored_chunk.chunk_id) + uri = self.storage.get_document_uri(self.namespace, stored_chunk.document_id) + fragment = metadata.get("citation.fragment", "") + if fragment: + uri = f"{uri}#{fragment}" + snippet = stored_chunk.text.strip()[:160] + return CitationRecord( + namespace=self.namespace, + document_id=stored_chunk.document_id, + chunk_id=stored_chunk.chunk_id, + uri=uri, + snippet=snippet, + score=round(chunk.combined_score, 6), + ) + + # ------------------------------------------------------------------ + # LexicalSearchCapable + # ------------------------------------------------------------------ + + def search_lexical(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + query_tokens = tuple(sorted(set(tokenize(query)))) + if not query_tokens: + return [] + + matches = self.storage.query_chunks_lexical( + namespace=self.namespace, + query_tokens=query_tokens, + limit=top_k, + ) + return [ + ScoredChunk( + chunk_id=match.chunk.chunk_id, + document_id=match.chunk.document_id, + text=match.chunk.text, + lexical_score=match.bm25_score, + ) + for match in matches + ] + + # ------------------------------------------------------------------ + # VectorSearchCapable + # ------------------------------------------------------------------ + + def search_vector(self, query: str, top_k: int) -> list[ScoredChunk]: + self._ensure_connected() + self._ensure_vector_index_ready() + with self._runtime_lock: + ann_index = self._ann_index + if ann_index is None: + return [] + query_vector = self.embedder.embed(query) + + candidate_ids: set[str] | None = None + if isinstance(self.embedder, HashEmbedder): + query_tokens = tuple(sorted(set(tokenize(query)))) + if query_tokens: + prefilter_limit = max(top_k * 40, 512) + candidate_ids = { + match.chunk.chunk_id + for match in self.storage.query_chunks_lexical( + namespace=self.namespace, + query_tokens=query_tokens, + limit=prefilter_limit, + ) + } + if not candidate_ids: + candidate_ids = None + neighbors = ann_index.query( + query_vector=query_vector, + top_k=top_k, + candidate_ids=candidate_ids, + ) + return self._neighbors_to_scored_chunks(neighbors) + + # ------------------------------------------------------------------ + # MetadataFilterCapable + # ------------------------------------------------------------------ + + def filter_metadata( + self, + candidates: list[ScoredChunk], + required: dict[str, str], + ) -> list[ScoredChunk]: + self._ensure_connected() + if not required: + return candidates + + filtered: list[ScoredChunk] = [] + for candidate in candidates: + metadata = self.storage.get_chunk_metadata(self.namespace, candidate.chunk_id) + if all(metadata.get(key) == value for key, value in required.items()): + filtered.append( + ScoredChunk( + chunk_id=candidate.chunk_id, + document_id=candidate.document_id, + text=candidate.text, + lexical_score=candidate.lexical_score, + vector_score=candidate.vector_score, + metadata_score=1.0, + ) + ) + return filtered + + # ------------------------------------------------------------------ + # ScientificSearchCapable + # ------------------------------------------------------------------ + + def search_scientific( + self, + query: str, + top_k: int, + operators: ScientificQueryOperators, + ) -> list[ScoredChunk]: + self._ensure_connected() + del query + if not operators.is_active(): + return [] + + candidate_ids: set[str] | None = None + + if operators.numeric_range is not None: + try: + canonical_min = None + canonical_max = None + canonical_unit = canonicalize_measurement(0.0, operators.numeric_range.unit)[1] + if operators.numeric_range.minimum is not None: + canonical_min = canonicalize_measurement( + operators.numeric_range.minimum, + operators.numeric_range.unit, + )[0] + if operators.numeric_range.maximum is not None: + canonical_max = canonicalize_measurement( + operators.numeric_range.maximum, + operators.numeric_range.unit, + )[0] + except ValueError: + return [] + range_chunks = self.storage.query_chunks_by_measurement_range( + self.namespace, canonical_unit, canonical_min, canonical_max + ) + range_ids = {c.chunk_id for c in range_chunks} + candidate_ids = range_ids if candidate_ids is None else candidate_ids & range_ids + + if operators.formula: + sig = normalize_formula(operators.formula) + formula_chunks = self.storage.query_chunks_by_formula(self.namespace, sig) + formula_ids = {c.chunk_id for c in formula_chunks} + candidate_ids = formula_ids if candidate_ids is None else candidate_ids & formula_ids + + if candidate_ids is not None: + chunks = [self.storage.get_chunk(self.namespace, cid) for cid in sorted(candidate_ids)] + else: + chunks = self.storage.list_chunks(self.namespace) + + scored: list[ScoredChunk] = [] + for chunk in chunks: + metadata = self.storage.get_chunk_metadata(self.namespace, chunk.chunk_id) + score = score_scientific_metadata(metadata, operators) + if score <= 0.0: + continue + scored.append( + ScoredChunk( + chunk_id=chunk.chunk_id, + document_id=chunk.document_id, + text=chunk.text, + metadata_score=score, + ) + ) + + scored.sort(key=lambda candidate: (-candidate.metadata_score, candidate.chunk_id)) + return scored[:top_k] + + # ------------------------------------------------------------------ + # Internal helpers + # ------------------------------------------------------------------ + + def _build_chunks(self, *, document_id: str, text: str) -> ScientificChunkPlan: + return build_structure_aware_chunk_plan( + namespace=self.namespace, + document_id=document_id, + text=text, + chunk_size=self.chunk_size, + ) + + def _build_metadata( + self, + *, + relative_path: str, + document_id: str, + chunks: list[ChunkRecord], + chunk_metadata: dict[str, dict[str, str]], + file_path: Path, + ) -> list[MetadataRecord]: + suffix = Path(relative_path).suffix.lower() + records: list[MetadataRecord] = [ + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="path", + value=relative_path, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="suffix", + value=suffix, + ), + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="connector_type", + value="netcdf", + ), + ] + + # Extract NetCDF-specific document-level metadata + if HAS_XARRAY: + try: + ds = xr.open_dataset(file_path, engine="netcdf4") + try: + attrs = dict(ds.attrs) + for attr_key in _GLOBAL_ATTR_KEYS: + val = attrs.get(attr_key) + if val is not None: + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key=f"netcdf.{attr_key.lower()}", + value=str(val), + ) + ) + var_names = sorted(str(v) for v in ds.data_vars) + if var_names: + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="netcdf.variables", + value=",".join(var_names), + ) + ) + coord_names = sorted(str(c) for c in ds.coords) + if coord_names: + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=document_id, + scope="document", + key="netcdf.coordinates", + value=",".join(coord_names), + ) + ) + finally: + ds.close() + except Exception: + pass + + for chunk in chunks: + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key="path", + value=relative_path, + ) + ) + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key="suffix", + value=suffix, + ) + ) + for key, value in sorted(chunk_metadata.get(chunk.chunk_id, {}).items()): + records.append( + MetadataRecord( + namespace=self.namespace, + record_id=chunk.chunk_id, + scope="chunk", + key=key, + value=value, + ) + ) + return records + + def _neighbors_to_scored_chunks(self, neighbors: list[AnnResult]) -> list[ScoredChunk]: + scored: list[ScoredChunk] = [] + for neighbor in neighbors: + chunk = self.storage.get_chunk(self.namespace, neighbor.chunk_id) + scored.append( + ScoredChunk( + chunk_id=neighbor.chunk_id, + document_id=chunk.document_id, + text=chunk.text, + vector_score=neighbor.score, + ) + ) + return scored + + def _ensure_connected(self) -> None: + if not self._connected: + raise RuntimeError("Connector is not connected") + + def _refresh_vector_index(self) -> None: + if not self._connected: + return + embeddings = self.storage.list_embeddings(self.namespace, self.embedding_model) + ann_index = build_ann_adapter( + backend=self.ann_backend, + dimensions=self.embedder.dimensions, + shard_count=max(1, self.cache_shards), + ) + ann_index.build(embeddings) + with self._runtime_lock: + if not self._connected: + return + self._ann_index = ann_index + + def _schedule_warmup(self) -> None: + if not self.warmup_async: + self._refresh_vector_index() + return + with self._runtime_lock: + if self._warmup_future is not None and not self._warmup_future.done(): + return + if self._warmup_executor is None: + self._warmup_executor = ThreadPoolExecutor( + max_workers=1, + thread_name_prefix=f"clio-warmup-{self.namespace}", + ) + self._warmup_future = self._warmup_executor.submit(self._refresh_vector_index) + + def _ensure_vector_index_ready(self) -> None: + with self._runtime_lock: + ann_index = self._ann_index + warmup_future = self._warmup_future + if ann_index is not None: + return + if warmup_future is not None: + warmup_future.result() + with self._runtime_lock: + if self._ann_index is not None: + return + self._refresh_vector_index() + + def _stop_warmup_worker(self) -> None: + with self._runtime_lock: + executor = self._warmup_executor + self._warmup_executor = None + self._warmup_future = None + if executor is not None: + executor.shutdown(wait=True, cancel_futures=True) + + +def _parse_bool(value: str) -> bool: + return value.strip().lower() in {"1", "true", "yes", "on"} + + +def _parse_postings_compression(value: str) -> str: + normalized = value.strip().lower() + if normalized in {"", "none"}: + return "none" + if normalized in {"gzip", "gz"}: + return "gzip" + raise ValueError("Unsupported lexical postings compression; expected one of: none, gzip") diff --git a/clio-agentic-search/src/clio_agentic_search/connectors/object_store/connector.py b/clio-agentic-search/src/clio_agentic_search/connectors/object_store/connector.py index a6f5c850..83c6efa8 100644 --- a/clio-agentic-search/src/clio_agentic_search/connectors/object_store/connector.py +++ b/clio-agentic-search/src/clio_agentic_search/connectors/object_store/connector.py @@ -336,7 +336,7 @@ def search_lexical(self, query: str, top_k: int) -> list[ScoredChunk]: chunk_id=match.chunk.chunk_id, document_id=match.chunk.document_id, text=match.chunk.text, - lexical_score=match.overlap_count / len(query_tokens), + lexical_score=match.bm25_score, ) for match in matches ] diff --git a/clio-agentic-search/src/clio_agentic_search/core/namespace_config.py b/clio-agentic-search/src/clio_agentic_search/core/namespace_config.py index f9440879..534991bb 100644 --- a/clio-agentic-search/src/clio_agentic_search/core/namespace_config.py +++ b/clio-agentic-search/src/clio_agentic_search/core/namespace_config.py @@ -23,6 +23,8 @@ def load_default_namespace_bundles() -> dict[str, NamespaceConfigBundle]: vector_collection = os.environ.get("CLIO_VECTOR_COLLECTION", "local_collection") graph_namespace = os.environ.get("CLIO_GRAPH_NAMESPACE", "graph_default") kv_stream = os.environ.get("CLIO_KV_STREAM", "events") + hdf5_root = Path(os.environ.get("CLIO_HDF5_ROOT", local_root)).resolve() + netcdf_root = Path(os.environ.get("CLIO_NETCDF_ROOT", local_root)).resolve() return { "local_fs": NamespaceConfigBundle( @@ -81,6 +83,16 @@ def load_default_namespace_bundles() -> dict[str, NamespaceConfigBundle]: }, ), ), + "hdf5_data": NamespaceConfigBundle( + namespace="hdf5_data", + connector_type="hdf5", + runtime=NamespaceRuntimeConfig(options={"root": str(hdf5_root)}), + ), + "netcdf_data": NamespaceConfigBundle( + namespace="netcdf_data", + connector_type="netcdf", + runtime=NamespaceRuntimeConfig(options={"root": str(netcdf_root)}), + ), "kv_redis": NamespaceConfigBundle( namespace="kv_redis", connector_type="kv_log_store", diff --git a/clio-agentic-search/src/clio_agentic_search/core/namespace_registry.py b/clio-agentic-search/src/clio_agentic_search/core/namespace_registry.py index ac73847f..f26371c0 100644 --- a/clio-agentic-search/src/clio_agentic_search/core/namespace_registry.py +++ b/clio-agentic-search/src/clio_agentic_search/core/namespace_registry.py @@ -8,6 +8,8 @@ from pathlib import Path from clio_agentic_search.connectors.filesystem import FilesystemConnector +from clio_agentic_search.connectors.hdf5.connector import HDF5Connector +from clio_agentic_search.connectors.netcdf.connector import NetCDFConnector from clio_agentic_search.connectors.object_store import InMemoryS3Client, S3ObjectStoreConnector from clio_agentic_search.connectors.vector_store import ( InMemoryQdrantClient, @@ -145,6 +147,36 @@ def build_default_registry() -> NamespaceRegistry: auth_config=object_bundle.auth, ) + hdf5_bundle = bundles["hdf5_data"] + hdf5_connector = HDF5Connector( + namespace="hdf5_data", + root=Path(hdf5_bundle.runtime.options["root"]), + storage=DuckDBStorage(database_path=_namespaced_storage_path(storage_path, "hdf5_data")), + embedder=embedder, + embedding_model=embedder.model_name, + ) + registry.register( + "hdf5_data", + hdf5_connector, + runtime_config=hdf5_bundle.runtime, + auth_config=hdf5_bundle.auth, + ) + + netcdf_bundle = bundles["netcdf_data"] + netcdf_connector = NetCDFConnector( + namespace="netcdf_data", + root=Path(netcdf_bundle.runtime.options["root"]), + storage=DuckDBStorage(database_path=_namespaced_storage_path(storage_path, "netcdf_data")), + embedder=embedder, + embedding_model=embedder.model_name, + ) + registry.register( + "netcdf_data", + netcdf_connector, + runtime_config=netcdf_bundle.runtime, + auth_config=netcdf_bundle.auth, + ) + vector_bundle = bundles["vector_qdrant"] vector_connector = QdrantVectorConnector( namespace="vector_qdrant", diff --git a/clio-agentic-search/src/clio_agentic_search/evals/quality_gate.py b/clio-agentic-search/src/clio_agentic_search/evals/quality_gate.py index 41d42c0a..dc0327f2 100644 --- a/clio-agentic-search/src/clio_agentic_search/evals/quality_gate.py +++ b/clio-agentic-search/src/clio_agentic_search/evals/quality_gate.py @@ -156,9 +156,9 @@ def _run_numeric_exactness_scenario( measurements.extend(decode_measurements(metadata.get("scientific.measurements", ""))) expected = [ - (101000.0, "pa"), - (200000.0, "pa"), - (350000.0, "pa"), + (101000.0, "1,-1,-2,0,0,0,0"), + (200000.0, "1,-1,-2,0,0,0,0"), + (350000.0, "1,-1,-2,0,0,0,0"), ] exactness = numeric_exactness(measurements, expected, tolerance=1e-6) results.append( diff --git a/clio-agentic-search/src/clio_agentic_search/indexing/csv_parser.py b/clio-agentic-search/src/clio_agentic_search/indexing/csv_parser.py new file mode 100644 index 00000000..1e757266 --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/indexing/csv_parser.py @@ -0,0 +1,442 @@ +"""Science-aware CSV parser with unit inference and QC flag extraction. + +This module provides a single entry point, :func:`parse_scientific_csv`, +used by connectors that ingest tabular scientific data (CIMIS, NOAA GHCN, +DOE data portal CSVs, and similar). It is deliberately self-contained and +connector-agnostic — connectors wrap it, pass a URL or text, and receive +structured :class:`ParsedCsv` objects that plug straight into CLIO's +measurement + metadata pipeline. + +What it does: + +1. Parses the CSV header and detects columns that look like measurements + via unit patterns in the header (``"Air Temp (C)"``, ``"Wind Speed + (m/s)"``, ``"Pressure [kPa]"``). +2. Detects adjacent quality-control columns using the convention + ``measurement_col, qc`` (CIMIS), ``column_Q`` (NOAA), or ``_qflag`` + (CF conventions). +3. For each matched measurement column, parses each row, canonicalises to + SI base units, and attaches the parsed quality flag. +4. Returns the rows as :class:`Measurement` objects alongside a + :class:`CsvSchema` describing the detected columns. + +The module does **not** touch DuckDB or any connector — it's pure Python +so it's trivially testable and reusable. +""" + +from __future__ import annotations + +import re +from dataclasses import dataclass, field +from typing import Any + +from clio_agentic_search.indexing.quality import ( + QualityFlag, + derive_flag_from_value, + parse_qc_token, +) +from clio_agentic_search.indexing.scientific import Measurement, canonicalize_measurement +from clio_agentic_search.retrieval.metadata_schema import align_field + +# --------------------------------------------------------------------------- +# Header parsing: find columns that contain measurements +# --------------------------------------------------------------------------- + +# Regex: capture a unit suffix in parentheses or square brackets at the end +# of a header name. Examples: +# "Air Temp (C)" -> unit="C" +# "Wind Speed (m/s)" -> unit="m/s" +# "Pressure [kPa]" -> unit="kPa" +# "Rel Hum (%)" -> unit="%" +_UNIT_SUFFIX_RE = re.compile( + r""" + .*? # column label (non-greedy) + [\(\[] # opening bracket + ([^)\]]+) # unit content (no brackets inside) + [\)\]] # closing bracket + \s*$ # end of string + """, + re.VERBOSE, +) + +# Common single-letter → canonical unit aliases used in CSV headers. +# (Full dimensional analysis happens downstream via canonicalize_measurement.) +_HEADER_UNIT_ALIASES: dict[str, str] = { + "C": "degC", + "°C": "degC", + "degC": "degC", + "F": "degF", + "°F": "degF", + "degF": "degF", + "K": "kelvin", + "%": "percent", # sentinel — % is dimensionless; treated as "no canonicalization" +} + + +def _parse_header_unit(header: str) -> tuple[str, str | None]: + """Return ``(display_name, unit_string_or_None)``. + + ``display_name`` is the header with any trailing ``(unit)`` stripped. + """ + match = _UNIT_SUFFIX_RE.match(header) + if not match: + return header.strip(), None + raw_unit = match.group(1).strip() + # Trim the bracketed portion off the display name + display = re.sub(r"\s*[\(\[].*?[\)\]]\s*$", "", header).strip() + return display, raw_unit + + +def _canonicalise_unit_for_registry(raw_unit: str) -> str: + """Apply header-specific aliases then return the string to feed to + :func:`canonicalize_measurement`.""" + return _HEADER_UNIT_ALIASES.get(raw_unit, raw_unit) + + +# --------------------------------------------------------------------------- +# QC column detection +# --------------------------------------------------------------------------- + + +def _find_qc_column_index( + headers: list[str], + measurement_idx: int, +) -> int | None: + """Return the index of a QC column associated with ``measurement_idx``. + + Conventions tried (in order): + 1. **CIMIS**: the immediately-following column named ``"qc"`` + (case-insensitive, optional whitespace). + 2. **Column suffix**: a later column named + ``_qflag``/``_quality``/``_q``. + + Returns ``None`` if no QC column is found. + """ + # CIMIS: qc column directly follows the measurement + if measurement_idx + 1 < len(headers): + nxt = headers[measurement_idx + 1].strip().lower() + if nxt in ("qc", "q", "qflag", "quality"): + return measurement_idx + 1 + + # Suffix convention + meas_name = headers[measurement_idx].strip().lower() + # Strip unit suffix for matching + base = re.sub(r"\s*[\(\[].*?[\)\]]\s*$", "", meas_name).strip() + base_normalised = re.sub(r"[\s\-\.]+", "_", base) + for idx, h in enumerate(headers): + h_lower = h.strip().lower() + if h_lower in ( + f"{base}_qflag", + f"{base}_quality", + f"{base}_q", + f"{base_normalised}_qflag", + f"{base_normalised}_quality", + f"{base_normalised}_q", + ): + return idx + return None + + +# --------------------------------------------------------------------------- +# Data classes describing the parsed schema + rows +# --------------------------------------------------------------------------- + + +@dataclass(frozen=True, slots=True) +class CsvColumn: + """One column in a parsed CSV.""" + + index: int + header: str + display_name: str + raw_unit: str | None + canonical_unit_for_registry: str | None + qc_column_index: int | None + canonical_concept: str | None # e.g. "temperature" — from metadata_schema + + +@dataclass(frozen=True, slots=True) +class CsvSchema: + """The result of analysing a CSV header.""" + + columns: tuple[CsvColumn, ...] + header: tuple[str, ...] + + @property + def measurement_columns(self) -> tuple[CsvColumn, ...]: + """All columns we were able to interpret as measurements.""" + return tuple(c for c in self.columns if c.canonical_unit_for_registry) + + +@dataclass(frozen=True, slots=True) +class ParsedRow: + """A single parsed row with measurements and contextual fields.""" + + row_index: int + measurements: tuple[Measurement, ...] + context: dict[str, str] = field(default_factory=dict) + + +@dataclass(frozen=True, slots=True) +class ParsedCsv: + """Full result of :func:`parse_scientific_csv`.""" + + schema: CsvSchema + rows: tuple[ParsedRow, ...] + total_rows: int + parse_errors: int + + +# --------------------------------------------------------------------------- +# Main parser +# --------------------------------------------------------------------------- + + +def analyse_header(headers: list[str]) -> CsvSchema: + """Analyse headers only — find measurement columns and their QC pairs. + + Returns a :class:`CsvSchema` describing each column, marking those that + look like measurements (have a recognised unit in their header) and + noting any adjacent QC columns. + """ + columns: list[CsvColumn] = [] + for idx, raw in enumerate(headers): + display, raw_unit = _parse_header_unit(raw) + canonical_unit_for_registry: str | None = None + if raw_unit is not None: + candidate = _canonicalise_unit_for_registry(raw_unit) + # Verify the unit is actually in the registry by attempting a trial + # canonicalisation. ``percent`` isn't in the registry; we keep it + # as a known display unit but skip it for SI conversion. + try: + canonicalize_measurement(0.0, candidate) + canonical_unit_for_registry = candidate + except (ValueError, KeyError): + canonical_unit_for_registry = None + + qc_idx = None + if canonical_unit_for_registry is not None: + qc_idx = _find_qc_column_index(headers, idx) + + # Map to a canonical concept using the metadata-schema aligner + concept = align_field(raw) + + columns.append( + CsvColumn( + index=idx, + header=raw, + display_name=display, + raw_unit=raw_unit, + canonical_unit_for_registry=canonical_unit_for_registry, + qc_column_index=qc_idx, + canonical_concept=concept, + ) + ) + return CsvSchema(columns=tuple(columns), header=tuple(headers)) + + +def parse_scientific_csv( + text: str, + *, + max_rows: int | None = None, + context_columns: tuple[str, ...] = ( + "stn name", + "station name", + "site name", + "name", + "date", + "datetime", + "time", + ), + delimiter: str = ",", +) -> ParsedCsv: + """Parse a CSV text into measurements with quality flags. + + Args: + text: Raw CSV content including header. + max_rows: Optional row cap (for bounded memory in tests). + context_columns: Substrings to look for in header names to capture + as ``context`` dict on each row (e.g. station name, date). + delimiter: Field delimiter. Default comma. + + Returns: + :class:`ParsedCsv` with the inferred schema, per-row measurements, + and parse error count. + """ + lines = text.splitlines() + if not lines: + return ParsedCsv( + schema=CsvSchema(columns=(), header=()), + rows=(), + total_rows=0, + parse_errors=0, + ) + + header_row = [h.strip() for h in lines[0].split(delimiter)] + schema = analyse_header(header_row) + + # Resolve context column indices + header_lower = [h.lower() for h in header_row] + context_indices: dict[str, int] = {} + for ctx in context_columns: + for i, h in enumerate(header_lower): + if ctx in h and i not in context_indices.values(): + context_indices[header_row[i]] = i + break + + rows: list[ParsedRow] = [] + parse_errors = 0 + data_lines = lines[1:] + if max_rows is not None: + data_lines = data_lines[:max_rows] + + for row_idx, line in enumerate(data_lines): + if not line.strip(): + continue + cells = line.split(delimiter) + if len(cells) < len(header_row): + # Allow rows shorter than the header (trailing empty cells) + cells.extend([""] * (len(header_row) - len(cells))) + + row_measurements: list[Measurement] = [] + row_has_error = False + for col in schema.measurement_columns: + if col.canonical_unit_for_registry is None: + continue + raw_cell = cells[col.index].strip() if col.index < len(cells) else "" + if not raw_cell: + # Treat empty cell as missing; don't emit a measurement. + continue + try: + raw_value = float(raw_cell) + except ValueError: + row_has_error = True + continue + + # Read QC token (if any) + if col.qc_column_index is not None and col.qc_column_index < len(cells): + qc_token = cells[col.qc_column_index].strip() + source_flag = parse_qc_token(qc_token) + else: + source_flag = QualityFlag.GOOD # no QC column = assume good + + try: + canonical_value, canonical_unit = canonicalize_measurement( + raw_value, + col.canonical_unit_for_registry, + ) + except (ValueError, KeyError): + row_has_error = True + continue + + # Combine source flag with physical-plausibility check + final_flag = derive_flag_from_value( + canonical_unit, + canonical_value, + source_flag, + ) + + row_measurements.append( + Measurement( + raw_value=raw_value, + raw_unit=(col.raw_unit or "").lower(), + canonical_value=canonical_value, + canonical_unit=canonical_unit, + quality=final_flag.value, + ) + ) + + if row_has_error: + parse_errors += 1 + + context = { + col_name: cells[idx].strip() if idx < len(cells) else "" + for col_name, idx in context_indices.items() + } + + rows.append( + ParsedRow( + row_index=row_idx, + measurements=tuple(row_measurements), + context=context, + ) + ) + + return ParsedCsv( + schema=schema, + rows=tuple(rows), + total_rows=len(data_lines), + parse_errors=parse_errors, + ) + + +# --------------------------------------------------------------------------- +# Convenience aggregates — used by the evaluation code +# --------------------------------------------------------------------------- + + +def filter_rows_by_concept( + parsed: ParsedCsv, + concept: str, + min_value_canonical: float | None = None, + max_value_canonical: float | None = None, + acceptable_quality: frozenset[QualityFlag] | None = None, +) -> list[dict[str, Any]]: + """Filter parsed rows to those matching a canonical concept + threshold. + + Args: + parsed: Output of :func:`parse_scientific_csv`. + concept: Canonical concept name from :mod:`metadata_schema` + (e.g. ``"temperature"``). + min_value_canonical, max_value_canonical: Optional range bounds in + canonical (SI) units. + acceptable_quality: Optional set of acceptable flags. Default + is ``{GOOD, ESTIMATED}``. + + Returns: + List of dicts containing ``{raw_value, raw_unit, canonical_value, + quality, context}``. + """ + if acceptable_quality is None: + acceptable_quality = frozenset({QualityFlag.GOOD, QualityFlag.ESTIMATED}) + + # Find measurement columns matching the concept + concept_cols = [c for c in parsed.schema.columns if c.canonical_concept == concept] + concept_col_indices = {c.index for c in concept_cols} + if not concept_cols: + return [] + + # Build a map from column index → the canonical unit the column + # produced. We need this because a row has one Measurement per + # matched column; we only want rows from columns matching the concept. + results: list[dict[str, Any]] = [] + for row in parsed.rows: + # Walk the row's measurements alongside the schema columns + # (measurements are emitted in the same order as measurement_columns). + meas_iter = iter(row.measurements) + for col in parsed.schema.measurement_columns: + try: + m = next(meas_iter) + except StopIteration: + break + if col.index not in concept_col_indices: + continue + flag = QualityFlag.from_string(m.quality) + if flag not in acceptable_quality: + continue + if min_value_canonical is not None and m.canonical_value < min_value_canonical: + continue + if max_value_canonical is not None and m.canonical_value > max_value_canonical: + continue + results.append( + { + "raw_value": m.raw_value, + "raw_unit": m.raw_unit, + "canonical_value": m.canonical_value, + "canonical_unit": m.canonical_unit, + "quality": m.quality, + "context": dict(row.context), + "column": col.header, + } + ) + return results diff --git a/clio-agentic-search/src/clio_agentic_search/indexing/quality.py b/clio-agentic-search/src/clio_agentic_search/indexing/quality.py new file mode 100644 index 00000000..aa5764bc --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/indexing/quality.py @@ -0,0 +1,282 @@ +"""Data quality layer: QC flags, quality scoring, and validity checks. + +This module implements the third search target from the research program: +filtering and ranking retrieval results by the *quality* of the underlying +measurements, alongside unit conversion (Cap. 1) and metadata adaptivity +(Cap. 2). + +Quality is captured as a :class:`QualityFlag` attached to each +:class:`Measurement`. Flags follow widely-used conventions from NOAA GHCN, +CIMIS, CF-conventions, and similar scientific data catalogs: + + GOOD — passed all validity checks (default) + QUESTIONABLE — out of expected range but not impossible + BAD — failed validation / flagged erroneous + MISSING — value was absent or sentinel + ESTIMATED — imputed / interpolated, not directly measured + UNKNOWN — quality information unavailable + +The module is deliberately self-contained: it does not import any retrieval +or storage code. Downstream modules (storage, coordinator, connectors) +attach to this module by calling :func:`parse_qc_token` or by constructing +:class:`QualityFlag` directly from whatever native representation the +source data uses. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import StrEnum + + +class QualityFlag(StrEnum): + """Normalized data-quality flag values. + + Stored as short lowercase strings so they serialise cleanly through + DuckDB columns and the ``encode_measurements``/``decode_measurements`` + pipe format. The string form is the authoritative representation; + downstream code uses ``QualityFlag(raw_string)`` to parse. + """ + + GOOD = "good" + QUESTIONABLE = "questionable" + BAD = "bad" + MISSING = "missing" + ESTIMATED = "estimated" + UNKNOWN = "unknown" + + @classmethod + def from_string(cls, value: str | None) -> QualityFlag: + if not value: + return cls.UNKNOWN + try: + return cls(value.strip().lower()) + except ValueError: + return cls.UNKNOWN + + @property + def is_acceptable(self) -> bool: + """Whether the flag is considered acceptable under default filtering. + + Default filtering accepts GOOD and ESTIMATED (interpolated values are + usable for most scientific questions) and rejects the rest. + """ + return self in _ACCEPTABLE_FLAGS + + @property + def numeric_score(self) -> float: + """Map the flag to a 0.0–1.0 confidence score. + + Used by the retrieval layer to rank matching measurements so that + higher-quality rows surface first. + """ + return _FLAG_SCORES[self] + + +_ACCEPTABLE_FLAGS: frozenset[QualityFlag] = frozenset( + {QualityFlag.GOOD, QualityFlag.ESTIMATED}, +) + +_FLAG_SCORES: dict[QualityFlag, float] = { + QualityFlag.GOOD: 1.0, + QualityFlag.ESTIMATED: 0.75, + QualityFlag.UNKNOWN: 0.5, + QualityFlag.QUESTIONABLE: 0.25, + QualityFlag.BAD: 0.0, + QualityFlag.MISSING: 0.0, +} + + +# --------------------------------------------------------------------------- +# QC token parsing +# --------------------------------------------------------------------------- +# +# Scientific CSVs and metadata typically report quality as a single-letter +# flag adjacent to the measurement value. The exact vocabulary varies by +# source, so we normalise the common conventions into QualityFlag. + +# Mapping from raw lowercase tokens to normalised flags. We support the +# overlapping conventions from: +# * NOAA GHCN-Daily (M=missing, empty=good, various QFLAG letters) +# * CIMIS (Y=questionable, R=rejected, M=missing, blank=good) +# * NetCDF/CF ancillary ("flag_meanings" strings) +# * Ad-hoc human flags (good/bad/ok/fail) +_TOKEN_MAP: dict[str, QualityFlag] = { + # Explicit good + "": QualityFlag.GOOD, + "ok": QualityFlag.GOOD, + "good": QualityFlag.GOOD, + "g": QualityFlag.GOOD, + "0": QualityFlag.GOOD, + "valid": QualityFlag.GOOD, + "pass": QualityFlag.GOOD, + # Questionable + "q": QualityFlag.QUESTIONABLE, + "y": QualityFlag.QUESTIONABLE, # CIMIS "questionable" + "s": QualityFlag.QUESTIONABLE, # CIMIS "suspect" + "?": QualityFlag.QUESTIONABLE, + "questionable": QualityFlag.QUESTIONABLE, + "suspect": QualityFlag.QUESTIONABLE, + "warn": QualityFlag.QUESTIONABLE, + # Bad + "b": QualityFlag.BAD, + "r": QualityFlag.BAD, # CIMIS "rejected" + "n": QualityFlag.BAD, # "no" / "not valid" + "bad": QualityFlag.BAD, + "fail": QualityFlag.BAD, + "rejected": QualityFlag.BAD, + "invalid": QualityFlag.BAD, + # Missing + "m": QualityFlag.MISSING, + "missing": QualityFlag.MISSING, + "na": QualityFlag.MISSING, + "n/a": QualityFlag.MISSING, + "null": QualityFlag.MISSING, + "nan": QualityFlag.MISSING, + "-9999": QualityFlag.MISSING, + # Estimated / interpolated + "e": QualityFlag.ESTIMATED, + "i": QualityFlag.ESTIMATED, + "estimated": QualityFlag.ESTIMATED, + "interpolated": QualityFlag.ESTIMATED, +} + + +def parse_qc_token(token: str | None) -> QualityFlag: + """Parse a single QC/quality token into a normalised :class:`QualityFlag`. + + Args: + token: The raw token from a data source. May be ``None``, empty, + whitespace, or a single-letter flag like ``"M"`` or ``"Y"``, + or a word like ``"good"`` / ``"bad"``. + + Returns: + The normalised flag. Unknown / unrecognised tokens become + :attr:`QualityFlag.UNKNOWN` rather than raising, so downstream + code can always classify a measurement. + """ + if token is None: + return QualityFlag.UNKNOWN + stripped = token.strip().lower() + return _TOKEN_MAP.get(stripped, QualityFlag.UNKNOWN) + + +# --------------------------------------------------------------------------- +# Quality summary — aggregated view over many measurements +# --------------------------------------------------------------------------- + + +@dataclass(frozen=True, slots=True) +class QualitySummary: + """Aggregate quality statistics over a collection of measurements. + + Used by corpus profiling and retrieval ranking to report "how clean is + this corpus". All counts are absolute; ``acceptable_ratio`` and + ``average_score`` are derived for convenience. + """ + + total: int + good: int + questionable: int + bad: int + missing: int + estimated: int + unknown: int + + @property + def acceptable_count(self) -> int: + return self.good + self.estimated + + @property + def acceptable_ratio(self) -> float: + if self.total == 0: + return 0.0 + return self.acceptable_count / self.total + + @property + def average_score(self) -> float: + """Mean numeric quality score across all flags.""" + if self.total == 0: + return 0.0 + weighted = ( + self.good * _FLAG_SCORES[QualityFlag.GOOD] + + self.estimated * _FLAG_SCORES[QualityFlag.ESTIMATED] + + self.unknown * _FLAG_SCORES[QualityFlag.UNKNOWN] + + self.questionable * _FLAG_SCORES[QualityFlag.QUESTIONABLE] + + self.bad * _FLAG_SCORES[QualityFlag.BAD] + + self.missing * _FLAG_SCORES[QualityFlag.MISSING] + ) + return weighted / self.total + + +def summarise_quality(flags: list[QualityFlag]) -> QualitySummary: + """Aggregate a list of flags into a :class:`QualitySummary`.""" + counts = {flag: 0 for flag in QualityFlag} + for flag in flags: + counts[flag] += 1 + return QualitySummary( + total=len(flags), + good=counts[QualityFlag.GOOD], + questionable=counts[QualityFlag.QUESTIONABLE], + bad=counts[QualityFlag.BAD], + missing=counts[QualityFlag.MISSING], + estimated=counts[QualityFlag.ESTIMATED], + unknown=counts[QualityFlag.UNKNOWN], + ) + + +# --------------------------------------------------------------------------- +# Range validators — physical-plausibility checks +# --------------------------------------------------------------------------- +# +# Even when a source marks a value "good", it can still be outside the +# physically plausible range (a 500°C air-temperature reading from a weather +# station, for example). These validators apply on the *canonical* (SI) value +# so a single table covers all units in a dimension. + +# Keyed by canonical dim-key. Values are (min, max) in SI base units. +_PHYSICAL_RANGES: dict[str, tuple[float, float]] = { + # Temperature (K). Allow deep-cryo lab data to 50 K; reject near absolute + # zero or anything above typical plasma physics at ~3000 K for weather/ + # chemistry use cases. Users with extreme-science data can bypass via + # accept_all=True. + "0,0,0,0,1,0,0": (50.0, 3000.0), + # Pressure (Pa). Near-vacuum ~1 Pa (lab) to 10^9 Pa (~10 GPa, high-pressure + # diamond-anvil experiments). + "1,-1,-2,0,0,0,0": (1.0, 1.0e9), + # Velocity (m/s). -1 to +3e8 (speed of light). Negative rejected. + "0,1,-1,0,0,0,0": (0.0, 3.0e8), +} + + +def is_physically_plausible( + canonical_unit: str, + canonical_value: float, +) -> bool: + """Check if a canonical (SI) value falls within a sanity range. + + If the dimension isn't in the table, returns True (no constraint). + """ + bounds = _PHYSICAL_RANGES.get(canonical_unit) + if bounds is None: + return True + lo, hi = bounds + return lo <= canonical_value <= hi + + +def derive_flag_from_value( + canonical_unit: str, + canonical_value: float, + source_flag: QualityFlag = QualityFlag.UNKNOWN, +) -> QualityFlag: + """Combine a source-provided flag with physical-plausibility check. + + If the source flag is BAD or MISSING we trust it and return as-is. + Otherwise we additionally check plausibility: if the value is outside + the physical range, downgrade to QUESTIONABLE. + """ + if source_flag in (QualityFlag.BAD, QualityFlag.MISSING): + return source_flag + if not is_physically_plausible(canonical_unit, canonical_value): + return QualityFlag.QUESTIONABLE + return source_flag diff --git a/clio-agentic-search/src/clio_agentic_search/indexing/scientific.py b/clio-agentic-search/src/clio_agentic_search/indexing/scientific.py index 82f91142..35f52566 100644 --- a/clio-agentic-search/src/clio_agentic_search/indexing/scientific.py +++ b/clio-agentic-search/src/clio_agentic_search/indexing/scientific.py @@ -30,26 +30,169 @@ _MATH_INDICATOR_RE = re.compile(r"[\^{\\]") _MEASUREMENT_PATTERN = re.compile( - r"(?P[+-]?\d+(?:\.\d+)?)\s*(?Pkm/h|m/s|km|cm|mm|m|kg|mg|g|h|min|s|mpa|kpa|pa)\b", + r"(?P[+-]?\d+(?:\.\d+)?)\s*" + r"(?P" + r"km/h|m/s|rad/s|m/s2|" # compound velocity/acceleration + r"degf|degc|°f|°c|kelvin|" # temperature + r"km|cm|mm|nm|m|" # length + r"kg|mg|g|" # mass + r"hz|khz|mhz|ghz|" # frequency + r"bq|ci|" # radioactivity + r"ha|" # area + r"ev|kev|mev|gev|" # energy + r"kj|mj|gj|" # energy (joule family) + r"kw|mw|gw|w|" # power + r"kn|" # force (kilonewton) + r"bar|atm|psi|hpa|mpa|kpa|pa|" # pressure + r"h|min|s" # time + r")\b", flags=re.IGNORECASE, ) -_UNIT_CANONICALIZATION: dict[str, tuple[str, float]] = { - "mm": ("m", 1e-3), - "cm": ("m", 1e-2), - "m": ("m", 1.0), - "km": ("m", 1e3), - "mg": ("kg", 1e-6), - "g": ("kg", 1e-3), - "kg": ("kg", 1.0), - "s": ("s", 1.0), - "min": ("s", 60.0), - "h": ("s", 3600.0), - "pa": ("pa", 1.0), - "kpa": ("pa", 1e3), - "mpa": ("pa", 1e6), - "m/s": ("m/s", 1.0), - "km/h": ("m/s", 1000.0 / 3600.0), +# --------------------------------------------------------------------------- +# Composable unit registry based on dimensional analysis. +# +# Every physical unit is represented as: +# - dim_vector: exponents of the 7 SI base dimensions [M, L, T, I, Θ, N, J] +# (mass, length, time, electric current, temperature, amount, luminous intensity) +# - scale: multiplicative factor relative to the SI base unit for that dimension +# - offset: additive offset (non-zero only for temperature scales) +# - domain: semantic grouping for disambiguation (e.g., Hz vs Bq are both T⁻¹) +# +# Compatibility check: dimension vectors must match. +# Conversion: canonical_value = raw_value * scale + offset. +# Adding a new unit = adding a single row. No code changes required. +# --------------------------------------------------------------------------- + +# Dimension vector indices: M=0, L=1, T=2, I=3, Θ=4, N=5, J=6 +# We use tuples for hashability and fast comparison. + +# Base dimension vectors for common physical quantities +_DIM_LENGTH = (0, 1, 0, 0, 0, 0, 0) # L +_DIM_MASS = (1, 0, 0, 0, 0, 0, 0) # M +_DIM_TIME = (0, 0, 1, 0, 0, 0, 0) # T +_DIM_TEMPERATURE = (0, 0, 0, 0, 1, 0, 0) # Θ +_DIM_VELOCITY = (0, 1, -1, 0, 0, 0, 0) # L·T⁻¹ +_DIM_ACCEL = (0, 1, -2, 0, 0, 0, 0) # L·T⁻² +_DIM_PRESSURE = (1, -1, -2, 0, 0, 0, 0) # M·L⁻¹·T⁻² +_DIM_FORCE = (1, 1, -2, 0, 0, 0, 0) # M·L·T⁻² +_DIM_ENERGY = (1, 2, -2, 0, 0, 0, 0) # M·L²·T⁻² +_DIM_POWER = (1, 2, -3, 0, 0, 0, 0) # M·L²·T⁻³ +_DIM_FREQUENCY = (0, 0, -1, 0, 0, 0, 0) # T⁻¹ +_DIM_AREA = (0, 2, 0, 0, 0, 0, 0) # L² +_DIM_RADIOACT = (0, 0, -1, 0, 0, 0, 0) # T⁻¹ (same as frequency, different domain) + + +@dataclass(frozen=True, slots=True) +class UnitEntry: + """One row in the composable unit registry.""" + + dim_vector: tuple[int, ...] # exponents of [M, L, T, I, Θ, N, J] + scale: float # multiplicative factor to SI base + offset: float = 0.0 # additive offset (temperature only) + domain: str = "" # semantic grouping (pressure, temperature, etc.) + + +# The registry: unit_name → UnitEntry. +# Adding a new unit = adding a single line here. +_UNIT_REGISTRY: dict[str, UnitEntry] = { + # --- Length (L) --- + "nm": UnitEntry(_DIM_LENGTH, 1e-9, domain="length"), + "mm": UnitEntry(_DIM_LENGTH, 1e-3, domain="length"), + "cm": UnitEntry(_DIM_LENGTH, 1e-2, domain="length"), + "m": UnitEntry(_DIM_LENGTH, 1.0, domain="length"), + "km": UnitEntry(_DIM_LENGTH, 1e3, domain="length"), + # --- Mass (M) --- + "mg": UnitEntry(_DIM_MASS, 1e-6, domain="mass"), + "g": UnitEntry(_DIM_MASS, 1e-3, domain="mass"), + "kg": UnitEntry(_DIM_MASS, 1.0, domain="mass"), + # --- Time (T) --- + "s": UnitEntry(_DIM_TIME, 1.0, domain="time"), + "min": UnitEntry(_DIM_TIME, 60.0, domain="time"), + "h": UnitEntry(_DIM_TIME, 3600.0, domain="time"), + # --- Temperature (Θ) --- + "kelvin": UnitEntry(_DIM_TEMPERATURE, 1.0, 0.0, domain="temperature"), + "k": UnitEntry(_DIM_TEMPERATURE, 1.0, 0.0, domain="temperature"), + "degc": UnitEntry(_DIM_TEMPERATURE, 1.0, 273.15, domain="temperature"), + "°c": UnitEntry(_DIM_TEMPERATURE, 1.0, 273.15, domain="temperature"), + "c": UnitEntry(_DIM_TEMPERATURE, 1.0, 273.15, domain="temperature"), + "celsius": UnitEntry(_DIM_TEMPERATURE, 1.0, 273.15, domain="temperature"), + "centigrade": UnitEntry(_DIM_TEMPERATURE, 1.0, 273.15, domain="temperature"), + "degf": UnitEntry(_DIM_TEMPERATURE, 5.0 / 9.0, 255.372, domain="temperature"), + "°f": UnitEntry(_DIM_TEMPERATURE, 5.0 / 9.0, 255.372, domain="temperature"), + "f": UnitEntry(_DIM_TEMPERATURE, 5.0 / 9.0, 255.372, domain="temperature"), + "fahrenheit": UnitEntry(_DIM_TEMPERATURE, 5.0 / 9.0, 255.372, domain="temperature"), + # --- Pressure (M·L⁻¹·T⁻²) --- + "pa": UnitEntry(_DIM_PRESSURE, 1.0, domain="pressure"), + "pascal": UnitEntry(_DIM_PRESSURE, 1.0, domain="pressure"), + "pascals": UnitEntry(_DIM_PRESSURE, 1.0, domain="pressure"), + "hpa": UnitEntry(_DIM_PRESSURE, 1e2, domain="pressure"), + "hectopascal": UnitEntry(_DIM_PRESSURE, 1e2, domain="pressure"), + "kpa": UnitEntry(_DIM_PRESSURE, 1e3, domain="pressure"), + "kilopascal": UnitEntry(_DIM_PRESSURE, 1e3, domain="pressure"), + "mpa": UnitEntry(_DIM_PRESSURE, 1e6, domain="pressure"), + "megapascal": UnitEntry(_DIM_PRESSURE, 1e6, domain="pressure"), + "bar": UnitEntry(_DIM_PRESSURE, 1e5, domain="pressure"), + "atm": UnitEntry(_DIM_PRESSURE, 101325.0, domain="pressure"), + "atmosphere": UnitEntry(_DIM_PRESSURE, 101325.0, domain="pressure"), + "psi": UnitEntry(_DIM_PRESSURE, 6894.757, domain="pressure"), + # --- Velocity (L·T⁻¹) --- + "m/s": UnitEntry(_DIM_VELOCITY, 1.0, domain="velocity"), + "km/h": UnitEntry(_DIM_VELOCITY, 1000.0 / 3600.0, domain="velocity"), + "kn": UnitEntry(_DIM_VELOCITY, 0.514444, domain="velocity"), # knots + # --- Acceleration (L·T⁻²) --- + "m/s2": UnitEntry(_DIM_ACCEL, 1.0, domain="acceleration"), + # --- Frequency (T⁻¹) --- + "hz": UnitEntry(_DIM_FREQUENCY, 1.0, domain="frequency"), + "khz": UnitEntry(_DIM_FREQUENCY, 1e3, domain="frequency"), + "mhz": UnitEntry(_DIM_FREQUENCY, 1e6, domain="frequency"), + "ghz": UnitEntry(_DIM_FREQUENCY, 1e9, domain="frequency"), + "rad/s": UnitEntry(_DIM_FREQUENCY, 1.0 / (2 * 3.14159265), domain="frequency"), + # --- Radioactivity (T⁻¹, different domain from frequency) --- + "bq": UnitEntry(_DIM_RADIOACT, 1.0, domain="radioactivity"), + "ci": UnitEntry(_DIM_RADIOACT, 3.7e10, domain="radioactivity"), + # --- Energy (M·L²·T⁻²) --- + "ev": UnitEntry(_DIM_ENERGY, 1.602176634e-19, domain="energy"), + "kev": UnitEntry(_DIM_ENERGY, 1.602176634e-16, domain="energy"), + "mev": UnitEntry(_DIM_ENERGY, 1.602176634e-13, domain="energy"), + "gev": UnitEntry(_DIM_ENERGY, 1.602176634e-10, domain="energy"), + "kj": UnitEntry(_DIM_ENERGY, 1e3, domain="energy"), + "mj": UnitEntry(_DIM_ENERGY, 1e6, domain="energy"), + "gj": UnitEntry(_DIM_ENERGY, 1e9, domain="energy"), + # --- Power (M·L²·T⁻³) --- + "w": UnitEntry(_DIM_POWER, 1.0, domain="power"), + "kw": UnitEntry(_DIM_POWER, 1e3, domain="power"), + "mw": UnitEntry(_DIM_POWER, 1e6, domain="power"), + "gw": UnitEntry(_DIM_POWER, 1e9, domain="power"), + # --- Area (L²) --- + "ha": UnitEntry(_DIM_AREA, 1e4, domain="area"), + # --- Force (M·L·T⁻²) --- + # "n" omitted — collides with amount-of-substance "N" and generic variables. + # Users can add it if their corpus doesn't use "N" as a variable. +} + +# Backward-compatible flat dict for query_rewriter.py (_expand_unit_variants). +# Maps unit_name → (canonical_dim_key, scale, offset). +# The canonical_dim_key is a string representation of the dimension vector +# so that existing code comparing canonical_unit strings still works. +_DIM_KEY_CACHE: dict[tuple[int, ...], str] = {} + + +def _dim_key(dim_vector: tuple[int, ...]) -> str: + """Return a stable string key for a dimension vector. + + Uses comma separator to avoid conflict with the pipe-delimited + measurement encoding format used by encode_measurements(). + """ + if dim_vector not in _DIM_KEY_CACHE: + _DIM_KEY_CACHE[dim_vector] = ",".join(str(d) for d in dim_vector) + return _DIM_KEY_CACHE[dim_vector] + + +# Build backward-compatible _UNIT_CANONICALIZATION from the registry. +_UNIT_CANONICALIZATION: dict[str, tuple[str, float, float]] = { + name: (_dim_key(entry.dim_vector), entry.scale, entry.offset) + for name, entry in _UNIT_REGISTRY.items() } @@ -58,7 +201,8 @@ class Measurement: raw_value: float raw_unit: str canonical_value: float - canonical_unit: str + canonical_unit: str # dimension key string (e.g., "1|-1|-2|0|0|0|0" for pressure) + quality: str = "unknown" # QualityFlag string form; see indexing.quality @dataclass(frozen=True, slots=True) @@ -81,8 +225,8 @@ def canonicalize_measurement(value: float, unit: str) -> tuple[float, str]: canonical = _UNIT_CANONICALIZATION.get(normalized_unit) if canonical is None: raise ValueError(f"Unsupported unit '{unit}'") - canonical_unit, multiplier = canonical - return value * multiplier, canonical_unit + canonical_unit, scale, offset = canonical + return value * scale + offset, canonical_unit def normalize_formula(formula: str) -> str: @@ -114,6 +258,20 @@ def _normalize_formula_side(side: str) -> str: def extract_measurements(text: str) -> list[Measurement]: + """Extract numeric measurements with units from free text. + + Each match is canonicalised to SI base units. Quality is set to + ``"good"`` by default since the value was successfully parsed and + canonicalised — downstream connectors can override this when the + source provides explicit QC flags (e.g. CSV qc columns). + """ + # Import locally to avoid a top-level circular import (quality depends + # on nothing, but indexing.scientific is imported widely). + from clio_agentic_search.indexing.quality import ( + QualityFlag, + derive_flag_from_value, + ) + measurements: list[Measurement] = [] for match in _MEASUREMENT_PATTERN.finditer(text): raw_value = float(match.group("value")) @@ -122,12 +280,20 @@ def extract_measurements(text: str) -> list[Measurement]: canonical_value, canonical_unit = canonicalize_measurement(raw_value, raw_unit) except ValueError: continue + # Default to GOOD, then let the physical-plausibility check + # potentially downgrade to QUESTIONABLE for out-of-range values. + flag = derive_flag_from_value( + canonical_unit, + canonical_value, + QualityFlag.GOOD, + ) measurements.append( Measurement( raw_value=raw_value, raw_unit=raw_unit.lower(), canonical_value=canonical_value, canonical_unit=canonical_unit, + quality=flag.value, ) ) return measurements @@ -146,24 +312,44 @@ def extract_formula_signatures(text: str) -> list[str]: def encode_measurements(measurements: list[Measurement]) -> str: + """Encode a list of :class:`Measurement` objects to a string. + + Format: semicolon-separated entries; each entry pipe-separated as: + canonical_unit|canonical_value|raw_unit|raw_value[|quality] + + The optional ``quality`` field is a :class:`~indexing.quality.QualityFlag` + string (``"good"``, ``"bad"``, etc). When absent (legacy rows), decoding + yields ``quality="unknown"``. + """ if not measurements: return "" return ";".join( - f"{item.canonical_unit}|{item.canonical_value:.12g}|{item.raw_unit}|{item.raw_value:.12g}" + f"{item.canonical_unit}|{item.canonical_value:.12g}|" + f"{item.raw_unit}|{item.raw_value:.12g}|{item.quality}" for item in measurements ) def decode_measurements(value: str) -> list[Measurement]: + """Decode a string produced by :func:`encode_measurements`. + + Accepts both the 4-field legacy format (no quality) and the 5-field + format (with quality) for backward compatibility. Malformed entries + are skipped silently. + """ decoded: list[Measurement] = [] if not value: return decoded for item in value.split(";"): parts = item.split("|") - if len(parts) != 4: + if len(parts) < 4: continue - canonical_unit, canonical_value, raw_unit, raw_value = parts + canonical_unit = parts[0] + canonical_value = parts[1] + raw_unit = parts[2] + raw_value = parts[3] + quality = parts[4] if len(parts) >= 5 else "unknown" try: decoded.append( Measurement( @@ -171,6 +357,7 @@ def decode_measurements(value: str) -> list[Measurement]: raw_unit=raw_unit, canonical_value=float(canonical_value), canonical_unit=canonical_unit, + quality=quality, ) ) except ValueError: diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/agentic.py b/clio-agentic-search/src/clio_agentic_search/retrieval/agentic.py new file mode 100644 index 00000000..5a37380e --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/agentic.py @@ -0,0 +1,471 @@ +"""Multi-hop agentic retrieval with iterative query refinement.""" + +from __future__ import annotations + +import time +from dataclasses import dataclass, field + +from clio_agentic_search.core.connectors import NamespaceConnector +from clio_agentic_search.models.contracts import CitationRecord, TraceEvent +from clio_agentic_search.retrieval.capabilities import CorpusProfileCapable +from clio_agentic_search.retrieval.coordinator import RetrievalCoordinator +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile +from clio_agentic_search.retrieval.query_rewriter import ( + FallbackQueryRewriter, + QueryRewriter, + RewriteResult, +) +from clio_agentic_search.retrieval.scientific import ScientificQueryOperators + + +@dataclass(frozen=True, slots=True) +class HopRecord: + hop_number: int + query: str + strategy: str + reasoning: str + citations_found: int + new_citations: int + + +@dataclass(frozen=True, slots=True) +class TokenUsage: + """Cumulative LLM token usage across all hops.""" + + total_input_tokens: int = 0 + total_output_tokens: int = 0 + llm_calls: int = 0 + + +@dataclass(frozen=True, slots=True) +class AgenticQueryResult: + namespace: str + original_query: str + final_query: str + citations: list[CitationRecord] + hops: list[HopRecord] + trace: list[TraceEvent] + total_hops: int + strategy_used: str = "default" + token_usage: TokenUsage = field(default_factory=TokenUsage) + + +@dataclass(slots=True) +class AgenticRetriever: + coordinator: RetrievalCoordinator = field(default_factory=RetrievalCoordinator) + rewriter: QueryRewriter | FallbackQueryRewriter = field(default_factory=FallbackQueryRewriter) + max_hops: int = 3 + min_score_threshold: float = 0.5 + convergence_threshold: int = 0 # stop if no new citations found + + def query( + self, + *, + connector: NamespaceConnector, + query: str, + top_k: int = 5, + metadata_filters: dict[str, str] | None = None, + scientific_operators: ScientificQueryOperators | None = None, + ) -> AgenticQueryResult: + """Run multi-hop agentic retrieval against a single namespace.""" + namespace = connector.descriptor().name + trace: list[TraceEvent] = [] + hops: list[HopRecord] = [] + all_citations: dict[str, CitationRecord] = {} # chunk_id -> best citation + current_query = query + + # --- Metadata-adaptive strategy selection --- + strategy_used = "default" + profile: CorpusProfile | None = None + if isinstance(connector, CorpusProfileCapable): + profile = connector.corpus_profile() + if profile.metadata_density > 0.5: + strategy_used = "metadata_rich" + elif profile.metadata_density < 0.1: + strategy_used = "metadata_sparse" + + self._append_trace( + trace=trace, + stage="agentic_started", + message="agentic retrieval loop started", + attributes={ + "query": query, + "namespace": namespace, + "max_hops": str(self.max_hops), + "strategy": strategy_used, + "metadata_density": f"{profile.metadata_density:.2f}" if profile else "n/a", + }, + ) + + for hop_number in range(1, self.max_hops + 1): + self._append_trace( + trace=trace, + stage="hop_started", + message=f"hop {hop_number} started", + attributes={ + "hop": str(hop_number), + "query": current_query, + }, + ) + + result = self.coordinator.query( + connector=connector, + query=current_query, + top_k=top_k, + metadata_filters=metadata_filters, + scientific_operators=scientific_operators, + ) + trace.extend(result.trace) + + # Merge citations — keep highest score per chunk_id. + new_count = 0 + for citation in result.citations: + existing = all_citations.get(citation.chunk_id) + if existing is None: + all_citations[citation.chunk_id] = citation + new_count += 1 + elif citation.score > existing.score: + all_citations[citation.chunk_id] = citation + + hop_record = HopRecord( + hop_number=hop_number, + query=current_query, + strategy="initial" if hop_number == 1 else "rewrite", + reasoning="", + citations_found=len(result.citations), + new_citations=new_count, + ) + + self._append_trace( + trace=trace, + stage="hop_completed", + message=f"hop {hop_number} completed", + attributes={ + "citations_found": str(len(result.citations)), + "new_citations": str(new_count), + "total_accumulated": str(len(all_citations)), + }, + ) + + # Check if best results meet score threshold. + max_score = max((c.score for c in result.citations), default=0.0) + results_sufficient = max_score >= self.min_score_threshold and len(result.citations) > 0 + + # Decide whether to continue. + if hop_number >= self.max_hops: + hops.append(hop_record) + break + + # Convergence: no new citations. + if new_count <= self.convergence_threshold and hop_number > 1: + hops.append( + HopRecord( + hop_number=hop_record.hop_number, + query=hop_record.query, + strategy="converged", + reasoning="No new citations found; stopping.", + citations_found=hop_record.citations_found, + new_citations=hop_record.new_citations, + ) + ) + self._append_trace( + trace=trace, + stage="convergence_reached", + message="no new citations; stopping", + attributes={"hop": str(hop_number)}, + ) + break + + # Ask the rewriter whether/how to refine. + snippets = [c.snippet for c in result.citations if c.snippet] + rewrite_result: RewriteResult = self.rewriter.rewrite( + query=current_query, + retrieved_snippets=snippets, + hop_number=hop_number, + max_hops=self.max_hops, + ) + + hop_record = HopRecord( + hop_number=hop_record.hop_number, + query=hop_record.query, + strategy=rewrite_result.strategy, + reasoning=rewrite_result.reasoning, + citations_found=hop_record.citations_found, + new_citations=hop_record.new_citations, + ) + hops.append(hop_record) + + self._append_trace( + trace=trace, + stage="rewrite_completed", + message=f"rewriter chose strategy={rewrite_result.strategy}", + attributes={ + "hop": str(hop_number), + "strategy": rewrite_result.strategy, + "rewritten_query": rewrite_result.rewritten_query, + "reasoning": rewrite_result.reasoning, + }, + ) + + if rewrite_result.strategy == "done": + break + if results_sufficient and rewrite_result.strategy == "done": + break + + current_query = rewrite_result.rewritten_query + continue + + # Final citation list sorted by score descending, capped at top_k. + final_citations = sorted( + all_citations.values(), + key=lambda c: (-c.score, c.namespace, c.document_id, c.chunk_id), + )[:top_k] + + self._append_trace( + trace=trace, + stage="agentic_completed", + message="agentic retrieval loop completed", + attributes={ + "total_hops": str(len(hops)), + "final_citations": str(len(final_citations)), + "final_query": current_query, + }, + ) + + # Aggregate token usage from rewrite results. + total_input = sum(getattr(h, "_input_tokens", 0) for h in hops) + total_output = sum(getattr(h, "_output_tokens", 0) for h in hops) + llm_calls = sum(1 for h in hops if h.strategy not in ("initial", "converged")) + + return AgenticQueryResult( + namespace=namespace, + original_query=query, + final_query=current_query, + citations=final_citations, + hops=hops, + trace=trace, + total_hops=len(hops), + strategy_used=strategy_used, + token_usage=TokenUsage( + total_input_tokens=total_input, + total_output_tokens=total_output, + llm_calls=llm_calls, + ), + ) + + def query_namespaces( + self, + *, + connectors: list[NamespaceConnector], + query: str, + top_k: int = 5, + metadata_filters: dict[str, str] | None = None, + scientific_operators: ScientificQueryOperators | None = None, + ) -> AgenticQueryResult: + """Run multi-hop agentic retrieval across multiple namespaces.""" + trace: list[TraceEvent] = [] + hops: list[HopRecord] = [] + all_citations: dict[str, CitationRecord] = {} + current_query = query + namespaces = [c.descriptor().name for c in connectors] + + # --- Namespace routing: score and rank connectors --- + ops = scientific_operators or ScientificQueryOperators() + scored_connectors: list[tuple[float, NamespaceConnector]] = [] + for conn in connectors: + score = 0.5 # base score for any non-empty namespace + if isinstance(conn, CorpusProfileCapable): + p = conn.corpus_profile() + if p.document_count > 0: + score += 0.5 + if ops.is_active() and p.has_measurements: + score += 2.0 + if ops.formula is not None and p.has_formulas: + score += 1.5 + if p.metadata_density > 0.3: + score += 1.0 + scored_connectors.append((score, conn)) + + # Sort descending by score; on first hop query only top-ranked. + scored_connectors.sort(key=lambda sc: -sc[0]) + ranked_connectors = [conn for _, conn in scored_connectors] + routing_order = [conn.descriptor().name for conn in ranked_connectors] + + self._append_trace( + trace=trace, + stage="agentic_multi_started", + message="agentic multi-namespace retrieval started", + attributes={ + "query": query, + "namespaces": ",".join(namespaces), + "routing_order": ",".join(routing_order), + "max_hops": str(self.max_hops), + }, + ) + + for hop_number in range(1, self.max_hops + 1): + # On hop 1, query only the top-ranked namespace(s); + # on subsequent hops, widen to all namespaces. + if hop_number == 1 and len(ranked_connectors) > 1: + active_connectors = ranked_connectors[:1] + else: + active_connectors = ranked_connectors + + self._append_trace( + trace=trace, + stage="hop_started", + message=f"hop {hop_number} started (multi-namespace)", + attributes={ + "hop": str(hop_number), + "query": current_query, + "active_namespaces": ",".join(c.descriptor().name for c in active_connectors), + }, + ) + + result = self.coordinator.query_namespaces( + connectors=active_connectors, + query=current_query, + top_k=top_k, + metadata_filters=metadata_filters, + scientific_operators=scientific_operators, + ) + trace.extend(result.trace) + + new_count = 0 + for citation in result.citations: + existing = all_citations.get(citation.chunk_id) + if existing is None: + all_citations[citation.chunk_id] = citation + new_count += 1 + elif citation.score > existing.score: + all_citations[citation.chunk_id] = citation + + hop_record = HopRecord( + hop_number=hop_number, + query=current_query, + strategy="initial" if hop_number == 1 else "rewrite", + reasoning="", + citations_found=len(result.citations), + new_citations=new_count, + ) + + self._append_trace( + trace=trace, + stage="hop_completed", + message=f"hop {hop_number} completed (multi-namespace)", + attributes={ + "citations_found": str(len(result.citations)), + "new_citations": str(new_count), + "total_accumulated": str(len(all_citations)), + }, + ) + + if hop_number >= self.max_hops: + hops.append(hop_record) + break + + if new_count <= self.convergence_threshold and hop_number > 1: + hops.append( + HopRecord( + hop_number=hop_record.hop_number, + query=hop_record.query, + strategy="converged", + reasoning="No new citations found; stopping.", + citations_found=hop_record.citations_found, + new_citations=hop_record.new_citations, + ) + ) + self._append_trace( + trace=trace, + stage="convergence_reached", + message="no new citations; stopping (multi-namespace)", + attributes={"hop": str(hop_number)}, + ) + break + + snippets = [c.snippet for c in result.citations if c.snippet] + rewrite_result: RewriteResult = self.rewriter.rewrite( + query=current_query, + retrieved_snippets=snippets, + hop_number=hop_number, + max_hops=self.max_hops, + ) + + hop_record = HopRecord( + hop_number=hop_record.hop_number, + query=hop_record.query, + strategy=rewrite_result.strategy, + reasoning=rewrite_result.reasoning, + citations_found=hop_record.citations_found, + new_citations=hop_record.new_citations, + ) + hops.append(hop_record) + + self._append_trace( + trace=trace, + stage="rewrite_completed", + message=f"rewriter chose strategy={rewrite_result.strategy}", + attributes={ + "hop": str(hop_number), + "strategy": rewrite_result.strategy, + "rewritten_query": rewrite_result.rewritten_query, + "reasoning": rewrite_result.reasoning, + }, + ) + + if rewrite_result.strategy == "done": + break + + current_query = rewrite_result.rewritten_query + continue + + final_citations = sorted( + all_citations.values(), + key=lambda c: (-c.score, c.namespace, c.document_id, c.chunk_id), + )[:top_k] + + self._append_trace( + trace=trace, + stage="agentic_multi_completed", + message="agentic multi-namespace retrieval completed", + attributes={ + "total_hops": str(len(hops)), + "final_citations": str(len(final_citations)), + "final_query": current_query, + }, + ) + + llm_calls = sum(1 for h in hops if h.strategy not in ("initial", "converged")) + + return AgenticQueryResult( + namespace=",".join(namespaces), + original_query=query, + final_query=current_query, + citations=final_citations, + hops=hops, + trace=trace, + total_hops=len(hops), + strategy_used="routed", + token_usage=TokenUsage( + total_input_tokens=0, + total_output_tokens=0, + llm_calls=llm_calls, + ), + ) + + @staticmethod + def _append_trace( + *, + trace: list[TraceEvent], + stage: str, + message: str, + attributes: dict[str, str], + ) -> None: + trace.append( + TraceEvent( + stage=stage, + message=message, + timestamp_ns=time.time_ns(), + attributes=attributes, + ) + ) diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/capabilities.py b/clio-agentic-search/src/clio_agentic_search/retrieval/capabilities.py index 1bade38d..f789cacc 100644 --- a/clio-agentic-search/src/clio_agentic_search/retrieval/capabilities.py +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/capabilities.py @@ -3,10 +3,13 @@ from __future__ import annotations from dataclasses import dataclass -from typing import Protocol, runtime_checkable +from typing import TYPE_CHECKING, Protocol, runtime_checkable from clio_agentic_search.retrieval.scientific import ScientificQueryOperators +if TYPE_CHECKING: + from clio_agentic_search.retrieval.corpus_profile import CorpusProfile + @dataclass(frozen=True, slots=True) class ScoredChunk: @@ -71,3 +74,9 @@ def search_scientific( operators: ScientificQueryOperators, ) -> list[ScoredChunk]: """Search by scientific operators on structured/indexed scientific metadata.""" + + +@runtime_checkable +class CorpusProfileCapable(Protocol): + def corpus_profile(self) -> CorpusProfile: + """Return a lightweight statistical profile of indexed content.""" diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/coordinator.py b/clio-agentic-search/src/clio_agentic_search/retrieval/coordinator.py index b4fc7a3a..497e3cc5 100644 --- a/clio-agentic-search/src/clio_agentic_search/retrieval/coordinator.py +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/coordinator.py @@ -8,6 +8,7 @@ from clio_agentic_search.core.connectors import NamespaceConnector from clio_agentic_search.models.contracts import CitationRecord, TraceEvent from clio_agentic_search.retrieval.capabilities import ( + CorpusProfileCapable, GraphSearchCapable, LexicalSearchCapable, MetadataFilterCapable, @@ -17,7 +18,11 @@ VectorSearchCapable, ) from clio_agentic_search.retrieval.rerank import DefaultHeuristicReranker, Reranker -from clio_agentic_search.retrieval.scientific import ScientificQueryOperators +from clio_agentic_search.retrieval.scientific import ( + QualityFilterOperator, + ScientificQueryOperators, +) +from clio_agentic_search.retrieval.strategy import select_branches from clio_agentic_search.telemetry import Tracer, get_tracer @@ -137,8 +142,51 @@ def _query_single_connector( attributes={"query": query}, ) + # --- Intelligent branch selection via corpus profiling --- + profile = None + if isinstance(connector, CorpusProfileCapable): + profile = connector.corpus_profile() + + plan = select_branches( + query=query, + operators=scientific_operators, + profile=profile, + connector_has_lexical=isinstance(connector, LexicalSearchCapable), + connector_has_vector=isinstance(connector, VectorSearchCapable), + connector_has_graph=isinstance(connector, GraphSearchCapable), + connector_has_scientific=isinstance(connector, ScientificSearchCapable), + ) + # If the plan says to apply the quality filter and the user didn't + # specify one explicitly, inject the default QualityFilterOperator so + # the scientific branch drops bad/missing rows automatically. + if plan.apply_quality_filter and scientific_operators.quality_filter is None: + scientific_operators = ScientificQueryOperators( + numeric_range=scientific_operators.numeric_range, + unit_match=scientific_operators.unit_match, + formula=scientific_operators.formula, + quality_filter=QualityFilterOperator(), + ) + + self._append_trace( + trace=trace, + stage="branch_plan_selected", + message=f"branch plan: {plan.reasoning}", + attributes={ + "namespace": namespace, + "use_lexical": str(plan.use_lexical), + "use_vector": str(plan.use_vector), + "use_graph": str(plan.use_graph), + "use_scientific": str(plan.use_scientific), + "apply_quality_filter": str(plan.apply_quality_filter), + "targeted_concepts": ",".join(plan.targeted_concepts), + "schema_richness": f"{plan.schema_richness:.3f}", + "average_quality": f"{plan.average_quality:.3f}", + "has_profile": str(profile is not None), + }, + ) + lexical: list[ScoredChunk] = [] - if isinstance(connector, LexicalSearchCapable): + if plan.use_lexical and isinstance(connector, LexicalSearchCapable): lexical = connector.search_lexical(query, top_k=top_k * 4) self._append_trace( trace=trace, @@ -148,7 +196,7 @@ def _query_single_connector( ) vector: list[ScoredChunk] = [] - if isinstance(connector, VectorSearchCapable): + if plan.use_vector and isinstance(connector, VectorSearchCapable): vector = connector.search_vector(query, top_k=top_k * 4) self._append_trace( trace=trace, @@ -158,7 +206,7 @@ def _query_single_connector( ) graph: list[ScoredChunk] = [] - if isinstance(connector, GraphSearchCapable): + if plan.use_graph and isinstance(connector, GraphSearchCapable): graph = connector.search_graph(query, top_k=top_k * 2) self._append_trace( trace=trace, @@ -168,7 +216,7 @@ def _query_single_connector( ) scientific: list[ScoredChunk] = [] - if scientific_operators.is_active() and isinstance(connector, ScientificSearchCapable): + if plan.use_scientific and isinstance(connector, ScientificSearchCapable): scientific = connector.search_scientific( query=query, top_k=top_k * 4, @@ -187,7 +235,7 @@ def _query_single_connector( graph=graph, scientific=scientific, ) - if scientific_operators.is_active() and isinstance(connector, ScientificSearchCapable): + if plan.use_scientific and isinstance(connector, ScientificSearchCapable): matched_scientific_ids = {candidate.chunk_id for candidate in scientific} merged = [ candidate for candidate in merged if candidate.chunk_id in matched_scientific_ids diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/corpus_profile.py b/clio-agentic-search/src/clio_agentic_search/retrieval/corpus_profile.py new file mode 100644 index 00000000..069cd9d6 --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/corpus_profile.py @@ -0,0 +1,244 @@ +"""Lightweight corpus profiling for intelligent branch selection. + +A :class:`CorpusProfile` is what the agent looks at *before* deciding +which retrieval branches to activate and what filters to apply. It +summarises three things: + +1. **Capability** — what kinds of search the corpus actually supports + (lexical postings? vector embeddings? scientific measurements? + formulas?). +2. **Metadata schema** — what structured metadata fields exist and what + canonical scientific concepts they cover (temperature, pressure, + station_id, etc.). See :mod:`metadata_schema`. +3. **Quality** — distribution of data-quality flags over the indexed + measurements. See :mod:`indexing.quality`. + +The profile is cheap to compute (a handful of GROUP BY queries on the +DuckDB index), so it's called per query. That's the whole point: +the agent can afford to look before it searches. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +from clio_agentic_search.indexing.quality import QualityFlag, QualitySummary +from clio_agentic_search.retrieval.metadata_schema import MetadataSchema +from clio_agentic_search.retrieval.sample_schema import SampledSchema +from clio_agentic_search.storage.contracts import StorageAdapter + + +@dataclass(frozen=True, slots=True) +class CorpusProfile: + """Statistical summary of what is indexed in a namespace. + + The ``metadata_density`` field is the narrow scientific-metadata ratio + (fraction of chunks with scientific.measurements or scientific.formulas). + For a broader notion of "how rich is this metadata", see + ``metadata_schema.richness_score``. + """ + + namespace: str + document_count: int + chunk_count: int + measurement_count: int + formula_count: int + distinct_units: tuple[str, ...] + distinct_formulas: tuple[str, ...] + metadata_density: float # fraction of chunks with scientific metadata + embedding_count: int + lexical_posting_count: int + + # Optional schema + quality (populated when the storage adapter + # exposes the corresponding query methods). + metadata_schema: MetadataSchema | None = None + quality_summary: QualitySummary | None = None + # Optional sampled-schema fallback: populated when metadata_density is + # low but ``enable_sampling=True`` was passed to build_corpus_profile. + # Captures concepts/measurements found by reading a small sample of + # chunks, even if structured extraction missed them at index time. + sampled_schema: SampledSchema | None = None + + @property + def has_measurements(self) -> bool: + """True if the primary index contains measurements or if a + sampling pass discovered recoverable ones.""" + if self.measurement_count > 0: + return True + if self.sampled_schema is not None and self.sampled_schema.measurement_count > 0: + return True + return False + + @property + def has_formulas(self) -> bool: + return self.formula_count > 0 + + @property + def has_embeddings(self) -> bool: + return self.embedding_count > 0 + + @property + def has_lexical(self) -> bool: + return self.lexical_posting_count > 0 + + @property + def has_metadata_schema(self) -> bool: + return self.metadata_schema is not None and len(self.metadata_schema.fields) > 0 + + @property + def has_sampled_schema(self) -> bool: + return self.sampled_schema is not None and self.sampled_schema.has_recoverable_structure + + @property + def has_quality_info(self) -> bool: + return self.quality_summary is not None and self.quality_summary.total > 0 + + @property + def richness_score(self) -> float: + """Broader metadata richness (schema-based, 0-1). + + Order of preference: + 1. Primary MetadataSchema richness (strongest signal). + 2. Sampled-schema inferred density (fallback when primary is empty). + 3. Raw metadata_density (narrowest signal). + """ + if self.metadata_schema is not None and self.metadata_schema.richness_score > 0: + return self.metadata_schema.richness_score + if self.sampled_schema is not None and self.sampled_schema.inferred_density > 0: + return self.sampled_schema.inferred_density + return self.metadata_density + + @property + def recovered_concepts(self) -> frozenset[str]: + """Union of concepts from the primary schema and sampled schema.""" + primary = self.metadata_schema.concepts if self.metadata_schema else frozenset() + sampled = self.sampled_schema.concepts_found if self.sampled_schema else frozenset() + return primary | sampled + + @property + def average_quality_score(self) -> float: + """Mean data-quality score across all measurements, or 1.0 if unknown.""" + if self.quality_summary is None or self.quality_summary.total == 0: + return 1.0 + return self.quality_summary.average_score + + +def build_corpus_profile( + storage: StorageAdapter, + namespace: str, + *, + enable_sampling: bool = False, + sample_size: int = 20, + sample_density_threshold: float = 0.1, + sample_seed: int = 42, +) -> CorpusProfile: + """Build a corpus profile by querying the storage adapter. + + The storage adapter is expected to implement ``corpus_profile_stats`` + (the base profile), and optionally ``query_metadata_schema_rows`` and + ``query_quality_summary`` (the richer fields). Missing optional + methods degrade gracefully. + + Args: + enable_sampling: When True, if the primary metadata_density is + below ``sample_density_threshold`` and the namespace has chunks, + read ``sample_size`` random chunks and run extractors on them + to recover any structure that wasn't captured at index time. + This is the "reason when metadata is absent" fallback — it + costs one extra query to the chunks table, bounded in size. + sample_size: How many chunks to sample. + sample_density_threshold: Only sample if the primary density is + below this (to avoid paying the sampling cost when we already + know the corpus is rich). + sample_seed: Deterministic seed for the sampling, so repeated + calls on the same namespace produce the same results. + """ + stats_fn = getattr(storage, "corpus_profile_stats", None) + if stats_fn is None: + return CorpusProfile( + namespace=namespace, + document_count=0, + chunk_count=0, + measurement_count=0, + formula_count=0, + distinct_units=(), + distinct_formulas=(), + metadata_density=0.0, + embedding_count=0, + lexical_posting_count=0, + ) + + base = stats_fn(namespace) + + # Optional: metadata schema + schema = None + schema_fn = getattr(storage, "query_metadata_schema_rows", None) + if schema_fn is not None: + from clio_agentic_search.retrieval.metadata_schema import ( + build_metadata_schema, + ) + + rows = schema_fn(namespace) + if rows: + schema = build_metadata_schema( + namespace=namespace, + metadata_rows=rows, + total_documents=base.document_count, + total_chunks=base.chunk_count, + ) + + # Optional: quality summary + quality = None + quality_fn = getattr(storage, "query_quality_summary", None) + if quality_fn is not None: + counts = quality_fn(namespace) + if counts: + total = sum(counts.values()) + quality = QualitySummary( + total=total, + good=counts.get(QualityFlag.GOOD.value, 0), + questionable=counts.get(QualityFlag.QUESTIONABLE.value, 0), + bad=counts.get(QualityFlag.BAD.value, 0), + missing=counts.get(QualityFlag.MISSING.value, 0), + estimated=counts.get(QualityFlag.ESTIMATED.value, 0), + unknown=counts.get(QualityFlag.UNKNOWN.value, 0), + ) + + # Optional: sampled schema fallback. Trigger only when the primary + # density is low but the namespace actually has chunks we could inspect. + sampled = None + if ( + enable_sampling + and base.chunk_count > 0 + and base.metadata_density < sample_density_threshold + ): + from clio_agentic_search.retrieval.sample_schema import sample_and_infer_schema + + sampled = sample_and_infer_schema( + storage, + namespace, + sample_size=sample_size, + seed=sample_seed, + ) + # If sampling didn't find anything useful, discard it so the + # profile doesn't pretend there's structure. + if not sampled.has_recoverable_structure: + sampled = None + + # Rebuild the dataclass with the enrichments attached. We can't mutate + # a frozen dataclass, so construct a new one. + return CorpusProfile( + namespace=base.namespace, + document_count=base.document_count, + chunk_count=base.chunk_count, + measurement_count=base.measurement_count, + formula_count=base.formula_count, + distinct_units=base.distinct_units, + distinct_formulas=base.distinct_formulas, + metadata_density=base.metadata_density, + embedding_count=base.embedding_count, + lexical_posting_count=base.lexical_posting_count, + metadata_schema=schema, + quality_summary=quality, + sampled_schema=sampled, + ) diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/metadata_schema.py b/clio-agentic-search/src/clio_agentic_search/retrieval/metadata_schema.py new file mode 100644 index 00000000..17f94887 --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/metadata_schema.py @@ -0,0 +1,425 @@ +"""Metadata schema inference and field alignment. + +This module implements the second search target from the research program: +*heterogeneous metadata*. Different scientific datasets describe the same +real-world concept under different field names — ``"temperature"``, +``"temp"``, ``"air_temp"``, ``"Air Temp (C)"``, ``"T_air"``, ``"T2M"``. +A retrieval layer that only does substring match on field names misses +most of these. + +Two separate concerns live here: + +1. :class:`MetadataSchema` — a per-namespace description of *what fields + exist and how often they appear*. Built from the ``metadata`` table in + DuckDB via :func:`build_metadata_schema`. + +2. :func:`align_field` — map a raw field name to a *canonical concept* + from a small, hand-curated taxonomy. This is the dictionary-based + "best match" that lets the retrieval layer say "field X in dataset A + and field Y in dataset B both represent temperature". + +A richer version of this layer would use embeddings to infer concepts, +but the dictionary approach is deterministic, fast, and covers the +most common scientific fields. It's the real version — not a stub. +""" + +from __future__ import annotations + +import re +from dataclasses import dataclass +from typing import Any + +# --------------------------------------------------------------------------- +# Canonical concept taxonomy +# --------------------------------------------------------------------------- +# +# After normalisation each field name becomes a sequence of ``_``-separated +# tokens (``"Air Temp (C)"`` → ``["air", "temp"]``). We match by checking +# whether any ``include_tokens`` entry is a **set subset** of the field's +# tokens (AND semantics for multi-token patterns), and whether none of the +# ``exclude_tokens`` words appear as tokens (OR semantics for exclusions). +# +# Order matters: the first concept whose include set matches wins. + +_CANONICAL_CONCEPTS: list[tuple[str, list[frozenset[str]], frozenset[str]]] = [ + # (canonical_name, [set_of_required_tokens, ...], {disqualifying_tokens}) + ( + "temperature", + [ + frozenset({"temp"}), + frozenset({"temperature"}), + frozenset({"air", "temp"}), + frozenset({"surface", "temp"}), + frozenset({"t", "air"}), + frozenset({"t2m"}), + ], + frozenset({"id", "sensor", "scale", "unit", "station", "site"}), + ), + ( + "station_id", + [ + frozenset({"stn", "id"}), + frozenset({"station", "id"}), + frozenset({"site", "id"}), + frozenset({"station", "number"}), + frozenset({"sid"}), + ], + frozenset(), + ), + ( + "pressure", + [ + frozenset({"pressure"}), + frozenset({"press"}), + frozenset({"pres"}), + frozenset({"baro"}), + frozenset({"barometric"}), + frozenset({"barometric", "pressure"}), + frozenset({"atm", "pressure"}), + frozenset({"mslp"}), + frozenset({"slp"}), + frozenset({"vap", "pres"}), + ], + frozenset({"id", "sensor"}), + ), + ( + "humidity", + [ + frozenset({"humidity"}), + frozenset({"humid"}), + frozenset({"rel", "hum"}), + frozenset({"relative", "humidity"}), + frozenset({"rh"}), + frozenset({"dew", "point"}), + ], + frozenset({"sensor"}), + ), + ( + "wind_direction", + [ + frozenset({"wind", "direction"}), + frozenset({"wind", "dir"}), + frozenset({"wnd", "dir"}), + frozenset({"wd"}), + ], + frozenset({"id"}), + ), + ( + "wind_speed", + [ + frozenset({"wind", "speed"}), + frozenset({"wind", "spd"}), + frozenset({"wnd", "spd"}), + frozenset({"wnd", "speed"}), + frozenset({"ws"}), + frozenset({"wind", "vel"}), + frozenset({"wind", "velocity"}), + ], + frozenset({"id", "direction", "dir"}), + ), + ( + "precipitation", + [ + frozenset({"precip"}), + frozenset({"precipitation"}), + frozenset({"rain"}), + frozenset({"rainfall"}), + frozenset({"pcp"}), + frozenset({"snow"}), + frozenset({"snowfall"}), + ], + frozenset({"id"}), + ), + ( + "solar_radiation", + [ + frozenset({"sol", "rad"}), + frozenset({"solar"}), + frozenset({"solar", "radiation"}), + frozenset({"irradiance"}), + frozenset({"short", "wave"}), + frozenset({"sw", "down"}), + ], + frozenset({"id"}), + ), + ( + "soil_moisture", + [ + frozenset({"soil", "moisture"}), + frozenset({"soil", "moist"}), + frozenset({"vwc"}), + ], + frozenset({"id"}), + ), + ( + "time", + [ + frozenset({"time"}), + frozenset({"timestamp"}), + frozenset({"date"}), + frozenset({"datetime"}), + frozenset({"epoch"}), + frozenset({"hour"}), + frozenset({"obs", "time"}), + ], + frozenset({"zone"}), + ), + ( + "latitude", + [ + frozenset({"lat"}), + frozenset({"latitude"}), + ], + frozenset({"id", "err", "limit", "plat", "flat"}), + ), + ( + "longitude", + [ + frozenset({"lon"}), + frozenset({"lng"}), + frozenset({"longitude"}), + ], + frozenset({"id", "err", "limit"}), + ), + ( + "elevation", + [ + frozenset({"elevation"}), + frozenset({"elev"}), + frozenset({"altitude"}), + frozenset({"alt"}), + frozenset({"height"}), + ], + frozenset({"id", "ref"}), + ), + ( + "measurement_quality", + [ + frozenset({"qc"}), + frozenset({"quality"}), + frozenset({"qflag"}), + frozenset({"qa"}), + frozenset({"flag"}), + ], + frozenset(), + ), +] + + +_WHITESPACE_RE = re.compile(r"[\s\-\.]+") +_UNIT_SUFFIX_RE = re.compile(r"\s*\([^)]*\)\s*$") +_PUNCT_RE = re.compile(r"[^\w_]") + + +def _normalise_field_name(name: str) -> str: + """Normalise a field name for matching. + + - Strip trailing ``(unit)`` suffixes. + - Lowercase. + - Collapse whitespace/dots/hyphens to underscores. + - Drop other punctuation. + """ + cleaned = _UNIT_SUFFIX_RE.sub("", name.strip()).lower() + cleaned = _WHITESPACE_RE.sub("_", cleaned) + cleaned = _PUNCT_RE.sub("", cleaned) + return cleaned + + +def _tokenise(normalised: str) -> set[str]: + """Split a normalised field name into its token set.""" + return {t for t in normalised.split("_") if t} + + +def align_field(field_name: str) -> str | None: + """Map a raw field name to a canonical concept, or ``None`` if unknown. + + Matching is token-based on the normalised form of the field name: + the field is split on underscores (after stripping ``(unit)`` suffixes + and lowercasing) and each concept's include patterns are treated as + required-token sets. Exclude tokens disqualify a match if they appear. + + Examples: + >>> align_field("Air Temp (C)") + 'temperature' + >>> align_field("temperature_sensor_id") # "id" disqualifies + >>> align_field("Rel Hum (%)") + 'humidity' + """ + normalised = _normalise_field_name(field_name) + if not normalised: + return None + + tokens = _tokenise(normalised) + if not tokens: + return None + + for concept, include_sets, excludes in _CANONICAL_CONCEPTS: + if tokens & excludes: + continue + for required in include_sets: + if required.issubset(tokens): + return concept + return None + + +# --------------------------------------------------------------------------- +# MetadataSchema — per-namespace description of indexed fields +# --------------------------------------------------------------------------- + + +@dataclass(frozen=True, slots=True) +class FieldInfo: + """Description of a single metadata field found in a namespace.""" + + key: str + scope: str # "document" or "chunk" + occurrences: int + canonical_concept: str | None + + +@dataclass(frozen=True, slots=True) +class MetadataSchema: + """Per-namespace metadata schema. + + Attributes: + namespace: The namespace this schema describes. + fields: All distinct metadata keys found, with occurrence counts. + total_documents: Total documents in the namespace. + total_chunks: Total chunks in the namespace. + concepts: Set of canonical concepts detected (e.g. ``{"temperature", + "humidity"}``). + richness_score: Heuristic 0-1 score of how metadata-rich this + namespace is. 0 = almost no structured metadata, 1 = every + chunk has rich structured metadata with recognised concepts. + """ + + namespace: str + fields: tuple[FieldInfo, ...] + total_documents: int + total_chunks: int + concepts: frozenset[str] + richness_score: float + + @property + def has_temperature_field(self) -> bool: + return "temperature" in self.concepts + + @property + def has_pressure_field(self) -> bool: + return "pressure" in self.concepts + + @property + def has_location_fields(self) -> bool: + return "latitude" in self.concepts and "longitude" in self.concepts + + @property + def has_quality_field(self) -> bool: + return "measurement_quality" in self.concepts + + def fields_for_concept(self, concept: str) -> tuple[FieldInfo, ...]: + """Return all fields that map to the given canonical concept.""" + return tuple(f for f in self.fields if f.canonical_concept == concept) + + +def build_metadata_schema( + namespace: str, + metadata_rows: list[tuple[str, str, str, int]], + total_documents: int, + total_chunks: int, +) -> MetadataSchema: + """Build a :class:`MetadataSchema` from raw metadata rows. + + Args: + namespace: Namespace name. + metadata_rows: Each entry is ``(key, scope, sample_value, count)`` + — the count of how many distinct record_ids in this namespace + have that ``(key, scope)`` pair. Typically produced by a + ``GROUP BY`` query on the ``metadata`` table. + total_documents, total_chunks: Totals for richness-score computation. + """ + fields: list[FieldInfo] = [] + concepts: set[str] = set() + for key, scope, _sample, count in metadata_rows: + concept = align_field(key) + if concept: + concepts.add(concept) + fields.append( + FieldInfo( + key=key, + scope=scope, + occurrences=count, + canonical_concept=concept, + ) + ) + + richness = _compute_richness(fields, concepts, total_documents, total_chunks) + + return MetadataSchema( + namespace=namespace, + fields=tuple(fields), + total_documents=total_documents, + total_chunks=total_chunks, + concepts=frozenset(concepts), + richness_score=richness, + ) + + +def _compute_richness( + fields: list[FieldInfo], + concepts: set[str], + total_docs: int, + total_chunks: int, +) -> float: + """Compute a 0-1 richness score. + + Combines three signals, each weighted: + - Coverage: how many chunks have ANY metadata key (0-0.4) + - Field count: how many distinct keys exist (saturates at 10) (0-0.3) + - Concept recognition: how many canonical concepts were detected + (saturates at 5) (0-0.3) + """ + if total_chunks == 0: + return 0.0 + + # Coverage + chunk_scope_fields = [f for f in fields if f.scope == "chunk"] + chunks_with_metadata = max( + (f.occurrences for f in chunk_scope_fields), + default=0, + ) + coverage = min(chunks_with_metadata / total_chunks, 1.0) if total_chunks > 0 else 0.0 + coverage_score = 0.4 * coverage + + # Field variety + variety_score = 0.3 * min(len(fields) / 10.0, 1.0) + + # Concept recognition + concept_score = 0.3 * min(len(concepts) / 5.0, 1.0) + + return round(coverage_score + variety_score + concept_score, 4) + + +# --------------------------------------------------------------------------- +# Convenience: describe schema as plain dict for JSON / trace output +# --------------------------------------------------------------------------- + + +def describe_schema(schema: MetadataSchema) -> dict[str, Any]: + """Return a JSON-serialisable description of a schema.""" + return { + "namespace": schema.namespace, + "total_documents": schema.total_documents, + "total_chunks": schema.total_chunks, + "richness_score": schema.richness_score, + "distinct_field_count": len(schema.fields), + "concepts": sorted(schema.concepts), + "top_fields": [ + { + "key": f.key, + "scope": f.scope, + "occurrences": f.occurrences, + "concept": f.canonical_concept, + } + for f in sorted(schema.fields, key=lambda x: -x.occurrences)[:20] + ], + } diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/query_rewriter.py b/clio-agentic-search/src/clio_agentic_search/retrieval/query_rewriter.py new file mode 100644 index 00000000..b03d0bfe --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/query_rewriter.py @@ -0,0 +1,207 @@ +"""LLM-driven query rewriting for iterative retrieval refinement.""" + +from __future__ import annotations + +import json +import re +from dataclasses import dataclass + +try: + import anthropic + + HAS_ANTHROPIC = True +except ImportError: + HAS_ANTHROPIC = False + +from clio_agentic_search.indexing.scientific import _UNIT_CANONICALIZATION + +_SYSTEM_PROMPT = """\ +You are a scientific search query optimizer. Given a query and retrieved results, \ +decide how to refine the query for better scientific data retrieval. + +Strategies: +- "expand": Add related terms discovered in results (e.g., add unit variants, synonyms) +- "narrow": Focus on a specific aspect when results are too broad +- "pivot": Shift to a related measurement or formula when direct match fails +- "done": Results are sufficient, stop iterating + +Respond in JSON: {"strategy": "...", "rewritten_query": "...", "reasoning": "..."}\ +""" + +_VALID_STRATEGIES = frozenset({"expand", "narrow", "pivot", "done"}) + + +@dataclass(frozen=True, slots=True) +class RewriteResult: + original_query: str + rewritten_query: str + strategy: str # "expand", "narrow", "pivot", "done" + reasoning: str + input_tokens: int = 0 + output_tokens: int = 0 + + +class QueryRewriter: + """Rewrites queries based on retrieval results using an LLM.""" + + def __init__( + self, + *, + model: str = "claude-sonnet-4-20250514", + api_key: str | None = None, + ): + if not HAS_ANTHROPIC: + raise RuntimeError("Install anthropic: pip install 'clio-agentic-search[llm]'") + self._client = anthropic.Anthropic(api_key=api_key) + self._model = model + + def rewrite( + self, + *, + query: str, + retrieved_snippets: list[str], + hop_number: int, + max_hops: int, + ) -> RewriteResult: + """Ask the LLM to decide whether and how to refine the query.""" + snippets_text = "\n---\n".join(retrieved_snippets) if retrieved_snippets else "(none)" + user_message = ( + f"Current query: {query}\n" + f"Hop: {hop_number}/{max_hops}\n" + f"Retrieved snippets:\n{snippets_text}\n\n" + "Decide: should the query be refined? " + "If the results already cover the information need, use strategy 'done' " + "and return the original query unchanged. Otherwise pick expand/narrow/pivot " + "and provide a rewritten query." + ) + + response = self._client.messages.create( + model=self._model, + max_tokens=512, + system=_SYSTEM_PROMPT, + messages=[{"role": "user", "content": user_message}], + ) + + # response.content[0] is a content-block union; only text blocks carry + # `.text`. The model is prompted to return plain text, so read it + # defensively to satisfy the typed Anthropic SDK. + raw_text = getattr(response.content[0], "text", "").strip() + result = _parse_llm_response(raw_text, original_query=query) + input_tokens = getattr(response.usage, "input_tokens", 0) + output_tokens = getattr(response.usage, "output_tokens", 0) + return RewriteResult( + original_query=result.original_query, + rewritten_query=result.rewritten_query, + strategy=result.strategy, + reasoning=result.reasoning, + input_tokens=input_tokens, + output_tokens=output_tokens, + ) + + +class FallbackQueryRewriter: + """Offline query rewriter that expands SI unit variants without an LLM.""" + + def rewrite( + self, + *, + query: str, + retrieved_snippets: list[str], + hop_number: int, + max_hops: int, + ) -> RewriteResult: + """Expand query with SI unit variants found in the canonicalization table.""" + expanded_terms = _expand_unit_variants(query) + if expanded_terms: + rewritten = f"{query} {' '.join(expanded_terms)}" + return RewriteResult( + original_query=query, + rewritten_query=rewritten, + strategy="expand", + reasoning=f"Added SI unit variants: {', '.join(expanded_terms)}", + ) + # No expansion possible — signal completion. + return RewriteResult( + original_query=query, + rewritten_query=query, + strategy="done", + reasoning="No unit variants to expand; stopping.", + ) + + +# --------------------------------------------------------------------------- +# Internal helpers +# --------------------------------------------------------------------------- + +# Build a reverse map: canonical_unit -> set of raw units that share it. +_CANONICAL_GROUPS: dict[str, set[str]] = {} +for _raw, (_canon, *_rest) in _UNIT_CANONICALIZATION.items(): + _CANONICAL_GROUPS.setdefault(_canon, set()).add(_raw) + +# Pattern that matches any known unit as a standalone token (case-insensitive). +_KNOWN_UNITS = sorted(_UNIT_CANONICALIZATION.keys(), key=len, reverse=True) +_UNIT_TOKEN_PATTERN = re.compile( + r"\b(" + "|".join(re.escape(u) for u in _KNOWN_UNITS) + r")\b", + flags=re.IGNORECASE, +) + + +def _expand_unit_variants(query: str) -> list[str]: + """Return unit tokens related to units already present in *query*.""" + found_units: set[str] = set() + for match in _UNIT_TOKEN_PATTERN.finditer(query): + found_units.add(match.group(1).lower()) + + if not found_units: + return [] + + variants: list[str] = [] + seen: set[str] = set(found_units) + for unit in found_units: + entry = _UNIT_CANONICALIZATION.get(unit) + if entry is None: + continue + canonical_unit = entry[0] + siblings = _CANONICAL_GROUPS.get(canonical_unit, set()) + for sibling in sorted(siblings): + if sibling not in seen: + variants.append(sibling) + seen.add(sibling) + return variants + + +def _parse_llm_response(raw_text: str, *, original_query: str) -> RewriteResult: + """Parse JSON from the LLM response, falling back gracefully.""" + # Strip markdown code fences if present. + cleaned = raw_text.strip() + if cleaned.startswith("```"): + cleaned = re.sub(r"^```\w*\n?", "", cleaned) + cleaned = re.sub(r"\n?```$", "", cleaned) + cleaned = cleaned.strip() + + try: + data = json.loads(cleaned) + except json.JSONDecodeError: + return RewriteResult( + original_query=original_query, + rewritten_query=original_query, + strategy="done", + reasoning=f"LLM returned unparseable response: {raw_text[:200]}", + ) + + strategy = str(data.get("strategy", "done")).lower() + if strategy not in _VALID_STRATEGIES: + strategy = "done" + + rewritten = str(data.get("rewritten_query", original_query)).strip() + if not rewritten: + rewritten = original_query + + reasoning = str(data.get("reasoning", "")).strip() + + return RewriteResult( + original_query=original_query, + rewritten_query=rewritten, + strategy=strategy, + reasoning=reasoning, + ) diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/sample_schema.py b/clio-agentic-search/src/clio_agentic_search/retrieval/sample_schema.py new file mode 100644 index 00000000..c5b8df0f --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/sample_schema.py @@ -0,0 +1,187 @@ +"""Active schema inference via sampling. + +When a namespace was indexed without structured metadata extraction — for +example, a CSV ingested as raw text or an HDF5 file whose attribute +extractor was disabled — ``CorpusProfile.metadata_density`` comes out near +zero. The basic branch planner then skips the scientific branch because +it believes there are no measurements. + +But the measurements might actually be *there*, sitting in chunk text +that nobody extracted. :func:`sample_and_infer_schema` recovers from this +by reading a small deterministic sample of chunks, running the regex +extractors and field aligners on them, and reporting what it finds. The +caller can then re-enable the scientific branch based on the inferred +schema — without having to re-index the entire corpus. + +This is the "reason when metadata is absent" half of the agentic search +motivation: the agent does a cheap bounded inspection rather than either +scanning everything or giving up. +""" + +from __future__ import annotations + +import re +from dataclasses import dataclass + +from clio_agentic_search.indexing.scientific import extract_measurements +from clio_agentic_search.retrieval.metadata_schema import align_field +from clio_agentic_search.storage.contracts import StorageAdapter + +# Separators that typically appear between CSV/TSV/pipe-delimited fields in +# text chunks that came from tabular sources. Used to split each line of +# a sampled chunk into candidate field names for the aligner. +_FIELD_SEPARATOR_RE = re.compile(r"[,\t|;]") + + +@dataclass(frozen=True, slots=True) +class SampledSchema: + """Schema discovered by reading a random sample of chunks. + + Attributes: + namespace: The namespace that was sampled. + sample_size: How many chunks were actually inspected (may be less + than the requested size if the namespace is small). + total_chunks: Total chunks in the namespace (for reference). + concepts_found: Canonical scientific concepts discovered + (via :func:`metadata_schema.align_field` on line-split text). + measurement_units_found: Distinct raw unit strings extracted from + the sampled text (via :func:`extract_measurements`). + measurement_count: Total extractable measurements found in the + sample, summed across all chunks. + chunks_with_signal: Number of sampled chunks that yielded at least + one concept or measurement. + inferred_density: ``chunks_with_signal / sample_size``. If this is + high, the namespace has recoverable structure even though the + primary metadata_density may have been low. + sample_chunk_ids: The chunk IDs actually read (for reproducibility). + """ + + namespace: str + sample_size: int + total_chunks: int + concepts_found: frozenset[str] + measurement_units_found: frozenset[str] + measurement_count: int + chunks_with_signal: int + inferred_density: float + sample_chunk_ids: tuple[str, ...] + + @property + def has_recoverable_structure(self) -> bool: + """True if sampling found concepts or measurements that weren't + captured by the primary index.""" + return bool(self.concepts_found) or self.measurement_count > 0 + + +def sample_and_infer_schema( + storage: StorageAdapter, + namespace: str, + *, + sample_size: int = 20, + seed: int = 42, +) -> SampledSchema: + """Sample chunks from a namespace and infer what's inside. + + The function: + 1. Asks storage for ``sample_size`` deterministically-random chunks. + 2. Runs :func:`extract_measurements` on each chunk's text. + 3. Scans each line for candidate field names separated by commas, + tabs, or pipes, and aligns each to a canonical concept. + 4. Aggregates the findings into a :class:`SampledSchema`. + + Args: + storage: Any :class:`StorageAdapter` implementing ``sample_chunks`` + (currently :class:`DuckDBStorage`). + namespace: The namespace to sample. + sample_size: Maximum number of chunks to inspect. + seed: Deterministic seed for sampling. + + Returns: + :class:`SampledSchema`. Fields are zero / empty if the namespace + has no chunks or the storage adapter doesn't support sampling. + """ + # Gracefully degrade if the adapter doesn't support sampling yet. + sample_fn = getattr(storage, "sample_chunks", None) + if sample_fn is None: + return SampledSchema( + namespace=namespace, + sample_size=0, + total_chunks=0, + concepts_found=frozenset(), + measurement_units_found=frozenset(), + measurement_count=0, + chunks_with_signal=0, + inferred_density=0.0, + sample_chunk_ids=(), + ) + + # Total chunk count (for the ratio) — use corpus_profile_stats if present + total_chunks = 0 + stats_fn = getattr(storage, "corpus_profile_stats", None) + if stats_fn is not None: + total_chunks = stats_fn(namespace).chunk_count + + sampled = sample_fn(namespace, sample_size=sample_size, seed=seed) + if not sampled: + return SampledSchema( + namespace=namespace, + sample_size=0, + total_chunks=total_chunks, + concepts_found=frozenset(), + measurement_units_found=frozenset(), + measurement_count=0, + chunks_with_signal=0, + inferred_density=0.0, + sample_chunk_ids=(), + ) + + concepts: set[str] = set() + units: set[str] = set() + total_measurements = 0 + chunks_with_signal = 0 + + for chunk in sampled: + chunk_signal = False + + # 1. Regex measurement extraction on the full text + measurements = extract_measurements(chunk.text) + if measurements: + chunk_signal = True + total_measurements += len(measurements) + for m in measurements: + units.add(m.raw_unit) + + # 2. Line-oriented field-name alignment: treat each line as + # possibly a CSV row and each comma/tab/pipe-separated cell as a + # candidate field name. Tabular data ingested as plain text shows + # up here even if its headers weren't captured as structured metadata. + for line in chunk.text.splitlines(): + line = line.strip() + if not line or len(line) > 500: + # Skip very long lines (prose paragraphs, not CSV rows). + continue + for cell in _FIELD_SEPARATOR_RE.split(line): + cell = cell.strip() + if not cell or len(cell) > 60: + continue + concept = align_field(cell) + if concept: + concepts.add(concept) + chunk_signal = True + + if chunk_signal: + chunks_with_signal += 1 + + inferred_density = chunks_with_signal / len(sampled) + + return SampledSchema( + namespace=namespace, + sample_size=len(sampled), + total_chunks=total_chunks, + concepts_found=frozenset(concepts), + measurement_units_found=frozenset(units), + measurement_count=total_measurements, + chunks_with_signal=chunks_with_signal, + inferred_density=round(inferred_density, 4), + sample_chunk_ids=tuple(c.chunk_id for c in sampled), + ) diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/scientific.py b/clio-agentic-search/src/clio_agentic_search/retrieval/scientific.py index 05592381..d478c764 100644 --- a/clio-agentic-search/src/clio_agentic_search/retrieval/scientific.py +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/scientific.py @@ -4,6 +4,7 @@ from dataclasses import dataclass +from clio_agentic_search.indexing.quality import QualityFlag from clio_agentic_search.indexing.scientific import ( Measurement, canonicalize_measurement, @@ -27,26 +28,86 @@ class UnitMatchOperator: tolerance: float = 1e-9 +@dataclass(frozen=True, slots=True) +class QualityFilterOperator: + """Filter measurements by data-quality flags. + + ``acceptable`` is the whitelist of :class:`QualityFlag` values that + should match. The default accepts GOOD and ESTIMATED only. Set + ``minimum_score`` to a value in [0, 1] to additionally require each + measurement's numeric quality score (see + :attr:`QualityFlag.numeric_score`) to exceed that threshold. + """ + + acceptable: tuple[QualityFlag, ...] = ( + QualityFlag.GOOD, + QualityFlag.ESTIMATED, + ) + minimum_score: float = 0.0 + + def accepts(self, flag_string: str | QualityFlag) -> bool: + flag = ( + flag_string + if isinstance(flag_string, QualityFlag) + else QualityFlag.from_string(flag_string) + ) + if flag not in self.acceptable: + return False + if flag.numeric_score < self.minimum_score: + return False + return True + + def acceptable_strings(self) -> tuple[str, ...]: + """Return the whitelist as raw strings (for SQL parameter binding).""" + return tuple(flag.value for flag in self.acceptable) + + @dataclass(frozen=True, slots=True) class ScientificQueryOperators: numeric_range: NumericRangeOperator | None = None unit_match: UnitMatchOperator | None = None formula: str | None = None + quality_filter: QualityFilterOperator | None = None def is_active(self) -> bool: - return self.numeric_range is not None or self.unit_match is not None or bool(self.formula) + return ( + self.numeric_range is not None + or self.unit_match is not None + or bool(self.formula) + or self.quality_filter is not None + ) def score_scientific_metadata( metadata: dict[str, str], operators: ScientificQueryOperators, ) -> float: + """Score a chunk's scientific metadata against a set of query operators. + + Returns ``0.0`` if any operator's hard constraint fails, otherwise a + sum of weighted contributions. The :class:`QualityFilterOperator` (if + present) is applied as a pre-filter to the measurement list — bad or + missing measurements are dropped before the other operators see them. + Additionally, the *mean* quality score of remaining measurements is + folded into the returned score as a soft boost, so chunks with + better-quality data rank higher. + """ if not operators.is_active(): return 0.0 measurements = decode_measurements(metadata.get("scientific.measurements", "")) formulas = _decode_formulas(metadata.get("scientific.formulas", "")) + # Quality pre-filter: drop unacceptable measurements entirely so the + # downstream range/unit operators only ever see clean rows. + if operators.quality_filter is not None: + measurements = [m for m in measurements if operators.quality_filter.accepts(m.quality)] + if not measurements and ( + operators.numeric_range is not None or operators.unit_match is not None + ): + # Quality filter removed everything this chunk could match on. + return 0.0 + score = 0.0 if operators.numeric_range is not None: if not _matches_numeric_range(measurements, operators.numeric_range): @@ -63,6 +124,15 @@ def score_scientific_metadata( return 0.0 score += 1.4 + # Quality boost: if the quality operator is active and there are + # surviving measurements, reward chunks whose average measurement + # quality is higher. Max boost = 0.3 for all-GOOD rows. + if operators.quality_filter is not None and measurements: + avg_quality = sum( + QualityFlag.from_string(m.quality).numeric_score for m in measurements + ) / len(measurements) + score += 0.3 * avg_quality + return score diff --git a/clio-agentic-search/src/clio_agentic_search/retrieval/strategy.py b/clio-agentic-search/src/clio_agentic_search/retrieval/strategy.py new file mode 100644 index 00000000..a92eeacc --- /dev/null +++ b/clio-agentic-search/src/clio_agentic_search/retrieval/strategy.py @@ -0,0 +1,151 @@ +"""Rule-based branch selection for intelligent retrieval orchestration. + +The :class:`BranchPlan` answers three questions the coordinator asks before +dispatching a query: + +1. Which retrieval branches should run? (lexical / vector / graph / scientific) +2. Should the quality filter be applied (is the corpus known to carry + quality flags)? +3. What concepts in the corpus schema is the agent implicitly targeting? + +The plan's ``reasoning`` field records the *why* in human-readable form so +the whole decision is auditable from the trace log. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile +from clio_agentic_search.retrieval.scientific import ScientificQueryOperators + + +@dataclass(frozen=True, slots=True) +class BranchPlan: + """Which retrieval branches to activate for a query. + + Also records the strategic choices the planner made based on the + metadata schema and quality information in the corpus profile. + """ + + use_lexical: bool + use_vector: bool + use_graph: bool + use_scientific: bool + reasoning: str + # Richer context for the agent and the trace log + apply_quality_filter: bool = False + targeted_concepts: tuple[str, ...] = () + schema_richness: float = 0.0 + average_quality: float = 1.0 + + +def select_branches( + query: str, + operators: ScientificQueryOperators, + profile: CorpusProfile | None, + *, + connector_has_lexical: bool = False, + connector_has_vector: bool = False, + connector_has_graph: bool = False, + connector_has_scientific: bool = False, +) -> BranchPlan: + """Decide which retrieval branches to activate. + + When *profile* is ``None`` (connector does not support profiling), + every branch that the connector declares is used — identical to the + original behaviour, with all schema/quality fields zeroed. + """ + if profile is None: + return BranchPlan( + use_lexical=connector_has_lexical, + use_vector=connector_has_vector, + use_graph=connector_has_graph, + use_scientific=connector_has_scientific and operators.is_active(), + reasoning="no corpus profile available; using all declared branches", + ) + + reasons: list[str] = [] + + # --- Branch 1: lexical --- + use_lexical = connector_has_lexical and profile.has_lexical + if connector_has_lexical and not profile.has_lexical: + reasons.append("lexical skipped (no postings)") + + # --- Branch 2: vector --- + use_vector = connector_has_vector and profile.has_embeddings + if connector_has_vector and not profile.has_embeddings: + reasons.append("vector skipped (no embeddings)") + + # --- Branch 3: graph (always run if supported, cheap) --- + use_graph = connector_has_graph + + # --- Branch 4: scientific --- + use_scientific = False + if connector_has_scientific and operators.is_active(): + has_relevant = False + if operators.numeric_range is not None and profile.has_measurements: + has_relevant = True + if operators.formula is not None and profile.has_formulas: + has_relevant = True + if operators.unit_match is not None and profile.has_measurements: + has_relevant = True + if operators.quality_filter is not None and profile.has_measurements: + has_relevant = True + use_scientific = has_relevant + if not has_relevant: + reasons.append("scientific skipped (operators active but corpus lacks matching data)") + elif connector_has_scientific and not operators.is_active(): + reasons.append("scientific skipped (no operators in query)") + + # --- Quality filter decision --- + # Apply the quality filter whenever the corpus actually carries quality + # information AND the scientific branch is about to run. This hides + # BAD/MISSING rows by default without requiring the user to specify + # the filter manually. + apply_quality_filter = False + if use_scientific and profile.has_quality_info: + # Only auto-apply if the corpus has at least some non-good flags; + # if everything is already GOOD there's no work for the filter to do. + q = profile.quality_summary + if q is not None and q.acceptable_ratio < 1.0: + apply_quality_filter = True + reasons.append( + f"quality filter enabled (corpus has " + f"{q.total - q.acceptable_count} non-acceptable rows)" + ) + + # --- Targeted concepts from schema --- + targeted: list[str] = [] + if profile.has_metadata_schema: + schema = profile.metadata_schema + assert schema is not None # for type checker + # If the query mentions a recognised scientific concept, prioritise it. + q_lower = query.lower() + concept_keywords = { + "temperature": ("temperature", "temp ", "celsius", "fahrenheit", "kelvin"), + "pressure": ("pressure", "kpa", "hpa", "atm", "bar"), + "humidity": ("humidity", "humid", "dew point"), + "wind_speed": ("wind speed", "wind velocity", "km/h", "m/s"), + "precipitation": ("precipitation", "rain", "snow"), + } + for concept, keywords in concept_keywords.items(): + if concept in schema.concepts and any(k in q_lower for k in keywords): + targeted.append(concept) + if targeted: + reasons.append(f"targeting schema concepts: {', '.join(targeted)}") + + if not reasons: + reasons.append("all applicable branches activated") + + return BranchPlan( + use_lexical=use_lexical, + use_vector=use_vector, + use_graph=use_graph, + use_scientific=use_scientific, + reasoning="; ".join(reasons), + apply_quality_filter=apply_quality_filter, + targeted_concepts=tuple(targeted), + schema_richness=profile.richness_score, + average_quality=profile.average_quality_score, + ) diff --git a/clio-agentic-search/src/clio_agentic_search/storage/contracts.py b/clio-agentic-search/src/clio_agentic_search/storage/contracts.py index e4f3bd78..6b79e7c3 100644 --- a/clio-agentic-search/src/clio_agentic_search/storage/contracts.py +++ b/clio-agentic-search/src/clio_agentic_search/storage/contracts.py @@ -28,6 +28,7 @@ class FileIndexState: class LexicalChunkMatch: chunk: ChunkRecord overlap_count: int + bm25_score: float = 0.0 @dataclass(frozen=True, slots=True) @@ -113,6 +114,7 @@ def query_chunks_by_measurement_range( canonical_unit: str, minimum: float | None, maximum: float | None, + acceptable_quality: tuple[str, ...] | None = None, ) -> list[ChunkRecord]: """Query chunks by canonical measurement range.""" diff --git a/clio-agentic-search/src/clio_agentic_search/storage/duckdb_store.py b/clio-agentic-search/src/clio_agentic_search/storage/duckdb_store.py index 7ffa40b4..183d4689 100644 --- a/clio-agentic-search/src/clio_agentic_search/storage/duckdb_store.py +++ b/clio-agentic-search/src/clio_agentic_search/storage/duckdb_store.py @@ -8,7 +8,10 @@ from collections import Counter from collections.abc import Iterable, Iterator from pathlib import Path -from typing import Any +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from clio_agentic_search.retrieval.corpus_profile import CorpusProfile import duckdb @@ -128,10 +131,20 @@ def connect(self) -> None: canonical_unit TEXT, canonical_value DOUBLE, raw_unit TEXT, - raw_value DOUBLE + raw_value DOUBLE, + quality TEXT DEFAULT 'unknown' ) """ ) + # Additive migration for pre-existing databases that were created + # before the quality column was introduced. ALTER ADD COLUMN is + # idempotent on DuckDB via try/except. + try: + connection.execute( + "ALTER TABLE scientific_measurements ADD COLUMN quality TEXT DEFAULT 'unknown'" + ) + except duckdb.Error: + pass # column already exists connection.execute( """ CREATE TABLE IF NOT EXISTS scientific_formulas ( @@ -340,7 +353,7 @@ def _upsert_document_bundle_unlocked( ) # Populate scientific index tables from metadata - measurement_rows: list[tuple[str, str, str, float, str, float]] = [] + measurement_rows: list[tuple[str, str, str, float, str, float, str]] = [] formula_rows: list[tuple[str, str, str]] = [] for meta_item in metadata: if meta_item.scope != "chunk": @@ -355,6 +368,7 @@ def _upsert_document_bundle_unlocked( m.canonical_value, m.raw_unit, m.raw_value, + m.quality, ) ) elif meta_item.key == "scientific.formulas": @@ -372,8 +386,9 @@ def _upsert_document_bundle_unlocked( connection.executemany( """ INSERT INTO scientific_measurements( - namespace, chunk_id, canonical_unit, canonical_value, raw_unit, raw_value - ) VALUES (?, ?, ?, ?, ?, ?) + namespace, chunk_id, canonical_unit, canonical_value, + raw_unit, raw_value, quality + ) VALUES (?, ?, ?, ?, ?, ?, ?) """, measurement_rows, ) @@ -508,6 +523,40 @@ def list_chunks(self, namespace: str) -> list[ChunkRecord]: return [self._row_to_chunk_record(row) for row in rows] + def sample_chunks( + self, + namespace: str, + sample_size: int, + seed: int = 42, + ) -> list[ChunkRecord]: + """Return at most ``sample_size`` chunks chosen deterministically. + + Uses a hash over ``(chunk_id, seed)`` so results are stable for a + given seed — useful for reproducible schema-inference runs and + tests. If the namespace has fewer chunks than requested, returns + everything. + """ + if sample_size <= 0: + return [] + with self._connection_lock: + connection = self._require_connection() + # DuckDB supports hash(col1, col2). We salt with the seed as a + # string so different seeds produce different orderings. ORDER + # BY on the resulting integer gives a deterministic random + # permutation. + rows = connection.execute( + """ + SELECT namespace, chunk_id, document_id, chunk_index, text, + start_offset, end_offset + FROM chunks + WHERE namespace = ? + ORDER BY hash(chunk_id || CAST(? AS VARCHAR)) + LIMIT ? + """, + [namespace, str(seed), int(sample_size)], + ).fetchall() + return [self._row_to_chunk_record(row) for row in rows] + def list_embeddings(self, namespace: str, model: str) -> dict[str, tuple[float, ...]]: with self._connection_lock: connection = self._require_connection() @@ -558,6 +607,20 @@ def get_chunk_metadata(self, namespace: str, chunk_id: str) -> dict[str, str]: ).fetchall() return {str(key): str(value) for key, value in rows} + def get_document_metadata(self, namespace: str, document_id: str) -> dict[str, str]: + with self._connection_lock: + connection = self._require_connection() + rows = connection.execute( + """ + SELECT key, value + FROM metadata + WHERE namespace = ? AND scope = 'document' AND record_id = ? + ORDER BY key + """, + [namespace, document_id], + ).fetchall() + return {str(key): str(value) for key, value in rows} + def get_document_uri(self, namespace: str, document_id: str) -> str: with self._connection_lock: connection = self._require_connection() @@ -579,7 +642,29 @@ def query_chunks_by_measurement_range( canonical_unit: str, minimum: float | None, maximum: float | None, + acceptable_quality: tuple[str, ...] | None = None, ) -> list[ChunkRecord]: + """Range query on ``scientific_measurements``. + + Args: + namespace, canonical_unit, minimum, maximum: Standard range bounds. + The canonical_unit may be either the dim-key form + (``"1,-1,-2,0,0,0,0"``) or a short unit name (``"pa"``) which + is converted internally. + acceptable_quality: Optional whitelist of ``QualityFlag`` string + values. When provided, only measurements whose ``quality`` + column is in this set are returned. ``None`` (default) + disables quality filtering for backward compatibility. + """ + # Support both legacy unit strings ("pa") and dimension keys ("1|-1|-2|0|0|0|0"). + # If the caller passes a short unit name, convert it to the dimension key. + if "," not in canonical_unit: + from clio_agentic_search.indexing.scientific import canonicalize_measurement + + try: + _, canonical_unit = canonicalize_measurement(0.0, canonical_unit) + except ValueError: + pass # keep original string if unit is unknown conditions = ["sm.namespace = ?", "sm.canonical_unit = ?"] params: list[Any] = [namespace, canonical_unit] if minimum is not None: @@ -588,6 +673,10 @@ def query_chunks_by_measurement_range( if maximum is not None: conditions.append("sm.canonical_value <= ?") params.append(maximum) + if acceptable_quality is not None and len(acceptable_quality) > 0: + placeholders = ",".join("?" * len(acceptable_quality)) + conditions.append(f"sm.quality IN ({placeholders})") + params.extend(acceptable_quality) where = " AND ".join(conditions) with self._connection_lock: connection = self._require_connection() @@ -604,6 +693,56 @@ def query_chunks_by_measurement_range( ).fetchall() return [self._row_to_chunk_record(row) for row in rows] + def query_metadata_schema_rows( + self, + namespace: str, + ) -> list[tuple[str, str, str, int]]: + """Return ``(key, scope, sample_value, count)`` rows for schema inference. + + Each row counts how many distinct ``record_id`` values in the namespace + have that ``(key, scope)`` pair. Used by + :func:`clio_agentic_search.retrieval.metadata_schema.build_metadata_schema`. + """ + with self._connection_lock: + connection = self._require_connection() + rows = connection.execute( + """ + SELECT key, + scope, + ANY_VALUE(value) AS sample_value, + COUNT(DISTINCT record_id) AS record_count + FROM metadata + WHERE namespace = ? + GROUP BY key, scope + ORDER BY record_count DESC + """, + [namespace], + ).fetchall() + return [(str(k), str(s), str(v) if v is not None else "", int(c)) for k, s, v, c in rows] + + def query_quality_summary( + self, + namespace: str, + ) -> dict[str, int]: + """Return a count of measurements per quality flag in the namespace. + + Returns a dict keyed by quality string (e.g. ``{"good": 1234, + "questionable": 5, "missing": 12}``). Unknown / missing values + map to ``"unknown"``. + """ + with self._connection_lock: + connection = self._require_connection() + rows = connection.execute( + """ + SELECT COALESCE(quality, 'unknown') AS q, COUNT(*) + FROM scientific_measurements + WHERE namespace = ? + GROUP BY q + """, + [namespace], + ).fetchall() + return {str(q): int(count) for q, count in rows} + def query_chunks_by_formula(self, namespace: str, formula_signature: str) -> list[ChunkRecord]: with self._connection_lock: connection = self._require_connection() @@ -630,22 +769,58 @@ def query_chunks_lexical( if not tokens or limit <= 0: return [] placeholders = ", ".join("?" for _ in tokens) - params: list[Any] = [namespace, *tokens, namespace, limit] + # BM25 parameters (Okapi BM25: k1=1.2, b=0.75) + k1 = 1.2 + b = 0.75 + params: list[Any] = [namespace, namespace, namespace, namespace, *tokens, namespace, limit] with self._connection_lock: connection = self._require_connection() rows = connection.execute( f""" - WITH matched AS ( - SELECT chunk_id, SUM(term_freq) AS overlap + WITH corpus_stats AS ( + SELECT + COUNT(DISTINCT chunk_id) AS total_chunks, + AVG(chunk_token_count) AS avgdl + FROM ( + SELECT chunk_id, SUM(term_freq) AS chunk_token_count + FROM lexical_postings + WHERE namespace = ? + GROUP BY chunk_id + ) sub + ), + token_df AS ( + SELECT token, COUNT(DISTINCT chunk_id) AS df FROM lexical_postings - WHERE namespace = ? AND token IN ({placeholders}) + WHERE namespace = ? + GROUP BY token + ), + chunk_lengths AS ( + SELECT chunk_id, SUM(term_freq) AS dl + FROM lexical_postings + WHERE namespace = ? GROUP BY chunk_id + ), + bm25_scored AS ( + SELECT + lp.chunk_id, + SUM( + LN((cs.total_chunks - td.df + 0.5) / (td.df + 0.5) + 1.0) + * (lp.term_freq * ({k1} + 1.0)) + / (lp.term_freq + {k1} * (1.0 - {b} + {b} * cl.dl / cs.avgdl)) + ) AS bm25_score, + SUM(lp.term_freq) AS overlap + FROM lexical_postings lp + JOIN token_df td ON td.token = lp.token + JOIN chunk_lengths cl ON cl.chunk_id = lp.chunk_id + CROSS JOIN corpus_stats cs + WHERE lp.namespace = ? AND lp.token IN ({placeholders}) + GROUP BY lp.chunk_id ) SELECT c.namespace, c.chunk_id, c.document_id, c.chunk_index, c.text, - c.start_offset, c.end_offset, matched.overlap - FROM matched - JOIN chunks c ON c.namespace = ? AND c.chunk_id = matched.chunk_id - ORDER BY matched.overlap DESC, c.chunk_id + c.start_offset, c.end_offset, bm.overlap, bm.bm25_score + FROM bm25_scored bm + JOIN chunks c ON c.namespace = ? AND c.chunk_id = bm.chunk_id + ORDER BY bm.bm25_score DESC, c.chunk_id LIMIT ? """, params, @@ -654,8 +829,13 @@ def query_chunks_lexical( for row in rows: chunk_row = row[:7] overlap = int(row[7]) + bm25 = float(row[8]) matches.append( - LexicalChunkMatch(chunk=self._row_to_chunk_record(chunk_row), overlap_count=overlap) + LexicalChunkMatch( + chunk=self._row_to_chunk_record(chunk_row), + overlap_count=overlap, + bm25_score=bm25, + ) ) return matches @@ -759,6 +939,91 @@ def _require_connection(self) -> duckdb.DuckDBPyConnection: raise RuntimeError("Storage is not connected") return self._connection + @staticmethod + def _scalar_int(connection: duckdb.DuckDBPyConnection, sql: str, params: list[Any]) -> int: + """Execute a single-aggregate query and return its scalar as an int.""" + row = connection.execute(sql, params).fetchone() + return int(row[0]) if row is not None else 0 + + def corpus_profile_stats(self, namespace: str) -> CorpusProfile: + """Return lightweight corpus statistics for *namespace*.""" + from clio_agentic_search.retrieval.corpus_profile import CorpusProfile + + with self._connection_lock: + connection = self._require_connection() + + doc_count = self._scalar_int( + connection, "SELECT COUNT(*) FROM documents WHERE namespace = ?", [namespace] + ) + + chunk_count = self._scalar_int( + connection, "SELECT COUNT(*) FROM chunks WHERE namespace = ?", [namespace] + ) + + meas_count = self._scalar_int( + connection, + "SELECT COUNT(*) FROM scientific_measurements WHERE namespace = ?", + [namespace], + ) + + formula_count = self._scalar_int( + connection, + "SELECT COUNT(*) FROM scientific_formulas WHERE namespace = ?", + [namespace], + ) + + distinct_units_rows = connection.execute( + "SELECT DISTINCT canonical_unit FROM scientific_measurements WHERE namespace = ?", + [namespace], + ).fetchall() + distinct_units = tuple(sorted(r[0] for r in distinct_units_rows)) + + distinct_formulas_rows = connection.execute( + "SELECT DISTINCT formula_signature FROM scientific_formulas WHERE namespace = ?", + [namespace], + ).fetchall() + distinct_formulas = tuple(sorted(r[0] for r in distinct_formulas_rows)) + + embedding_count = self._scalar_int( + connection, "SELECT COUNT(*) FROM embeddings WHERE namespace = ?", [namespace] + ) + + lexical_count = self._scalar_int( + connection, + "SELECT COUNT(*) FROM lexical_postings WHERE namespace = ?", + [namespace], + ) + + # metadata_density: fraction of chunks that have at least one + # scientific.measurements or scientific.formulas metadata key. + if chunk_count > 0: + sci_chunk_count = self._scalar_int( + connection, + """ + SELECT COUNT(DISTINCT record_id) FROM metadata + WHERE namespace = ? AND scope = 'chunk' + AND key IN ('scientific.measurements', 'scientific.formulas') + AND value IS NOT NULL AND value != '' + """, + [namespace], + ) + metadata_density = sci_chunk_count / chunk_count + else: + metadata_density = 0.0 + + return CorpusProfile( + namespace=namespace, + document_count=doc_count, + chunk_count=chunk_count, + measurement_count=meas_count, + formula_count=formula_count, + distinct_units=distinct_units, + distinct_formulas=distinct_formulas, + metadata_density=metadata_density, + embedding_count=embedding_count, + lexical_posting_count=lexical_count, + ) + @staticmethod def _row_to_chunk_record(row: tuple[Any, ...]) -> ChunkRecord: namespace, chunk_id, document_id, chunk_index, text, start_offset, end_offset = row diff --git a/clio-agentic-search/src/clio_agentic_search/telemetry/__init__.py b/clio-agentic-search/src/clio_agentic_search/telemetry/__init__.py index a30fe02c..c7cf0adb 100644 --- a/clio-agentic-search/src/clio_agentic_search/telemetry/__init__.py +++ b/clio-agentic-search/src/clio_agentic_search/telemetry/__init__.py @@ -7,7 +7,7 @@ from collections.abc import Iterator from contextlib import contextmanager from dataclasses import dataclass, field -from typing import Any, Protocol, cast +from typing import Any, Protocol # ---------- Tracer abstraction ---------- @@ -243,7 +243,7 @@ def observe_index_duration(self, seconds: float) -> None: self._index_duration.observe(seconds) def export(self) -> str: - raw = cast(bytes, self._generate_latest(self._registry)) + raw: bytes = self._generate_latest(self._registry) return raw.decode("utf-8") diff --git a/clio-agentic-search/tests/integration/test_retrieval_flow.py b/clio-agentic-search/tests/integration/test_retrieval_flow.py index 0e47986f..e0ee4ffe 100644 --- a/clio-agentic-search/tests/integration/test_retrieval_flow.py +++ b/clio-agentic-search/tests/integration/test_retrieval_flow.py @@ -47,6 +47,7 @@ def test_query_returns_deterministic_citations_and_trace(tmp_path: Path) -> None assert first.trace and second.trace assert [event.stage for event in first.trace] == [ "query_started", + "branch_plan_selected", "lexical_completed", "vector_completed", "graph_completed", diff --git a/clio-agentic-search/tests/scientific/test_hardening.py b/clio-agentic-search/tests/scientific/test_hardening.py index 24ad4e28..c3546940 100644 --- a/clio-agentic-search/tests/scientific/test_hardening.py +++ b/clio-agentic-search/tests/scientific/test_hardening.py @@ -149,7 +149,7 @@ def test_numeric_range_filters_noisy_corpus_correctly(tmp_path: Path) -> None: metadata = connector.storage.get_chunk_metadata("test_ns", citation.chunk_id) measurements = decode_measurements(metadata.get("scientific.measurements", "")) in_range = any( - m.canonical_unit == "pa" and 200000.0 <= m.canonical_value <= 310000.0 + m.canonical_unit == "1,-1,-2,0,0,0,0" and 200000.0 <= m.canonical_value <= 310000.0 for m in measurements ) assert in_range, ( @@ -182,7 +182,7 @@ def test_misleading_pressure_mention_excluded_by_tight_range(tmp_path: Path) -> metadata = connector.storage.get_chunk_metadata("test_ns", citation.chunk_id) measurements = decode_measurements(metadata.get("scientific.measurements", "")) in_range = any( - m.canonical_unit == "pa" and 340000.0 <= m.canonical_value <= 360000.0 + m.canonical_unit == "1,-1,-2,0,0,0,0" and 340000.0 <= m.canonical_value <= 360000.0 for m in measurements ) assert in_range, f"Citation {citation.uri} outside [340,360] kPa" @@ -274,7 +274,7 @@ def test_object_store_noisy_corpus_numeric_precision(tmp_path: Path) -> None: # At least 101000 and 102000 Pa should be present exactness = numeric_exactness( retrieved_measurements, - expected=[(101000.0, "pa"), (102000.0, "pa")], + expected=[(101000.0, "1,-1,-2,0,0,0,0"), (102000.0, "1,-1,-2,0,0,0,0")], tolerance=1.0, ) assert exactness >= 1.0 diff --git a/clio-agentic-search/tests/scientific/test_phase3_scientific_retrieval.py b/clio-agentic-search/tests/scientific/test_phase3_scientific_retrieval.py index 33b3d55e..17f6d8ab 100644 --- a/clio-agentic-search/tests/scientific/test_phase3_scientific_retrieval.py +++ b/clio-agentic-search/tests/scientific/test_phase3_scientific_retrieval.py @@ -77,15 +77,16 @@ def test_structure_aware_chunking_indexes_sections_tables_equations_and_captions ) assert any( - measurement.canonical_unit == "pa" and measurement.canonical_value == 120000.0 + measurement.canonical_unit == "1,-1,-2,0,0,0,0" + and measurement.canonical_value == 120000.0 for measurement in all_measurements ) assert any( - measurement.canonical_unit == "m/s" and measurement.canonical_value == 10.0 + measurement.canonical_unit == "0,1,-1,0,0,0,0" and measurement.canonical_value == 10.0 for measurement in all_measurements ) assert any( - measurement.canonical_unit == "kg" and measurement.canonical_value == 0.5 + measurement.canonical_unit == "1,0,0,0,0,0,0" and measurement.canonical_value == 0.5 for measurement in all_measurements ) assert any( @@ -200,7 +201,7 @@ def test_scientific_benchmark_metrics_are_reproducible_on_same_corpus(tmp_path: assert ( numeric_exactness( retrieved_measurements, - expected=[(120000.0, "pa"), (150000.0, "pa")], + expected=[(120000.0, "1,-1,-2,0,0,0,0"), (150000.0, "1,-1,-2,0,0,0,0")], tolerance=1e-9, ) == 1.0 diff --git a/clio-agentic-search/tests/scientific/test_realistic_retrieval_scenarios.py b/clio-agentic-search/tests/scientific/test_realistic_retrieval_scenarios.py index ed66704d..b04c7bb0 100644 --- a/clio-agentic-search/tests/scientific/test_realistic_retrieval_scenarios.py +++ b/clio-agentic-search/tests/scientific/test_realistic_retrieval_scenarios.py @@ -105,7 +105,7 @@ def test_mixed_corpus_generic_and_numeric_queries_are_grounded(tmp_path: Path) - metadata = connector.storage.get_chunk_metadata("local_science", citation.chunk_id) measurements = decode_measurements(metadata.get("scientific.measurements", "")) assert any( - measurement.canonical_unit == "pa" + measurement.canonical_unit == "1,-1,-2,0,0,0,0" and 140000.0 <= measurement.canonical_value <= 155000.0 for measurement in measurements ) diff --git a/clio-agentic-search/tests/unit/test_agentic_retriever.py b/clio-agentic-search/tests/unit/test_agentic_retriever.py new file mode 100644 index 00000000..a38f9913 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_agentic_retriever.py @@ -0,0 +1,218 @@ +"""Tests for multi-hop agentic retrieval.""" + +from __future__ import annotations + +from collections.abc import Iterator +from contextlib import contextmanager +from dataclasses import dataclass, field + +from clio_agentic_search.core.connectors import IndexReport +from clio_agentic_search.models.contracts import CitationRecord, NamespaceDescriptor +from clio_agentic_search.retrieval.agentic import AgenticRetriever +from clio_agentic_search.retrieval.capabilities import ScoredChunk +from clio_agentic_search.retrieval.coordinator import RetrievalCoordinator +from clio_agentic_search.retrieval.query_rewriter import FallbackQueryRewriter + +# --------------------------------------------------------------------------- +# Lightweight stubs (same pattern as test_coordinator_tracing.py) +# --------------------------------------------------------------------------- + + +@dataclass +class _RecordedSpan: + name: str + attributes: dict[str, object] = field(default_factory=dict) + + def set_attribute(self, key: str, value: object) -> None: + self.attributes[key] = value + + def __enter__(self) -> _RecordedSpan: + return self + + def __exit__(self, *args: object) -> None: + return None + + +@dataclass +class _RecordingTracer: + spans: list[_RecordedSpan] = field(default_factory=list) + + @contextmanager + def start_span(self, name: str) -> Iterator[_RecordedSpan]: + span = _RecordedSpan(name=name) + self.spans.append(span) + yield span + + +@dataclass +class _MinimalConnector: + """A connector that returns a fixed set of citations.""" + + namespace: str = "test-ns" + _citations: list[tuple[str, str, str, float]] = field(default_factory=list) + + def set_citations(self, citations: list[tuple[str, str, str, float]]) -> None: + """Set (doc_id, chunk_id, text, score) tuples to return.""" + self._citations = citations + + def descriptor(self) -> NamespaceDescriptor: + return NamespaceDescriptor(name=self.namespace, connector_type="mock", root_uri="mock://") + + def connect(self) -> None: + return None + + def teardown(self) -> None: + return None + + def index(self, *, full_rebuild: bool = False) -> IndexReport: + del full_rebuild + return IndexReport( + scanned_files=0, + indexed_files=0, + skipped_files=0, + removed_files=0, + elapsed_seconds=0.0, + ) + + def build_citation(self, chunk: ScoredChunk) -> CitationRecord: + return CitationRecord( + namespace=self.namespace, + document_id=chunk.document_id, + chunk_id=chunk.chunk_id, + uri=f"mock://{chunk.document_id}", + snippet=chunk.text, + score=chunk.combined_score, + ) + + +def _make_connector( + namespace: str, + citations: list[tuple[str, str, str, float]], +) -> _MinimalConnector: + c = _MinimalConnector(namespace=namespace) + c.set_citations(citations) + return c + + +# --------------------------------------------------------------------------- +# Tests +# --------------------------------------------------------------------------- + + +def test_single_hop() -> None: + """With max_hops=1, the retriever runs exactly one pass.""" + connector = _make_connector("ns", [("d1", "c1", "text1", 0.9)]) + tracer = _RecordingTracer() + coordinator = RetrievalCoordinator(tracer=tracer) + retriever = AgenticRetriever( + coordinator=coordinator, + rewriter=FallbackQueryRewriter(), + max_hops=1, + ) + + result = retriever.query(connector=connector, query="test query", top_k=5) + + assert result.namespace == "ns" + assert result.original_query == "test query" + assert result.total_hops == 1 + assert len(result.hops) == 1 + + +def test_multi_hop_convergence() -> None: + """When the second hop finds no new citations, the loop stops early.""" + connector = _make_connector("ns", [("d1", "c1", "text1", 0.9)]) + tracer = _RecordingTracer() + coordinator = RetrievalCoordinator(tracer=tracer) + retriever = AgenticRetriever( + coordinator=coordinator, + rewriter=FallbackQueryRewriter(), + max_hops=5, + convergence_threshold=0, + ) + + # The FallbackQueryRewriter on a unit-less query will return strategy="done" + # on the first hop, so the loop should stop after hop 1. + result = retriever.query(connector=connector, query="no units here", top_k=5) + assert result.total_hops <= 2 + + +def test_multi_hop_with_unit_rewrite() -> None: + """FallbackQueryRewriter expands units, enabling a second hop.""" + connector = _make_connector("ns", [("d1", "c1", "pressure 200 kPa data", 0.8)]) + tracer = _RecordingTracer() + coordinator = RetrievalCoordinator(tracer=tracer) + retriever = AgenticRetriever( + coordinator=coordinator, + rewriter=FallbackQueryRewriter(), + max_hops=3, + ) + + result = retriever.query(connector=connector, query="pressure 200 kPa", top_k=5) + + # The rewriter should have expanded the query with unit variants. + # Check that at least one hop recorded strategy "expand". + strategies = {hop.strategy for hop in result.hops} + assert "expand" in strategies or "initial" in strategies + + +def test_trace_events_include_agentic_stages() -> None: + """Trace should contain agentic_started, hop_started, hop_completed, and agentic_completed.""" + connector = _make_connector("ns", [("d1", "c1", "text1", 0.9)]) + tracer = _RecordingTracer() + coordinator = RetrievalCoordinator(tracer=tracer) + retriever = AgenticRetriever( + coordinator=coordinator, + rewriter=FallbackQueryRewriter(), + max_hops=1, + ) + + result = retriever.query(connector=connector, query="test", top_k=5) + + stages = {event.stage for event in result.trace} + assert "agentic_started" in stages + assert "hop_started" in stages + assert "hop_completed" in stages + assert "agentic_completed" in stages + + +def test_citations_deduplicated_by_chunk_id() -> None: + """When the same chunk appears across hops, the highest score wins.""" + connector = _make_connector("ns", [("d1", "c1", "text1", 0.7)]) + tracer = _RecordingTracer() + coordinator = RetrievalCoordinator(tracer=tracer) + retriever = AgenticRetriever( + coordinator=coordinator, + rewriter=FallbackQueryRewriter(), + max_hops=1, + ) + + result = retriever.query(connector=connector, query="test", top_k=10) + + # Only one citation per chunk_id. + chunk_ids = [c.chunk_id for c in result.citations] + assert len(chunk_ids) == len(set(chunk_ids)) + + +def test_query_namespaces_across_multiple_connectors() -> None: + """query_namespaces should merge results from multiple connectors.""" + conn_a = _make_connector("ns-a", [("d1", "c1", "text-a", 0.9)]) + conn_b = _make_connector("ns-b", [("d2", "c2", "text-b", 0.8)]) + tracer = _RecordingTracer() + coordinator = RetrievalCoordinator(tracer=tracer) + retriever = AgenticRetriever( + coordinator=coordinator, + rewriter=FallbackQueryRewriter(), + max_hops=1, + ) + + result = retriever.query_namespaces( + connectors=[conn_a, conn_b], + query="test", + top_k=10, + ) + + assert "ns-a" in result.namespace + assert "ns-b" in result.namespace + stages = {event.stage for event in result.trace} + assert "agentic_multi_started" in stages + assert "agentic_multi_completed" in stages diff --git a/clio-agentic-search/tests/unit/test_corpus_profile.py b/clio-agentic-search/tests/unit/test_corpus_profile.py new file mode 100644 index 00000000..1009d179 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_corpus_profile.py @@ -0,0 +1,84 @@ +"""Tests for corpus profiling.""" + +from __future__ import annotations + +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile, build_corpus_profile + + +class _FakeStorage: + """Minimal stub that lacks corpus_profile_stats.""" + + pass + + +class _FakeStorageWithProfile: + """Stub that implements corpus_profile_stats.""" + + def corpus_profile_stats(self, namespace: str) -> CorpusProfile: + return CorpusProfile( + namespace=namespace, + document_count=10, + chunk_count=50, + measurement_count=20, + formula_count=5, + distinct_units=("kg", "m"), + distinct_formulas=("f=ma",), + metadata_density=0.6, + embedding_count=50, + lexical_posting_count=500, + ) + + +def test_corpus_profile_properties() -> None: + p = CorpusProfile( + namespace="ns", + document_count=5, + chunk_count=10, + measurement_count=3, + formula_count=0, + distinct_units=("pa",), + distinct_formulas=(), + metadata_density=0.3, + embedding_count=10, + lexical_posting_count=100, + ) + assert p.has_measurements is True + assert p.has_formulas is False + assert p.has_embeddings is True + assert p.has_lexical is True + + +def test_corpus_profile_zero_counts() -> None: + p = CorpusProfile( + namespace="empty", + document_count=0, + chunk_count=0, + measurement_count=0, + formula_count=0, + distinct_units=(), + distinct_formulas=(), + metadata_density=0.0, + embedding_count=0, + lexical_posting_count=0, + ) + assert p.has_measurements is False + assert p.has_formulas is False + assert p.has_embeddings is False + assert p.has_lexical is False + + +def test_build_corpus_profile_no_stats_method() -> None: + """When storage has no corpus_profile_stats, return zeroed profile.""" + profile = build_corpus_profile(_FakeStorage(), "test") # type: ignore[arg-type] + assert profile.namespace == "test" + assert profile.document_count == 0 + assert profile.measurement_count == 0 + + +def test_build_corpus_profile_with_stats() -> None: + """When storage has corpus_profile_stats, delegate to it.""" + profile = build_corpus_profile(_FakeStorageWithProfile(), "myns") # type: ignore[arg-type] + assert profile.namespace == "myns" + assert profile.document_count == 10 + assert profile.measurement_count == 20 + assert profile.has_formulas is True diff --git a/clio-agentic-search/tests/unit/test_csv_parser.py b/clio-agentic-search/tests/unit/test_csv_parser.py new file mode 100644 index 00000000..c3d7d0a2 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_csv_parser.py @@ -0,0 +1,244 @@ +"""Tests for the science-aware CSV parser (indexing.csv_parser).""" + +from __future__ import annotations + +import textwrap + +from clio_agentic_search.indexing.csv_parser import ( + _find_qc_column_index, + _parse_header_unit, + analyse_header, + filter_rows_by_concept, + parse_scientific_csv, +) +from clio_agentic_search.indexing.quality import QualityFlag + +# --------------------------------------------------------------------------- +# Header parsing +# --------------------------------------------------------------------------- + + +def test_parse_header_unit_parentheses() -> None: + assert _parse_header_unit("Air Temp (C)") == ("Air Temp", "C") + + +def test_parse_header_unit_square_brackets() -> None: + assert _parse_header_unit("Pressure [kPa]") == ("Pressure", "kPa") + + +def test_parse_header_unit_no_unit() -> None: + assert _parse_header_unit("Station Name") == ("Station Name", None) + + +def test_parse_header_unit_compound_unit() -> None: + assert _parse_header_unit("Wind Speed (m/s)") == ("Wind Speed", "m/s") + + +# --------------------------------------------------------------------------- +# QC column detection +# --------------------------------------------------------------------------- + + +def test_find_qc_column_cimis_convention() -> None: + # CIMIS format: each measurement followed by a "qc" column + headers = ["Date", "Air Temp (C)", "qc", "Rel Hum (%)", "qc"] + assert _find_qc_column_index(headers, 1) == 2 # Air Temp's qc + assert _find_qc_column_index(headers, 3) == 4 # Rel Hum's qc + + +def test_find_qc_column_suffix_convention() -> None: + headers = ["Date", "temp", "temp_qflag", "pressure", "pressure_q"] + assert _find_qc_column_index(headers, 1) == 2 + assert _find_qc_column_index(headers, 3) == 4 + + +def test_find_qc_column_none_when_no_qc() -> None: + headers = ["Date", "temperature", "pressure"] + assert _find_qc_column_index(headers, 1) is None + assert _find_qc_column_index(headers, 2) is None + + +# --------------------------------------------------------------------------- +# analyse_header +# --------------------------------------------------------------------------- + + +def test_analyse_header_cimis() -> None: + headers = [ + "Stn Id", + "Stn Name", + "Date", + "Hour (PST)", + "Air Temp (C)", + "qc", + "Rel Hum (%)", + "qc", + "Wind Speed (m/s)", + "qc", + ] + schema = analyse_header(headers) + # Air Temp, Wind Speed are parseable measurements + # (Rel Hum has % which isn't in the registry) + measurement_cols = schema.measurement_columns + display_names = [c.display_name for c in measurement_cols] + assert "Air Temp" in display_names + assert "Wind Speed" in display_names + + # Air Temp should have an adjacent qc column detected + air_temp = next(c for c in schema.columns if c.display_name == "Air Temp") + assert air_temp.qc_column_index == 5 + + # Air Temp should be aligned to the "temperature" concept + assert air_temp.canonical_concept == "temperature" + + +def test_analyse_header_ignores_percent() -> None: + # "%" is dimensionless and not in the registry — not a measurement column. + headers = ["Humidity (%)"] + schema = analyse_header(headers) + assert len(schema.measurement_columns) == 0 + + +# --------------------------------------------------------------------------- +# End-to-end parsing with CIMIS-like fixture +# --------------------------------------------------------------------------- + + +_CIMIS_FIXTURE = textwrap.dedent("""\ + Stn Id,Stn Name,Date,Hour (PST),Air Temp (C),qc,Wind Speed (m/s),qc + 105,Westlands,2024-06-01,0100,20.6,,2.1, + 105,Westlands,2024-06-01,1400,35.2,,3.4, + 105,Westlands,2024-06-01,1500,36.1,Y,3.5, + 105,Westlands,2024-06-01,1600,999,M,4.2, + 105,Westlands,2024-06-01,1700,32.0,,100.0,R +""").strip() + + +def test_parse_cimis_fixture_shape() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE) + # 5 data rows (all non-empty) + assert len(parsed.rows) == 5 + # 2 measurement columns + assert len(parsed.schema.measurement_columns) == 2 + + +def test_parse_cimis_fixture_air_temp_values() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE) + # Extract just the temperature measurements across rows. + # Measurements are emitted in the same order as schema.measurement_columns; + # air temp is first (after wind speed in header order — but our schema + # walks header order, so air temp is first). + temp_measurements = [] + for row in parsed.rows: + for col, m in zip(parsed.schema.measurement_columns, row.measurements, strict=False): + if col.canonical_concept == "temperature": + temp_measurements.append(m) + assert len(temp_measurements) == 5 + + raw_values = [m.raw_value for m in temp_measurements] + assert raw_values == [20.6, 35.2, 36.1, 999.0, 32.0] + + +def test_parse_cimis_fixture_qc_flags() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE) + temp_measurements = [] + for row in parsed.rows: + for col, m in zip(parsed.schema.measurement_columns, row.measurements, strict=False): + if col.canonical_concept == "temperature": + temp_measurements.append(m) + + # Row 1: blank qc → good + assert temp_measurements[0].quality == "good" + # Row 2: blank qc → good + assert temp_measurements[1].quality == "good" + # Row 3: Y qc → questionable + assert temp_measurements[2].quality == "questionable" + # Row 4: M qc → missing (but value is 999, physically implausible too) + assert temp_measurements[3].quality == "missing" + # Row 5: blank qc → good + assert temp_measurements[4].quality == "good" + + +def test_parse_cimis_fixture_wind_quality_and_range() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE) + wind_measurements = [] + for row in parsed.rows: + for col, m in zip(parsed.schema.measurement_columns, row.measurements, strict=False): + if col.canonical_concept == "wind_speed": + wind_measurements.append(m) + # Row 5 has wind=100 m/s with qc=R (rejected). Source flag is BAD, kept. + assert wind_measurements[4].quality == "bad" + + +def test_parse_cimis_fixture_filter_by_concept_default_quality() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE) + # Filter: temperature >= 30°C = 303.15 K, default quality (good/estimated) + results = filter_rows_by_concept( + parsed, + concept="temperature", + min_value_canonical=303.15, + ) + # Row 2 (35.2 → 308.35, good), row 3 (36.1, questionable - dropped), + # row 4 (999, missing - dropped), row 5 (32.0 → 305.15, good). + # So 2 results expected. + assert len(results) == 2 + raw_values = sorted(r["raw_value"] for r in results) + assert raw_values == [32.0, 35.2] + + +def test_parse_cimis_fixture_filter_relaxed_quality_includes_questionable() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE) + # Allow questionable through too + results = filter_rows_by_concept( + parsed, + concept="temperature", + min_value_canonical=303.15, + acceptable_quality=frozenset( + { + QualityFlag.GOOD, + QualityFlag.ESTIMATED, + QualityFlag.QUESTIONABLE, + } + ), + ) + # Adds row 3 (36.1) and row 4 (999°C → physically implausible → questionable) + raw_values = sorted(r["raw_value"] for r in results) + # Note: 999 C → 1272.15 K, exceeds physical plausibility → questionable + # (source was MISSING though, so still excluded). That's important to + # verify: derive_flag preserves MISSING. + # So we expect: 32.0, 35.2, 36.1 + assert raw_values == [32.0, 35.2, 36.1] + + +def test_parse_cimis_fixture_context_preserved() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE) + # Station and date should be captured in each row's context + for row in parsed.rows: + assert row.context # non-empty + # Either "Stn Name" or "Date" should be captured + context_keys_lower = [k.lower() for k in row.context] + assert any("station" in k or "stn" in k or "date" in k for k in context_keys_lower) + + +def test_parse_empty_csv() -> None: + parsed = parse_scientific_csv("") + assert parsed.rows == () + assert parsed.schema.columns == () + + +def test_parse_csv_header_only() -> None: + parsed = parse_scientific_csv("col1,col2\n") + assert parsed.rows == () + assert len(parsed.schema.columns) == 2 + + +def test_parse_csv_respects_max_rows() -> None: + parsed = parse_scientific_csv(_CIMIS_FIXTURE, max_rows=2) + assert len(parsed.rows) == 2 + + +def test_parse_csv_counts_parse_errors() -> None: + csv = "Air Temp (C),qc\n20.5,\nnot_a_number,\n30.1," + parsed = parse_scientific_csv(csv) + # 3 rows total, 1 has a bad numeric value + assert parsed.parse_errors == 1 diff --git a/clio-agentic-search/tests/unit/test_hdf5_connector.py b/clio-agentic-search/tests/unit/test_hdf5_connector.py new file mode 100644 index 00000000..31e5c334 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_hdf5_connector.py @@ -0,0 +1,193 @@ +"""Tests for HDF5 connector.""" + +from __future__ import annotations + +from pathlib import Path +from unittest.mock import MagicMock, patch + +import pytest + +try: + import h5py + + HAS_H5PY = True +except ImportError: + h5py = None # type: ignore[assignment] + HAS_H5PY = False + + +# --------------------------------------------------------------------------- +# Fake h5py objects for mocking +# --------------------------------------------------------------------------- + + +class _FakeAttrs(dict): + """Dict subclass that behaves like HDF5 attrs (truthy when non-empty).""" + + pass + + +class _FakeDataset: + """Minimal stand-in for h5py.Dataset.""" + + def __init__( + self, + shape: tuple[int, ...] = (100,), + dtype: str = "float64", + attrs: dict[str, object] | None = None, + ) -> None: + self.shape = shape + self.dtype = dtype + self.attrs = _FakeAttrs(attrs or {}) + + +class _FakeGroup: + """Minimal stand-in for h5py.Group.""" + + def __init__(self, attrs: dict[str, object] | None = None) -> None: + self.attrs = _FakeAttrs(attrs or {}) + + +class _FakeFile: + """Minimal stand-in for h5py.File, used as a context manager.""" + + def __init__( + self, + items: dict[str, _FakeDataset | _FakeGroup], + root_attrs: dict[str, object] | None = None, + ) -> None: + self._items = items + self.attrs = _FakeAttrs(root_attrs or {}) + + def visititems(self, func: object) -> None: + for name, obj in sorted(self._items.items()): + func(name, obj) # type: ignore[operator] + + def __enter__(self) -> _FakeFile: + return self + + def __exit__(self, *args: object) -> None: + return None + + +# --------------------------------------------------------------------------- +# Tests +# --------------------------------------------------------------------------- + + +@pytest.mark.skipif(not HAS_H5PY, reason="h5py required for isinstance checks") +def test_extract_hdf5_text_basic_structure() -> None: + """_extract_hdf5_text produces text from groups, datasets, and attributes.""" + from clio_agentic_search.connectors.hdf5.connector import _extract_hdf5_text + + fake_file = _FakeFile( + items={ + "experiment/pressure": _FakeDataset( + shape=(1000,), + dtype="float32", + attrs={"units": "kPa", "long_name": "Static Pressure"}, + ), + "experiment": _FakeGroup( + attrs={"description": "Wind tunnel run 42"}, + ), + }, + root_attrs={"title": "CFD Benchmark"}, + ) + + # Patch h5py.File to return our fake, and h5py.Dataset/Group for isinstance. + with ( + patch("clio_agentic_search.connectors.hdf5.connector.h5py.File", return_value=fake_file), + patch("clio_agentic_search.connectors.hdf5.connector.h5py.Dataset", _FakeDataset), + patch("clio_agentic_search.connectors.hdf5.connector.h5py.Group", _FakeGroup), + ): + text = _extract_hdf5_text(Path("/fake/data.h5")) + + assert "Dataset: /experiment/pressure" in text + assert "Shape: (1000,)" in text + assert "float32" in text + assert "units: kPa" in text + assert "long_name: Static Pressure" in text + assert "Group: /experiment" in text + assert "description: Wind tunnel run 42" in text + # Root attributes + assert "title: CFD Benchmark" in text + + +@pytest.mark.skipif(not HAS_H5PY, reason="h5py required for isinstance checks") +def test_extract_hdf5_text_bytes_attrs_decoded() -> None: + """Byte-string attributes should be decoded to UTF-8.""" + from clio_agentic_search.connectors.hdf5.connector import _extract_hdf5_text + + fake_file = _FakeFile( + items={ + "data": _FakeDataset(attrs={"label": b"encoded-value"}), + }, + ) + + with ( + patch("clio_agentic_search.connectors.hdf5.connector.h5py.File", return_value=fake_file), + patch("clio_agentic_search.connectors.hdf5.connector.h5py.Dataset", _FakeDataset), + patch("clio_agentic_search.connectors.hdf5.connector.h5py.Group", _FakeGroup), + ): + text = _extract_hdf5_text(Path("/fake/data.h5")) + + assert "encoded-value" in text + + +def test_descriptor_returns_hdf5_type() -> None: + """HDF5Connector.descriptor() should report connector_type='hdf5'.""" + from clio_agentic_search.connectors.hdf5.connector import HDF5Connector + + storage = MagicMock() + connector = HDF5Connector(namespace="test-ns", root=Path("/data"), storage=storage) + desc = connector.descriptor() + + assert desc.name == "test-ns" + assert desc.connector_type == "hdf5" + assert "/data" in desc.root_uri + + +@pytest.mark.skipif(not HAS_H5PY, reason="h5py required for isinstance checks") +def test_measurement_extracted_from_attribute_text() -> None: + """Text with 'pressure_value: 250 kPa' should produce measurement metadata via chunking.""" + from clio_agentic_search.connectors.hdf5.connector import _extract_hdf5_text + from clio_agentic_search.indexing.scientific import build_structure_aware_chunk_plan + + fake_file = _FakeFile( + items={ + "sensors/pressure": _FakeDataset( + shape=(500,), + dtype="float64", + attrs={"pressure_value": "250 kPa", "units": "kPa"}, + ), + }, + ) + + with ( + patch("clio_agentic_search.connectors.hdf5.connector.h5py.File", return_value=fake_file), + patch("clio_agentic_search.connectors.hdf5.connector.h5py.Dataset", _FakeDataset), + patch("clio_agentic_search.connectors.hdf5.connector.h5py.Group", _FakeGroup), + ): + text = _extract_hdf5_text(Path("/fake/data.h5")) + + # The extracted text should mention the measurement. + assert "250" in text + assert "kPa" in text or "kpa" in text.lower() + + # When we chunk this text through the scientific pipeline, we should get + # measurement metadata. + plan = build_structure_aware_chunk_plan( + namespace="test", + document_id="doc1", + text=text, + chunk_size=800, + ) + assert plan.chunks + + # Check if any chunk picked up scientific measurement metadata. + all_meta_keys: set[str] = set() + for chunk_meta in plan.metadata_by_chunk_id.values(): + all_meta_keys.update(chunk_meta.keys()) + + has_measurement = any("measurement" in k.lower() for k in all_meta_keys) + assert has_measurement, f"Expected measurement metadata, got keys: {all_meta_keys}" diff --git a/clio-agentic-search/tests/unit/test_metadata_schema.py b/clio-agentic-search/tests/unit/test_metadata_schema.py new file mode 100644 index 00000000..ab8a67b6 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_metadata_schema.py @@ -0,0 +1,257 @@ +"""Unit tests for metadata schema inference and field alignment.""" + +from __future__ import annotations + +from clio_agentic_search.retrieval.metadata_schema import ( + FieldInfo, + _normalise_field_name, + align_field, + build_metadata_schema, + describe_schema, +) + +# --------------------------------------------------------------------------- +# Field name normalisation +# --------------------------------------------------------------------------- + + +def test_normalise_strips_unit_suffix() -> None: + assert _normalise_field_name("Air Temp (C)") == "air_temp" + assert _normalise_field_name("Vap Pres (kPa)") == "vap_pres" + assert _normalise_field_name("Wind Speed (m/s)") == "wind_speed" + + +def test_normalise_lowercases() -> None: + assert _normalise_field_name("TEMPERATURE") == "temperature" + assert _normalise_field_name("RelHum") == "relhum" + + +def test_normalise_handles_empty() -> None: + assert _normalise_field_name("") == "" + assert _normalise_field_name(" ") == "" + + +def test_normalise_collapses_whitespace_and_punct() -> None: + assert _normalise_field_name("Air.Temperature") == "air_temperature" + assert _normalise_field_name("wind-speed-avg") == "wind_speed_avg" + + +# --------------------------------------------------------------------------- +# Field alignment to canonical concepts +# --------------------------------------------------------------------------- + + +def test_align_temperature_variants() -> None: + assert align_field("temperature") == "temperature" + assert align_field("temp") == "temperature" + assert align_field("Air Temp (C)") == "temperature" + assert align_field("T_air") == "temperature" + assert align_field("air_temp") == "temperature" + assert align_field("T2M") == "temperature" + + +def test_align_temperature_excludes_sensor_and_id() -> None: + assert align_field("temperature_sensor_id") is None + assert align_field("temp_station") is None + + +def test_align_pressure_variants() -> None: + assert align_field("pressure") == "pressure" + assert align_field("press") == "pressure" + assert align_field("barometric pressure") == "pressure" + assert align_field("Vap Pres (kPa)") == "pressure" + assert align_field("MSLP") == "pressure" + + +def test_align_humidity_variants() -> None: + assert align_field("humidity") == "humidity" + assert align_field("Rel Hum (%)") == "humidity" + assert align_field("RH") == "humidity" + assert align_field("relative_humidity") == "humidity" + assert align_field("dew_point") == "humidity" + + +def test_align_wind_speed_variants() -> None: + assert align_field("wind_speed") == "wind_speed" + assert align_field("WS") == "wind_speed" + assert align_field("Wind Speed (m/s)") == "wind_speed" + assert align_field("wnd_spd") == "wind_speed" + + +def test_align_wind_direction_not_speed() -> None: + assert align_field("wind_direction") == "wind_direction" + assert align_field("WD") == "wind_direction" + + +def test_align_location_fields() -> None: + assert align_field("latitude") == "latitude" + assert align_field("lat") == "latitude" + assert align_field("longitude") == "longitude" + assert align_field("lon") == "longitude" + assert align_field("lng") == "longitude" + assert align_field("elevation") == "elevation" + assert align_field("altitude") == "elevation" + + +def test_align_quality_field() -> None: + assert align_field("qc") == "measurement_quality" + assert align_field("quality") == "measurement_quality" + assert align_field("qflag") == "measurement_quality" + + +def test_align_unknown_field_returns_none() -> None: + assert align_field("random_gibberish_column") is None + assert align_field("foo") is None + + +def test_align_empty_returns_none() -> None: + assert align_field("") is None + assert align_field(" ") is None + + +def test_align_station_id_distinct_from_temperature() -> None: + # "station" alone should not match any concept (no "station" concept), + # and "station_id" should match station_id concept. + assert align_field("station") is None + assert align_field("stn_id") == "station_id" + assert align_field("station_id") == "station_id" + + +# --------------------------------------------------------------------------- +# build_metadata_schema +# --------------------------------------------------------------------------- + + +def test_build_metadata_schema_empty() -> None: + schema = build_metadata_schema( + namespace="empty", + metadata_rows=[], + total_documents=0, + total_chunks=0, + ) + assert schema.namespace == "empty" + assert len(schema.fields) == 0 + assert len(schema.concepts) == 0 + assert schema.richness_score == 0.0 + + +def test_build_metadata_schema_with_real_cimis_fields() -> None: + # Simulate what we'd get from a CIMIS-derived corpus + rows = [ + ("Air Temp (C)", "chunk", "25.3", 1000), + ("Rel Hum (%)", "chunk", "40", 1000), + ("Wind Speed (m/s)", "chunk", "2.1", 1000), + ("Sol Rad (W/sq.m)", "chunk", "800", 1000), + ("Stn Id", "document", "105", 10), + ("Date", "chunk", "2024-06-01", 1000), + ("random_internal_field", "chunk", "x", 50), + ] + schema = build_metadata_schema( + namespace="cimis", + metadata_rows=rows, + total_documents=10, + total_chunks=1000, + ) + assert schema.namespace == "cimis" + assert len(schema.fields) == 7 + # Detected concepts + assert "temperature" in schema.concepts + assert "humidity" in schema.concepts + assert "wind_speed" in schema.concepts + assert "solar_radiation" in schema.concepts + assert "time" in schema.concepts + assert "station_id" in schema.concepts + # Convenience properties + assert schema.has_temperature_field is True + assert schema.has_pressure_field is False # CIMIS doesn't have it + assert schema.has_quality_field is False + # Richness should be high given multiple concepts + 100% chunk coverage + assert schema.richness_score > 0.5 + + +def test_build_metadata_schema_sparse_corpus() -> None: + # Corpus with only a single low-frequency random field + rows = [ + ("internal_id", "document", "xyz", 1), + ] + schema = build_metadata_schema( + namespace="sparse", + metadata_rows=rows, + total_documents=100, + total_chunks=500, + ) + # Only 1 field, no recognised concept + assert len(schema.fields) == 1 + assert len(schema.concepts) == 0 + assert schema.richness_score < 0.2 + + +def test_schema_fields_for_concept() -> None: + rows = [ + ("Air Temp (C)", "chunk", "25", 1000), + ("temperature", "chunk", "25", 500), # two aliases for the same thing + ("humidity", "chunk", "40", 1000), + ] + schema = build_metadata_schema( + namespace="multi", + metadata_rows=rows, + total_documents=10, + total_chunks=1000, + ) + temp_fields = schema.fields_for_concept("temperature") + assert len(temp_fields) == 2 + assert {f.key for f in temp_fields} == {"Air Temp (C)", "temperature"} + + +def test_describe_schema_returns_serialisable_dict() -> None: + rows = [ + ("Air Temp (C)", "chunk", "25", 1000), + ("humidity", "chunk", "40", 1000), + ] + schema = build_metadata_schema( + namespace="test", + metadata_rows=rows, + total_documents=10, + total_chunks=1000, + ) + description = describe_schema(schema) + assert description["namespace"] == "test" + assert description["distinct_field_count"] == 2 + assert "temperature" in description["concepts"] + assert "humidity" in description["concepts"] + assert len(description["top_fields"]) == 2 + + # Must be JSON-serialisable + import json + + json.dumps(description) # raises if not + + +def test_field_info_construction() -> None: + info = FieldInfo( + key="temperature", + scope="chunk", + occurrences=100, + canonical_concept="temperature", + ) + assert info.key == "temperature" + assert info.canonical_concept == "temperature" + + +def test_richness_score_bounded_0_1() -> None: + # Extreme case: lots of fields, perfect coverage + rows = [(f"field_{i}", "chunk", "x", 1000) for i in range(20)] + [ + ("temperature", "chunk", "25", 1000), + ("humidity", "chunk", "40", 1000), + ("pressure", "chunk", "101", 1000), + ("wind_speed", "chunk", "5", 1000), + ("solar_radiation", "chunk", "800", 1000), + ] + schema = build_metadata_schema( + namespace="rich", + metadata_rows=rows, + total_documents=10, + total_chunks=1000, + ) + assert 0.0 <= schema.richness_score <= 1.0 + assert schema.richness_score > 0.9 # all signals maxed diff --git a/clio-agentic-search/tests/unit/test_mvp_gaps.py b/clio-agentic-search/tests/unit/test_mvp_gaps.py index 2d27f53d..752fe7d5 100644 --- a/clio-agentic-search/tests/unit/test_mvp_gaps.py +++ b/clio-agentic-search/tests/unit/test_mvp_gaps.py @@ -2,6 +2,7 @@ from __future__ import annotations +import sys from pathlib import Path from unittest.mock import patch @@ -171,6 +172,9 @@ def test_no_results_prints_diagnostic( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: + # Force the deterministic hash embedder so the nonsense query yields no + # results regardless of whether the optional `semantic` extra is present. + monkeypatch.setitem(sys.modules, "sentence_transformers", None) docs_dir = tmp_path / "docs" docs_dir.mkdir() (docs_dir / "data.txt").write_text("alpha beta gamma", encoding="utf-8") diff --git a/clio-agentic-search/tests/unit/test_netcdf_connector.py b/clio-agentic-search/tests/unit/test_netcdf_connector.py new file mode 100644 index 00000000..22937db2 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_netcdf_connector.py @@ -0,0 +1,217 @@ +"""Tests for NetCDF connector.""" + +from __future__ import annotations + +from pathlib import Path +from unittest.mock import MagicMock + +import pytest + +# --------------------------------------------------------------------------- +# Helpers: lightweight fake xarray objects +# --------------------------------------------------------------------------- + + +class _FakeVariable: + """Minimal stand-in for an xarray DataArray (variable).""" + + def __init__( + self, + dims: tuple[str, ...] = ("time",), + shape: tuple[int, ...] = (100,), + dtype: str = "float64", + attrs: dict[str, object] | None = None, + values: object = None, + ) -> None: + self.dims = dims + self.shape = shape + self.dtype = dtype + self.attrs = attrs or {} + self.values = values if values is not None else [] + self.size = shape[0] if shape else 0 + + +class _FakeDataset: + """Minimal stand-in for an xarray Dataset.""" + + def __init__( + self, + data_vars: dict[str, _FakeVariable] | None = None, + coords: dict[str, _FakeVariable] | None = None, + dims: dict[str, int] | None = None, + attrs: dict[str, object] | None = None, + ) -> None: + self.data_vars = data_vars or {} + self.coords = coords or {} + self.dims = dims or {} + self.attrs = attrs or {} + + def close(self) -> None: + pass + + +# --------------------------------------------------------------------------- +# Tests for _dataset_to_text (no xarray import needed) +# --------------------------------------------------------------------------- + + +def test_dataset_to_text_basic() -> None: + """_dataset_to_text should render variables, coords, dims, and global attrs.""" + from clio_agentic_search.connectors.netcdf.connector import _dataset_to_text + + ds = _FakeDataset( + data_vars={ + "temperature": _FakeVariable( + dims=("time", "lat", "lon"), + shape=(365, 180, 360), + dtype="float32", + attrs={ + "units": "K", + "long_name": "Air Temperature", + "standard_name": "air_temperature", + }, + ), + }, + coords={ + "time": _FakeVariable(dims=("time",), shape=(365,), dtype="datetime64[ns]"), + "lat": _FakeVariable(dims=("lat",), shape=(180,), dtype="float64"), + }, + dims={"time": 365, "lat": 180, "lon": 360}, + attrs={"title": "ERA5 Reanalysis", "Conventions": "CF-1.8"}, + ) + + text = _dataset_to_text(ds, "era5.nc") + + assert "NetCDF Dataset: era5.nc" in text + assert "Variable: temperature" in text + assert "Units: K" in text + assert "Long Name: Air Temperature" in text + assert "Standard Name: air_temperature" in text + assert "Dimensions:" in text + assert "time: 365" in text + + +def test_dataset_to_text_global_attrs() -> None: + """Standard global attributes should appear in output.""" + from clio_agentic_search.connectors.netcdf.connector import _dataset_to_text + + ds = _FakeDataset( + attrs={ + "title": "Climate Model Output", + "institution": "NCAR", + "source": "CESM2", + "history": "created 2025-01-01", + }, + ) + + text = _dataset_to_text(ds, "model.nc") + + assert "Title: Climate Model Output" in text + assert "Institution: NCAR" in text + assert "Source: CESM2" in text + assert "History: created 2025-01-01" in text + + +def test_dataset_to_text_cf_attributes() -> None: + """CF metadata attributes like cell_methods should be rendered.""" + from clio_agentic_search.connectors.netcdf.connector import _dataset_to_text + + ds = _FakeDataset( + data_vars={ + "precip": _FakeVariable( + attrs={ + "units": "mm/day", + "cell_methods": "time: mean", + }, + ), + }, + ) + + text = _dataset_to_text(ds, "precip.nc") + + assert "Units: mm/day" in text + assert "cell_methods: time: mean" in text + + +# --------------------------------------------------------------------------- +# Descriptor +# --------------------------------------------------------------------------- + + +def test_descriptor_returns_netcdf_type() -> None: + """NetCDFConnector.descriptor() should report connector_type='netcdf'.""" + from clio_agentic_search.connectors.netcdf.connector import NetCDFConnector + + storage = MagicMock() + connector = NetCDFConnector(namespace="climate", root=Path("/data"), storage=storage) + desc = connector.descriptor() + + assert desc.name == "climate" + assert desc.connector_type == "netcdf" + assert "/data" in desc.root_uri + + +# --------------------------------------------------------------------------- +# Measurement extraction through the scientific chunk pipeline +# --------------------------------------------------------------------------- + + +def test_measurement_extracted_from_netcdf_text() -> None: + """Text describing a variable with '250 kPa' should yield measurement metadata.""" + from clio_agentic_search.connectors.netcdf.connector import _dataset_to_text + from clio_agentic_search.indexing.scientific import build_structure_aware_chunk_plan + + ds = _FakeDataset( + data_vars={ + "pressure": _FakeVariable( + dims=("time", "level"), + shape=(100, 37), + dtype="float32", + attrs={"units": "kPa", "long_name": "Atmospheric Pressure"}, + ), + }, + attrs={"title": "Pressure at 250 kPa level"}, + ) + + text = _dataset_to_text(ds, "pressure.nc") + assert "250" in text + assert "kPa" in text or "kpa" in text.lower() + + plan = build_structure_aware_chunk_plan( + namespace="test", + document_id="doc1", + text=text, + chunk_size=800, + ) + assert plan.chunks + + all_meta_keys: set[str] = set() + for chunk_meta in plan.metadata_by_chunk_id.values(): + all_meta_keys.update(chunk_meta.keys()) + + has_measurement = any("measurement" in k.lower() for k in all_meta_keys) + assert has_measurement, f"Expected measurement metadata, got keys: {all_meta_keys}" + + +# --------------------------------------------------------------------------- +# connect() guard +# --------------------------------------------------------------------------- + + +def test_connect_without_xarray_uses_storage(monkeypatch: pytest.MonkeyPatch) -> None: + """NetCDFConnector.connect() should call storage.connect() and succeed + even if xarray is absent (xarray is only needed at index time, not connect).""" + from clio_agentic_search.connectors.netcdf import connector as nc_mod + + storage = MagicMock() + conn = nc_mod.NetCDFConnector( + namespace="ns", + root=Path("/tmp"), + storage=storage, + warmup_async=False, + ) + # connect should call through to storage + conn.connect() + storage.connect.assert_called_once() + conn.teardown() + storage.teardown.assert_called_once() diff --git a/clio-agentic-search/tests/unit/test_production_hardening.py b/clio-agentic-search/tests/unit/test_production_hardening.py index 03b498a1..16073924 100644 --- a/clio-agentic-search/tests/unit/test_production_hardening.py +++ b/clio-agentic-search/tests/unit/test_production_hardening.py @@ -2,6 +2,7 @@ from __future__ import annotations +import sys from pathlib import Path import pytest @@ -38,15 +39,18 @@ def test_default_registry_has_three_namespaces( monkeypatch.setenv("CLIO_LOCAL_ROOT", str(tmp_path)) monkeypatch.setenv("CLIO_STORAGE_PATH", str(tmp_path / "reg2.duckdb")) registry = build_default_registry() - assert len(registry.list_namespaces()) == 3 + assert len(registry.list_namespaces()) == 5 registry.teardown() class TestEmbedderAutoDetect: - def test_falls_back_to_hash_when_no_sentence_transformers(self) -> None: + def test_falls_back_to_hash_when_no_sentence_transformers( + self, monkeypatch: pytest.MonkeyPatch + ) -> None: + # Force the no-sentence-transformers path regardless of whether the + # optional `semantic` extra is installed in this environment. + monkeypatch.setitem(sys.modules, "sentence_transformers", None) embedder = _default_embedder() - # In test environment without sentence-transformers installed, - # should fall back to HashEmbedder assert isinstance(embedder, HashEmbedder) diff --git a/clio-agentic-search/tests/unit/test_quality.py b/clio-agentic-search/tests/unit/test_quality.py new file mode 100644 index 00000000..82541291 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_quality.py @@ -0,0 +1,252 @@ +"""Unit tests for the data-quality layer (indexing.quality).""" + +from __future__ import annotations + +from clio_agentic_search.indexing.quality import ( + QualityFlag, + derive_flag_from_value, + is_physically_plausible, + parse_qc_token, + summarise_quality, +) +from clio_agentic_search.indexing.scientific import ( + Measurement, + decode_measurements, + encode_measurements, +) + +# --------------------------------------------------------------------------- +# QualityFlag enum + string round-trips +# --------------------------------------------------------------------------- + + +def test_quality_flag_from_string_known_values() -> None: + assert QualityFlag.from_string("good") is QualityFlag.GOOD + assert QualityFlag.from_string("bad") is QualityFlag.BAD + assert QualityFlag.from_string("missing") is QualityFlag.MISSING + assert QualityFlag.from_string("questionable") is QualityFlag.QUESTIONABLE + assert QualityFlag.from_string("estimated") is QualityFlag.ESTIMATED + + +def test_quality_flag_from_string_unknown_or_none() -> None: + assert QualityFlag.from_string(None) is QualityFlag.UNKNOWN + assert QualityFlag.from_string("") is QualityFlag.UNKNOWN + assert QualityFlag.from_string("complete gibberish") is QualityFlag.UNKNOWN + + +def test_quality_flag_case_insensitive() -> None: + assert QualityFlag.from_string("GOOD") is QualityFlag.GOOD + assert QualityFlag.from_string(" Bad ") is QualityFlag.BAD + + +def test_quality_flag_is_acceptable() -> None: + assert QualityFlag.GOOD.is_acceptable is True + assert QualityFlag.ESTIMATED.is_acceptable is True + assert QualityFlag.QUESTIONABLE.is_acceptable is False + assert QualityFlag.BAD.is_acceptable is False + assert QualityFlag.MISSING.is_acceptable is False + assert QualityFlag.UNKNOWN.is_acceptable is False + + +def test_quality_flag_numeric_score_ordering() -> None: + # GOOD > ESTIMATED > UNKNOWN > QUESTIONABLE > BAD = MISSING + assert QualityFlag.GOOD.numeric_score > QualityFlag.ESTIMATED.numeric_score + assert QualityFlag.ESTIMATED.numeric_score > QualityFlag.UNKNOWN.numeric_score + assert QualityFlag.UNKNOWN.numeric_score > QualityFlag.QUESTIONABLE.numeric_score + assert QualityFlag.QUESTIONABLE.numeric_score > QualityFlag.BAD.numeric_score + assert QualityFlag.BAD.numeric_score == QualityFlag.MISSING.numeric_score == 0.0 + assert QualityFlag.GOOD.numeric_score == 1.0 + + +# --------------------------------------------------------------------------- +# parse_qc_token — covers CIMIS, NOAA, and common conventions +# --------------------------------------------------------------------------- + + +def test_parse_qc_token_cimis_conventions() -> None: + # CIMIS: blank/nothing = good, Y = questionable, R = rejected/bad, M = missing + assert parse_qc_token("") is QualityFlag.GOOD + assert parse_qc_token(" ") is QualityFlag.GOOD + assert parse_qc_token("Y") is QualityFlag.QUESTIONABLE + assert parse_qc_token("R") is QualityFlag.BAD + assert parse_qc_token("M") is QualityFlag.MISSING + + +def test_parse_qc_token_noaa_conventions() -> None: + assert parse_qc_token("M") is QualityFlag.MISSING + # Generic good cases used by multiple NOAA feeds + assert parse_qc_token("0") is QualityFlag.GOOD + assert parse_qc_token("good") is QualityFlag.GOOD + + +def test_parse_qc_token_missing_sentinels() -> None: + assert parse_qc_token("NA") is QualityFlag.MISSING + assert parse_qc_token("N/A") is QualityFlag.MISSING + assert parse_qc_token("null") is QualityFlag.MISSING + assert parse_qc_token("NaN") is QualityFlag.MISSING + assert parse_qc_token("-9999") is QualityFlag.MISSING + + +def test_parse_qc_token_none_returns_unknown() -> None: + assert parse_qc_token(None) is QualityFlag.UNKNOWN + + +def test_parse_qc_token_unknown_flag_returns_unknown() -> None: + assert parse_qc_token("XYZ") is QualityFlag.UNKNOWN + assert parse_qc_token("123") is QualityFlag.UNKNOWN + + +# --------------------------------------------------------------------------- +# QualitySummary aggregation +# --------------------------------------------------------------------------- + + +def test_summarise_quality_empty() -> None: + summary = summarise_quality([]) + assert summary.total == 0 + assert summary.acceptable_count == 0 + assert summary.acceptable_ratio == 0.0 + assert summary.average_score == 0.0 + + +def test_summarise_quality_mixed() -> None: + flags = [ + QualityFlag.GOOD, + QualityFlag.GOOD, + QualityFlag.GOOD, + QualityFlag.QUESTIONABLE, + QualityFlag.MISSING, + ] + summary = summarise_quality(flags) + assert summary.total == 5 + assert summary.good == 3 + assert summary.questionable == 1 + assert summary.missing == 1 + assert summary.acceptable_count == 3 # only GOOD + ESTIMATED + assert summary.acceptable_ratio == 0.6 + # (3*1.0 + 1*0.25 + 1*0.0) / 5 = 0.65 + assert abs(summary.average_score - 0.65) < 1e-9 + + +def test_summarise_quality_all_good() -> None: + flags = [QualityFlag.GOOD] * 10 + summary = summarise_quality(flags) + assert summary.acceptable_ratio == 1.0 + assert summary.average_score == 1.0 + + +# --------------------------------------------------------------------------- +# Physical plausibility +# --------------------------------------------------------------------------- + + +def test_is_physically_plausible_temperature() -> None: + # Ordinary room temp = 293 K → OK + assert is_physically_plausible("0,0,0,0,1,0,0", 293.15) is True + # Cryo = 77 K (liquid nitrogen) → OK + assert is_physically_plausible("0,0,0,0,1,0,0", 77.0) is True + # Near absolute zero → rejected + assert is_physically_plausible("0,0,0,0,1,0,0", 0.5) is False + # Sun surface-ish → rejected + assert is_physically_plausible("0,0,0,0,1,0,0", 1e6) is False + + +def test_is_physically_plausible_pressure() -> None: + # 1 atm = 101325 Pa → OK + assert is_physically_plausible("1,-1,-2,0,0,0,0", 101325.0) is True + # Deep lab vacuum = 0.001 Pa → rejected by our sanity lower bound + assert is_physically_plausible("1,-1,-2,0,0,0,0", 0.001) is False + # 10 GPa → at the upper edge, OK + assert is_physically_plausible("1,-1,-2,0,0,0,0", 1e9) is True + # 100 GPa → out of range + assert is_physically_plausible("1,-1,-2,0,0,0,0", 1e11) is False + + +def test_is_physically_plausible_unknown_dimension() -> None: + # Dimensions not in the table always pass (we don't constrain them) + assert is_physically_plausible("unknown_dim", 1e20) is True + + +def test_derive_flag_downgrades_out_of_range() -> None: + # Out-of-range value with a GOOD source flag → QUESTIONABLE + assert ( + derive_flag_from_value("0,0,0,0,1,0,0", 1e6, QualityFlag.GOOD) is QualityFlag.QUESTIONABLE + ) + + +def test_derive_flag_preserves_bad() -> None: + # BAD stays BAD even if the value happens to be in range + assert derive_flag_from_value("0,0,0,0,1,0,0", 293.0, QualityFlag.BAD) is QualityFlag.BAD + + +def test_derive_flag_preserves_good_in_range() -> None: + # In-range with GOOD source → stays GOOD + assert derive_flag_from_value("0,0,0,0,1,0,0", 293.0, QualityFlag.GOOD) is QualityFlag.GOOD + + +# --------------------------------------------------------------------------- +# Measurement encode / decode with quality — backward compatibility +# --------------------------------------------------------------------------- + + +def test_measurement_encode_decode_roundtrip_with_quality() -> None: + original = [ + Measurement( + raw_value=30.0, + raw_unit="degc", + canonical_value=303.15, + canonical_unit="0,0,0,0,1,0,0", + quality="good", + ), + Measurement( + raw_value=120.0, + raw_unit="degc", + canonical_value=393.15, + canonical_unit="0,0,0,0,1,0,0", + quality="questionable", + ), + ] + encoded = encode_measurements(original) + decoded = decode_measurements(encoded) + assert len(decoded) == 2 + assert decoded[0].quality == "good" + assert decoded[1].quality == "questionable" + assert decoded[0].canonical_value == 303.15 + assert decoded[1].canonical_value == 393.15 + + +def test_measurement_decode_legacy_4field_format_defaults_unknown() -> None: + # Legacy rows without quality field should parse as "unknown" + legacy_encoded = "0,0,0,0,1,0,0|303.15|degc|30" + decoded = decode_measurements(legacy_encoded) + assert len(decoded) == 1 + assert decoded[0].quality == "unknown" + assert decoded[0].canonical_value == 303.15 + + +def test_measurement_default_quality_is_unknown() -> None: + # Constructing a Measurement without quality → "unknown" + m = Measurement( + raw_value=1.0, + raw_unit="m", + canonical_value=1.0, + canonical_unit="0,1,0,0,0,0,0", + ) + assert m.quality == "unknown" + + +def test_encode_measurements_empty() -> None: + assert encode_measurements([]) == "" + + +def test_decode_measurements_empty() -> None: + assert decode_measurements("") == [] + + +def test_decode_measurements_skips_malformed() -> None: + # Mix of valid and malformed entries + encoded = "0,0,0,0,1,0,0|303.15|degc|30|good;junk;0,1,0,0,0,0,0|5|m|5|bad" + decoded = decode_measurements(encoded) + assert len(decoded) == 2 # "junk" dropped + assert decoded[0].quality == "good" + assert decoded[1].quality == "bad" diff --git a/clio-agentic-search/tests/unit/test_quality_filter_operator.py b/clio-agentic-search/tests/unit/test_quality_filter_operator.py new file mode 100644 index 00000000..a5b5a895 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_quality_filter_operator.py @@ -0,0 +1,184 @@ +"""Tests for QualityFilterOperator integration in retrieval scoring.""" + +from __future__ import annotations + +from clio_agentic_search.indexing.quality import QualityFlag +from clio_agentic_search.indexing.scientific import Measurement, encode_measurements +from clio_agentic_search.retrieval.scientific import ( + NumericRangeOperator, + QualityFilterOperator, + ScientificQueryOperators, + score_scientific_metadata, +) + + +def _metadata_from_measurements(measurements: list[Measurement]) -> dict[str, str]: + return {"scientific.measurements": encode_measurements(measurements)} + + +def test_quality_filter_operator_accepts_defaults() -> None: + op = QualityFilterOperator() + assert op.accepts("good") is True + assert op.accepts("estimated") is True + assert op.accepts("bad") is False + assert op.accepts("questionable") is False + assert op.accepts("missing") is False + assert op.accepts("unknown") is False + + +def test_quality_filter_operator_minimum_score() -> None: + # Custom: accept GOOD only, and require >= 0.9 score + op = QualityFilterOperator( + acceptable=(QualityFlag.GOOD,), + minimum_score=0.9, + ) + assert op.accepts("good") is True + assert op.accepts("estimated") is False # not in whitelist + + +def test_quality_filter_operator_accept_all_flags() -> None: + # Custom: accept every flag including MISSING (for debugging/audit) + op = QualityFilterOperator( + acceptable=tuple(QualityFlag), + ) + for flag in QualityFlag: + assert op.accepts(flag.value) is True + + +def test_quality_filter_operator_handles_raw_string() -> None: + op = QualityFilterOperator() + # Accepts both enum and string forms + assert op.accepts(QualityFlag.GOOD) is True + assert op.accepts("good") is True + + +def test_quality_filter_operator_acceptable_strings() -> None: + op = QualityFilterOperator( + acceptable=(QualityFlag.GOOD, QualityFlag.ESTIMATED, QualityFlag.UNKNOWN), + ) + result = op.acceptable_strings() + assert set(result) == {"good", "estimated", "unknown"} + + +# --------------------------------------------------------------------------- +# Integration: score_scientific_metadata with quality filter +# --------------------------------------------------------------------------- + + +def test_scoring_with_quality_filter_drops_bad_rows() -> None: + # Chunk has one GOOD temperature (35°C) and one BAD temperature (38°C) + measurements = [ + Measurement( + raw_value=35.0, + raw_unit="degc", + canonical_value=308.15, + canonical_unit="0,0,0,0,1,0,0", + quality="good", + ), + Measurement( + raw_value=38.0, + raw_unit="degc", + canonical_value=311.15, + canonical_unit="0,0,0,0,1,0,0", + quality="bad", + ), + ] + metadata = _metadata_from_measurements(measurements) + + ops = ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degc", minimum=34.0, maximum=40.0), + quality_filter=QualityFilterOperator(), # defaults: GOOD/ESTIMATED only + ) + # Should still match because the GOOD row survives the filter + # and falls in [34, 40] degC + score = score_scientific_metadata(metadata, ops) + assert score > 0.0 + + +def test_scoring_with_quality_filter_rejects_all_bad() -> None: + # All measurements are BAD — quality filter removes everything + measurements = [ + Measurement( + raw_value=35.0, + raw_unit="degc", + canonical_value=308.15, + canonical_unit="0,0,0,0,1,0,0", + quality="bad", + ), + Measurement( + raw_value=38.0, + raw_unit="degc", + canonical_value=311.15, + canonical_unit="0,0,0,0,1,0,0", + quality="bad", + ), + ] + metadata = _metadata_from_measurements(measurements) + + ops = ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degc", minimum=34.0, maximum=40.0), + quality_filter=QualityFilterOperator(), + ) + score = score_scientific_metadata(metadata, ops) + assert score == 0.0 + + +def test_scoring_without_quality_filter_matches_legacy_behavior() -> None: + # No quality filter → pre-existing behavior unchanged + measurements = [ + Measurement( + raw_value=35.0, + raw_unit="degc", + canonical_value=308.15, + canonical_unit="0,0,0,0,1,0,0", + quality="bad", # even though bad, no filter → matches + ), + ] + metadata = _metadata_from_measurements(measurements) + + ops = ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degc", minimum=34.0, maximum=40.0), + ) + score = score_scientific_metadata(metadata, ops) + assert score > 0.0 + + +def test_scoring_quality_boost_rewards_good_data() -> None: + # Two chunks, one all-GOOD, one mixed. All-GOOD should score higher. + good_only = [ + Measurement( + raw_value=35.0, + raw_unit="degc", + canonical_value=308.15, + canonical_unit="0,0,0,0,1,0,0", + quality="good", + ), + ] + mixed = [ + Measurement( + raw_value=35.0, + raw_unit="degc", + canonical_value=308.15, + canonical_unit="0,0,0,0,1,0,0", + quality="estimated", # acceptable but lower score + ), + ] + + ops = ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degc", minimum=34.0, maximum=40.0), + quality_filter=QualityFilterOperator(), + ) + score_good = score_scientific_metadata(_metadata_from_measurements(good_only), ops) + score_mixed = score_scientific_metadata(_metadata_from_measurements(mixed), ops) + + assert score_good > score_mixed > 0.0 + + +def test_is_active_with_only_quality_filter() -> None: + ops = ScientificQueryOperators(quality_filter=QualityFilterOperator()) + assert ops.is_active() is True + + +def test_is_active_empty() -> None: + ops = ScientificQueryOperators() + assert ops.is_active() is False diff --git a/clio-agentic-search/tests/unit/test_query_rewriter.py b/clio-agentic-search/tests/unit/test_query_rewriter.py new file mode 100644 index 00000000..7f528764 --- /dev/null +++ b/clio-agentic-search/tests/unit/test_query_rewriter.py @@ -0,0 +1,138 @@ +"""Tests for query rewriting.""" + +from __future__ import annotations + +from clio_agentic_search.retrieval.query_rewriter import ( + FallbackQueryRewriter, + RewriteResult, + _expand_unit_variants, + _parse_llm_response, +) + +# --------------------------------------------------------------------------- +# _expand_unit_variants +# --------------------------------------------------------------------------- + + +def test_expand_unit_variants_pressure() -> None: + """A query containing 'kPa' should expand to include 'pa' and 'mpa'.""" + variants = _expand_unit_variants("pressure 200 kPa") + assert variants # non-empty + lower_variants = {v.lower() for v in variants} + assert "pa" in lower_variants + assert "mpa" in lower_variants + # The original unit itself should NOT appear as an expansion. + assert "kpa" not in lower_variants + + +def test_expand_unit_variants_distance() -> None: + """A query containing 'km' should expand to include 'm', 'cm', 'mm'.""" + variants = _expand_unit_variants("distance 5 km") + lower_variants = {v.lower() for v in variants} + assert "m" in lower_variants + assert "cm" in lower_variants + assert "mm" in lower_variants + assert "km" not in lower_variants + + +def test_expand_unit_variants_no_units() -> None: + """A query with no recognized units should return an empty list.""" + variants = _expand_unit_variants("no units here") + assert variants == [] + + +# --------------------------------------------------------------------------- +# FallbackQueryRewriter.rewrite +# --------------------------------------------------------------------------- + + +def test_fallback_rewriter_with_units() -> None: + """When the query contains units, strategy should be 'expand'.""" + rewriter = FallbackQueryRewriter() + result = rewriter.rewrite( + query="pressure 200 kPa", + retrieved_snippets=["some snippet"], + hop_number=1, + max_hops=3, + ) + assert isinstance(result, RewriteResult) + assert result.strategy == "expand" + assert result.original_query == "pressure 200 kPa" + # The rewritten query should contain additional unit variants. + assert len(result.rewritten_query) > len(result.original_query) + assert "pa" in result.rewritten_query.lower() + + +def test_fallback_rewriter_without_units() -> None: + """When the query has no units, strategy should be 'done'.""" + rewriter = FallbackQueryRewriter() + result = rewriter.rewrite( + query="generic search terms", + retrieved_snippets=[], + hop_number=1, + max_hops=3, + ) + assert result.strategy == "done" + assert result.rewritten_query == "generic search terms" + + +# --------------------------------------------------------------------------- +# _parse_llm_response +# --------------------------------------------------------------------------- + + +def test_parse_llm_response_valid_json() -> None: + """Valid JSON should produce the correct RewriteResult.""" + raw = '{"strategy": "expand", "rewritten_query": "refined query", "reasoning": "added terms"}' + result = _parse_llm_response(raw, original_query="original") + assert result.strategy == "expand" + assert result.rewritten_query == "refined query" + assert result.reasoning == "added terms" + assert result.original_query == "original" + + +def test_parse_llm_response_markdown_fences() -> None: + """JSON wrapped in markdown code fences should be parsed correctly.""" + raw = ( + "```json\n" + '{"strategy": "narrow", "rewritten_query": "focused query", "reasoning": "too broad"}\n' + "```" + ) + result = _parse_llm_response(raw, original_query="original") + assert result.strategy == "narrow" + assert result.rewritten_query == "focused query" + assert result.reasoning == "too broad" + + +def test_parse_llm_response_invalid_json() -> None: + """Unparseable text should return 'done' strategy with original query.""" + raw = "This is not JSON at all." + result = _parse_llm_response(raw, original_query="my query") + assert result.strategy == "done" + assert result.rewritten_query == "my query" + assert "unparseable" in result.reasoning.lower() + + +def test_parse_llm_response_missing_fields() -> None: + """JSON with missing fields should fill in defaults.""" + raw = '{"strategy": "pivot"}' + result = _parse_llm_response(raw, original_query="fallback query") + assert result.strategy == "pivot" + # Missing rewritten_query should fall back to original. + assert result.rewritten_query == "fallback query" + # Missing reasoning should default to empty string. + assert result.reasoning == "" + + +def test_parse_llm_response_invalid_strategy() -> None: + """An unrecognized strategy should be replaced with 'done'.""" + raw = '{"strategy": "invalid_strategy", "rewritten_query": "q", "reasoning": "r"}' + result = _parse_llm_response(raw, original_query="q") + assert result.strategy == "done" + + +def test_parse_llm_response_empty_rewritten_query() -> None: + """An empty rewritten_query should fall back to the original query.""" + raw = '{"strategy": "expand", "rewritten_query": "", "reasoning": "empty"}' + result = _parse_llm_response(raw, original_query="original") + assert result.rewritten_query == "original" diff --git a/clio-agentic-search/tests/unit/test_sample_schema.py b/clio-agentic-search/tests/unit/test_sample_schema.py new file mode 100644 index 00000000..2149a2fe --- /dev/null +++ b/clio-agentic-search/tests/unit/test_sample_schema.py @@ -0,0 +1,354 @@ +"""Tests for active schema inference via sampling (retrieval.sample_schema).""" + +from __future__ import annotations + +import tempfile +from pathlib import Path + +import pytest + +from clio_agentic_search.indexing.scientific import ScientificChunkPlan +from clio_agentic_search.models.contracts import ( + ChunkRecord, + DocumentRecord, + MetadataRecord, +) +from clio_agentic_search.retrieval.corpus_profile import build_corpus_profile +from clio_agentic_search.retrieval.sample_schema import ( + SampledSchema, + sample_and_infer_schema, +) +from clio_agentic_search.storage.contracts import DocumentBundle, FileIndexState +from clio_agentic_search.storage.duckdb_store import DuckDBStorage + +# --------------------------------------------------------------------------- +# Fixtures +# --------------------------------------------------------------------------- + + +@pytest.fixture +def tmp_storage() -> DuckDBStorage: + tmpdir = tempfile.mkdtemp() + storage = DuckDBStorage(database_path=Path(tmpdir) / "sample_test.duckdb") + storage.connect() + yield storage + storage.teardown() + + +def _ingest_plain_chunks( + storage: DuckDBStorage, + namespace: str, + chunks_text: list[str], +) -> None: + """Insert chunks as plain text, deliberately WITHOUT any + scientific.measurements metadata — simulating a dataset ingested as + raw text where structured extraction was never run.""" + bundles: list[DocumentBundle] = [] + for i, text in enumerate(chunks_text): + doc_id = f"doc_{i}" + chunk_id = f"{doc_id}_c0" + doc = DocumentRecord( + namespace=namespace, + document_id=doc_id, + uri=f"synth://{doc_id}", + checksum=f"h{i}", + modified_at_ns=1_000_000 + i, + ) + chunk = ChunkRecord( + namespace=namespace, + chunk_id=chunk_id, + document_id=doc_id, + chunk_index=0, + text=text, + start_offset=0, + end_offset=len(text), + ) + # Only path metadata — no scientific fields + meta = [ + MetadataRecord( + namespace=namespace, + record_id=doc_id, + scope="document", + key="source", + value="synthetic", + ), + ] + file_state = FileIndexState( + namespace=namespace, + path=f"synth/{doc_id}", + document_id=doc_id, + mtime_ns=1_000_000 + i, + content_hash=f"h{i}", + ) + bundles.append( + DocumentBundle( + document=doc, + chunks=[chunk], + embeddings=[], + metadata=meta, + file_state=file_state, + ) + ) + storage.upsert_document_bundles(bundles, include_lexical_postings=False) + + +# --------------------------------------------------------------------------- +# sample_and_infer_schema basic behaviour +# --------------------------------------------------------------------------- + + +def test_sample_empty_namespace(tmp_storage: DuckDBStorage) -> None: + result = sample_and_infer_schema(tmp_storage, "empty_ns", sample_size=10) + assert result.sample_size == 0 + assert result.total_chunks == 0 + assert len(result.concepts_found) == 0 + assert result.measurement_count == 0 + assert result.inferred_density == 0.0 + assert result.has_recoverable_structure is False + + +def test_sample_namespace_with_no_signal(tmp_storage: DuckDBStorage) -> None: + """A namespace with pure prose should yield no recoverable structure.""" + _ingest_plain_chunks( + tmp_storage, + "prose_ns", + [ + "This is a paragraph of prose about nothing in particular.", + "Another paragraph, still no numbers or column names.", + "The quick brown fox jumps over the lazy dog.", + ], + ) + result = sample_and_infer_schema(tmp_storage, "prose_ns", sample_size=10) + assert result.sample_size == 3 + assert result.total_chunks == 3 + assert result.measurement_count == 0 + assert len(result.concepts_found) == 0 + assert result.has_recoverable_structure is False + + +def test_sample_detects_measurements_in_plain_text(tmp_storage: DuckDBStorage) -> None: + """Measurements embedded in prose should be detected by the regex extractor.""" + _ingest_plain_chunks( + tmp_storage, + "measurement_ns", + [ + "The recorded air temperature was 35 degC at noon.", + "Wind speed measured 12 m/s during the storm.", + "A dataset of mostly prose with no numbers here.", + ], + ) + result = sample_and_infer_schema(tmp_storage, "measurement_ns", sample_size=10) + assert result.sample_size == 3 + assert result.measurement_count >= 2 # temp + wind + assert "degc" in result.measurement_units_found or "m/s" in result.measurement_units_found + assert result.chunks_with_signal == 2 + assert result.has_recoverable_structure is True + + +def test_sample_detects_concepts_from_csv_header_lines(tmp_storage: DuckDBStorage) -> None: + """CSV-like headers embedded in chunk text should be aligned to concepts.""" + _ingest_plain_chunks( + tmp_storage, + "csv_ns", + [ + "Stn Id,Stn Name,Date,Air Temp (C),qc,Wind Speed (m/s),qc", + "105,Westlands,2024-06-01,25.3,,3.2,", + "105,Westlands,2024-06-01,26.1,,3.5,", + ], + ) + result = sample_and_infer_schema(tmp_storage, "csv_ns", sample_size=10) + assert "temperature" in result.concepts_found + assert "wind_speed" in result.concepts_found + assert result.has_recoverable_structure is True + + +def test_sample_deterministic_seed(tmp_storage: DuckDBStorage) -> None: + """Same seed → same sample; different seeds → potentially different samples.""" + # Create more chunks than the sample size so the order matters + chunks = [f"Chunk number {i} contains {i * 3} degC measurement." for i in range(30)] + _ingest_plain_chunks(tmp_storage, "det_ns", chunks) + + result_a = sample_and_infer_schema(tmp_storage, "det_ns", sample_size=5, seed=42) + result_b = sample_and_infer_schema(tmp_storage, "det_ns", sample_size=5, seed=42) + assert result_a.sample_chunk_ids == result_b.sample_chunk_ids + + # Different seed → likely different sample + result_c = sample_and_infer_schema(tmp_storage, "det_ns", sample_size=5, seed=99) + # They could coincide on a tiny set, so we don't assert hard inequality. + # At minimum both should be valid samples of size 5. + assert len(result_c.sample_chunk_ids) == 5 + + +def test_sample_bounded_by_size_and_corpus(tmp_storage: DuckDBStorage) -> None: + """If sample_size > chunk count, returns all chunks.""" + _ingest_plain_chunks(tmp_storage, "small_ns", ["a", "b"]) + result = sample_and_infer_schema(tmp_storage, "small_ns", sample_size=100) + assert result.sample_size == 2 + + +def test_sample_storage_without_sample_chunks_method() -> None: + """If the storage adapter doesn't implement sample_chunks, degrade gracefully.""" + + class DummyStorage: + pass + + result = sample_and_infer_schema(DummyStorage(), "ns") # type: ignore[arg-type] + assert result.sample_size == 0 + assert result.has_recoverable_structure is False + + +# --------------------------------------------------------------------------- +# Integration with build_corpus_profile +# --------------------------------------------------------------------------- + + +def test_build_profile_with_sampling_disabled(tmp_storage: DuckDBStorage) -> None: + """enable_sampling=False (default) means no sampled schema even if density is low.""" + _ingest_plain_chunks( + tmp_storage, + "no_sampling", + ["Air temperature 35 degC, pressure 101 kPa."], + ) + profile = build_corpus_profile(tmp_storage, "no_sampling") + assert profile.sampled_schema is None + assert profile.has_sampled_schema is False + + +def test_build_profile_with_sampling_enabled_recovers_measurements( + tmp_storage: DuckDBStorage, +) -> None: + """enable_sampling=True recovers measurements when primary density is low.""" + _ingest_plain_chunks( + tmp_storage, + "recover_ns", + [ + "Air temperature was 35 degC and wind 12 m/s.", + "Pressure measured 101 kPa at sea level.", + "Another chunk with Air Temp (C) column", + ], + ) + # Primary density will be ~0 because we ingested without structured metadata + profile_no_sample = build_corpus_profile(tmp_storage, "recover_ns") + assert profile_no_sample.metadata_density < 0.1 # primary sees nothing + assert profile_no_sample.has_measurements is False + + # With sampling, the same profile recovers measurements and concepts + profile_sampled = build_corpus_profile( + tmp_storage, + "recover_ns", + enable_sampling=True, + sample_size=10, + ) + assert profile_sampled.sampled_schema is not None + assert profile_sampled.sampled_schema.measurement_count > 0 + # has_measurements now returns True because sampled_schema backs it + assert profile_sampled.has_measurements is True + # richness_score reflects the sampled density + assert profile_sampled.richness_score > 0.0 + # Recovered concepts union + assert "temperature" in profile_sampled.recovered_concepts + + +def test_build_profile_sampling_skipped_when_density_already_high( + tmp_storage: DuckDBStorage, +) -> None: + """If the primary density is already high, sampling shouldn't re-scan.""" + # Ingest with real scientific metadata (via the structured pipeline) + from clio_agentic_search.indexing.scientific import build_structure_aware_chunk_plan + + plan: ScientificChunkPlan = build_structure_aware_chunk_plan( + namespace="rich_ns", + document_id="doc_0", + text="The temperature is 25 degC and pressure is 101 kPa.", + chunk_size=200, + ) + # Manually create the document + inject chunks with their metadata + doc = DocumentRecord( + namespace="rich_ns", + document_id="doc_0", + uri="synth://doc_0", + checksum="h", + modified_at_ns=1, + ) + meta_records: list[MetadataRecord] = [] + for chunk_id, chunk_meta in plan.metadata_by_chunk_id.items(): + for k, v in chunk_meta.items(): + meta_records.append( + MetadataRecord( + namespace="rich_ns", + record_id=chunk_id, + scope="chunk", + key=k, + value=v, + ) + ) + file_state = FileIndexState( + namespace="rich_ns", + path="synth/doc_0", + document_id="doc_0", + mtime_ns=1, + content_hash="h", + ) + tmp_storage.upsert_document_bundles( + [ + DocumentBundle( + document=doc, + chunks=plan.chunks, + embeddings=[], + metadata=meta_records, + file_state=file_state, + ), + ], + include_lexical_postings=False, + ) + + profile = build_corpus_profile( + tmp_storage, + "rich_ns", + enable_sampling=True, + ) + # Primary metadata density > threshold → sampled_schema should be None + # (we don't waste the sampling pass) + if profile.metadata_density >= 0.1: + assert profile.sampled_schema is None + + +def test_sample_schema_has_recoverable_structure_flag() -> None: + empty = SampledSchema( + namespace="x", + sample_size=5, + total_chunks=5, + concepts_found=frozenset(), + measurement_units_found=frozenset(), + measurement_count=0, + chunks_with_signal=0, + inferred_density=0.0, + sample_chunk_ids=(), + ) + assert empty.has_recoverable_structure is False + + with_measurements = SampledSchema( + namespace="x", + sample_size=5, + total_chunks=5, + concepts_found=frozenset(), + measurement_units_found=frozenset({"degc"}), + measurement_count=3, + chunks_with_signal=2, + inferred_density=0.4, + sample_chunk_ids=(), + ) + assert with_measurements.has_recoverable_structure is True + + with_concepts = SampledSchema( + namespace="x", + sample_size=5, + total_chunks=5, + concepts_found=frozenset({"temperature"}), + measurement_units_found=frozenset(), + measurement_count=0, + chunks_with_signal=1, + inferred_density=0.2, + sample_chunk_ids=(), + ) + assert with_concepts.has_recoverable_structure is True diff --git a/clio-agentic-search/tests/unit/test_strategy.py b/clio-agentic-search/tests/unit/test_strategy.py new file mode 100644 index 00000000..82ac8bdd --- /dev/null +++ b/clio-agentic-search/tests/unit/test_strategy.py @@ -0,0 +1,136 @@ +"""Tests for branch selection strategy.""" + +from __future__ import annotations + +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile +from clio_agentic_search.retrieval.scientific import ( + NumericRangeOperator, + ScientificQueryOperators, +) +from clio_agentic_search.retrieval.strategy import select_branches + + +def _make_profile( + *, + has_meas: bool = True, + has_form: bool = True, + has_emb: bool = True, + has_lex: bool = True, +) -> CorpusProfile: + return CorpusProfile( + namespace="test", + document_count=10, + chunk_count=50, + measurement_count=5 if has_meas else 0, + formula_count=3 if has_form else 0, + distinct_units=("pa",) if has_meas else (), + distinct_formulas=("f=ma",) if has_form else (), + metadata_density=0.5, + embedding_count=50 if has_emb else 0, + lexical_posting_count=100 if has_lex else 0, + ) + + +def test_no_profile_uses_all_branches() -> None: + """When profile is None, all declared branches are used.""" + plan = select_branches( + query="pressure 200 kPa", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(minimum=200, maximum=400, unit="kPa"), + ), + profile=None, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=True, + connector_has_scientific=True, + ) + assert plan.use_lexical is True + assert plan.use_vector is True + assert plan.use_graph is True + assert plan.use_scientific is True + assert "no corpus profile" in plan.reasoning + + +def test_skip_scientific_when_no_measurements() -> None: + """Scientific branch skipped when corpus has no measurements.""" + profile = _make_profile(has_meas=False) + plan = select_branches( + query="pressure 200 kPa", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(minimum=200, maximum=400, unit="kPa"), + ), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert plan.use_scientific is False + assert "scientific skipped" in plan.reasoning + + +def test_skip_vector_when_no_embeddings() -> None: + """Vector branch skipped when no embeddings indexed.""" + profile = _make_profile(has_emb=False) + plan = select_branches( + query="temperature data", + operators=ScientificQueryOperators(), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert plan.use_vector is False + assert "vector skipped" in plan.reasoning + + +def test_all_branches_when_profile_has_everything() -> None: + """All branches activated when corpus has all data types.""" + profile = _make_profile() + plan = select_branches( + query="pressure 200 kPa", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(minimum=200, maximum=400, unit="kPa"), + ), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=True, + connector_has_scientific=True, + ) + assert plan.use_lexical is True + assert plan.use_vector is True + assert plan.use_graph is True + assert plan.use_scientific is True + + +def test_no_operators_skips_scientific() -> None: + """Scientific branch skipped when no operators in query.""" + profile = _make_profile() + plan = select_branches( + query="general search", + operators=ScientificQueryOperators(), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert plan.use_scientific is False + assert "no operators" in plan.reasoning + + +def test_formula_operator_uses_scientific_when_formulas_exist() -> None: + """Scientific branch activated for formula queries when corpus has formulas.""" + profile = _make_profile(has_meas=False, has_form=True) + plan = select_branches( + query="F=ma", + operators=ScientificQueryOperators(formula="F=ma"), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert plan.use_scientific is True diff --git a/clio-agentic-search/tests/unit/test_strategy_quality_schema.py b/clio-agentic-search/tests/unit/test_strategy_quality_schema.py new file mode 100644 index 00000000..ae2db6ba --- /dev/null +++ b/clio-agentic-search/tests/unit/test_strategy_quality_schema.py @@ -0,0 +1,194 @@ +"""Tests for BranchPlan fields added by the quality + metadata schema layers.""" + +from __future__ import annotations + +from clio_agentic_search.indexing.quality import QualitySummary +from clio_agentic_search.retrieval.corpus_profile import CorpusProfile +from clio_agentic_search.retrieval.metadata_schema import build_metadata_schema +from clio_agentic_search.retrieval.scientific import ( + NumericRangeOperator, + ScientificQueryOperators, +) +from clio_agentic_search.retrieval.strategy import select_branches + + +def _make_profile_with_schema_and_quality( + *, + concepts_in_schema: list[str] | None = None, + quality_acceptable_ratio: float = 1.0, + total_quality_rows: int = 1000, +) -> CorpusProfile: + # Build a schema matching the supplied concepts + if concepts_in_schema is None: + concepts_in_schema = ["temperature", "humidity"] + rows = [(concept, "chunk", "x", 100) for concept in concepts_in_schema] + schema = build_metadata_schema( + namespace="test", + metadata_rows=rows, + total_documents=10, + total_chunks=1000, + ) + + # Build a quality summary with the target acceptable ratio + good = int(total_quality_rows * quality_acceptable_ratio) + bad = total_quality_rows - good + quality = QualitySummary( + total=total_quality_rows, + good=good, + questionable=0, + bad=bad, + missing=0, + estimated=0, + unknown=0, + ) + + return CorpusProfile( + namespace="test", + document_count=10, + chunk_count=1000, + measurement_count=total_quality_rows, + formula_count=0, + distinct_units=("0,0,0,0,1,0,0",), + distinct_formulas=(), + metadata_density=0.8, + embedding_count=1000, + lexical_posting_count=5000, + metadata_schema=schema, + quality_summary=quality, + ) + + +def test_quality_filter_enabled_when_corpus_has_non_good_rows() -> None: + """If the profile shows the corpus has some bad/missing rows, the + quality filter should auto-activate so users get clean results by default.""" + profile = _make_profile_with_schema_and_quality( + quality_acceptable_ratio=0.9, # 10% non-acceptable + ) + plan = select_branches( + query="temperature above 30 celsius", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degC", minimum=30.0), + ), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert plan.use_scientific is True + assert plan.apply_quality_filter is True + assert "quality filter enabled" in plan.reasoning + assert 0.0 <= plan.average_quality <= 1.0 + + +def test_quality_filter_not_enabled_when_corpus_all_good() -> None: + """If every row is GOOD, no filter needed.""" + profile = _make_profile_with_schema_and_quality( + quality_acceptable_ratio=1.0, + ) + plan = select_branches( + query="temperature above 30 celsius", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degC", minimum=30.0), + ), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert plan.apply_quality_filter is False + + +def test_targeted_concepts_picked_from_query() -> None: + """When the query mentions a known concept and the schema has it, it's targeted.""" + profile = _make_profile_with_schema_and_quality( + concepts_in_schema=["temperature", "pressure", "humidity"], + ) + plan = select_branches( + query="Find temperature above 30 degrees celsius", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degC", minimum=30.0), + ), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert "temperature" in plan.targeted_concepts + # Other concepts not mentioned in the query should not be targeted + assert "humidity" not in plan.targeted_concepts + assert "pressure" not in plan.targeted_concepts + + +def test_targeted_concepts_requires_concept_in_schema() -> None: + """If the query mentions a concept but the schema doesn't have it, not targeted.""" + profile = _make_profile_with_schema_and_quality( + concepts_in_schema=["humidity"], # no temperature + ) + plan = select_branches( + query="Find temperature above 30 celsius", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degC", minimum=30.0), + ), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert "temperature" not in plan.targeted_concepts + + +def test_schema_richness_propagated_to_plan() -> None: + profile = _make_profile_with_schema_and_quality( + concepts_in_schema=["temperature", "pressure", "humidity", "wind_speed", "solar_radiation"], + ) + plan = select_branches( + query="anything", + operators=ScientificQueryOperators(), + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + # richness_score should be > 0 when the schema has recognised concepts + assert plan.schema_richness > 0.3 + + +def test_quality_filter_not_enabled_without_scientific_branch() -> None: + """If the scientific branch won't run, the quality filter isn't needed either.""" + profile = _make_profile_with_schema_and_quality( + quality_acceptable_ratio=0.5, + ) + plan = select_branches( + query="free text query with no operators", + operators=ScientificQueryOperators(), # nothing active + profile=profile, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_graph=False, + connector_has_scientific=True, + ) + assert plan.use_scientific is False + assert plan.apply_quality_filter is False + + +def test_profile_none_yields_default_fields() -> None: + plan = select_branches( + query="x", + operators=ScientificQueryOperators( + numeric_range=NumericRangeOperator(unit="degC", minimum=0), + ), + profile=None, + connector_has_lexical=True, + connector_has_vector=True, + connector_has_scientific=True, + ) + # Defaults when profile is missing + assert plan.apply_quality_filter is False + assert plan.targeted_concepts == () + assert plan.schema_richness == 0.0 + assert plan.average_quality == 1.0 diff --git a/clio-agentic-search/uv.lock b/clio-agentic-search/uv.lock index b7608b9b..b92dc205 100644 --- a/clio-agentic-search/uv.lock +++ b/clio-agentic-search/uv.lock @@ -2,9 +2,162 @@ version = 1 revision = 3 requires-python = ">=3.11" resolution-markers = [ - "python_full_version >= '3.13'", - "python_full_version == '3.12.*'", - "python_full_version < '3.12'", + "python_full_version >= '3.14' and platform_machine == 'ARM64' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and platform_machine == 'ARM64' and sys_platform == 'win32'", + "python_full_version >= '3.14' and platform_machine != 'ARM64' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and platform_machine != 'ARM64' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 'ARM64' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 'ARM64' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.12' and platform_machine == 'ARM64' and sys_platform == 'win32'", + "python_full_version < '3.12' and platform_machine != 'ARM64' and sys_platform == 'win32'", + "python_full_version < '3.12' and sys_platform == 'emscripten'", + "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/c6/61a2d7b7572279226bb2e7f61d7a19ca7c90da0329c93fa0d560cbf288d8/aiohappyeyeballs-2.6.2.tar.gz", hash = "sha256:e202810ee718bd01fc6ef49e8ea53d023d5cb6b581076d7925aa499fa55dbe64", size = 22591, upload-time = "2026-05-20T15:12:24.631Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/fc/a7bf5b6e4e617b45f90f2d9d2a68519c249c81dd4fc2658c7a2a61c4f4b7/aiohappyeyeballs-2.6.2-py3-none-any.whl", hash = "sha256:4708045e2d7a6c6bdf8aafa8ed39649eaf926a4543b54560659129e3365953c4", size = 15062, upload-time = "2026-05-20T15:12:23.328Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ee/ab/93ce242f899b68c51b0578c027aafa791ab3614cb9345fa5d37b5f5c8e3e/aiohttp-3.14.0.tar.gz", hash = "sha256:2882de819734c715fd1b9c11c97e09fa020d14438203d1d354d8ed1702791c9b", size = 7940674, upload-time = "2026-06-01T19:41:02.763Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/47/7727bfe8db93f8835a001bd4359d8480cc68d1259b8bce334668f8be97bd/aiohttp-3.14.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:54bf3522d6f7351e55f89a62d5c2bf138ad557b031670266c5df604ae88e0b5a", size = 759147, upload-time = "2026-06-01T19:37:12.918Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f2/cd3fedff6fade73d71df9ec908c210cec518ef90fd00289250684b90aecf/aiohttp-3.14.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0746d9fb0ac4fdef643a84494efe3f06d50335dd8c7a530228b86448aae0a803", size = 513705, upload-time = "2026-06-01T19:37:14.633Z" }, + { url = "https://files.pythonhosted.org/packages/5a/fe/49746b6b610144a06323bebd8e1211a390310d8c69b98dd6d52df341bc3e/aiohttp-3.14.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9f3a96b6d39a4872222beee72e1df41d2ff886ae96152cf3e757ef8c5673ef0e", size = 509627, upload-time = "2026-06-01T19:37:16.385Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3f/28f2f6cf3d5c0e7b01b27140d0e7873fd11fb341169ad3ce78ad04aba628/aiohttp-3.14.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d336820adbb914debbc90a1d8c1bfc4bea55996aecf64866a989d35d1f9fd903", size = 1769293, upload-time = "2026-06-01T19:37:18.067Z" }, + { url = "https://files.pythonhosted.org/packages/97/6f/2e5f1b525d5474b12b3c60abf733a755845f3bceff21542081ada515f837/aiohttp-3.14.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:71b2604c9bfc1b115547d63a094d5244b3f02799833513a99a68aaa7b167c4cb", size = 1732363, upload-time = "2026-06-01T19:37:20.138Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ce/596120faa85ca7b19cd061e3f2f3be23aa8f11a0aedf9191db9e0da1bd76/aiohttp-3.14.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:610d68800435903e303ca0542b9d3e4eb72a12ff33a6d471a070c1d81eebd3c2", size = 1840375, upload-time = "2026-06-01T19:37:22.104Z" }, + { url = "https://files.pythonhosted.org/packages/72/3c/a7ffe05a757a4a7867643da69357ec41f506879fbd1b231d2ed90af246b2/aiohttp-3.14.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:514db9a79337068981ee2137310283a07b4b885c584991097a91a4da419bcb81", size = 1921484, upload-time = "2026-06-01T19:37:24.068Z" }, + { url = "https://files.pythonhosted.org/packages/93/fa/2c861170bbd4a491de93a69e081db1d971092569e0d593a98ef62c384dc1/aiohttp-3.14.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c452d17eeb95d563fc8b936f3050301dbd1d268126c4632d8b70ede9696202ee", size = 1774153, upload-time = "2026-06-01T19:37:26.256Z" }, + { url = "https://files.pythonhosted.org/packages/9d/da/1d2f5a165f47ec9b1f69d37b8b977fdc4d501aa72ffb7930db27bb9e49ea/aiohttp-3.14.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ed94a81506e3d1bdbad5108f497a58f2a2354aedb4ca314d5326f07d1fd1ac2d", size = 1632569, upload-time = "2026-06-01T19:37:28.192Z" }, + { url = "https://files.pythonhosted.org/packages/46/1d/7a6e295c4257252f70f69e90864fdad74b6a1293054fb3f9e65a15de6d63/aiohttp-3.14.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1394dce36e0f0d260ac0b555a654de19cb989f3c1b8bdd24f505314dfea18a00", size = 1740325, upload-time = "2026-06-01T19:37:30.08Z" }, + { url = "https://files.pythonhosted.org/packages/f1/7e/e1899b1ca3ec62f1eab2a5cbde14039b97493f7f53eb88d9b668562ffa8d/aiohttp-3.14.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d1467d1e7b48a73ca7237e0ee4335f3d02b923dbc27b82fd254bc301c97d4026", size = 1748691, upload-time = "2026-06-01T19:37:32.211Z" }, + { url = "https://files.pythonhosted.org/packages/ec/54/4e6b61c1fe7d3433f82bcc6bd7e4d7c683a742a10c9b12a025fd3695c047/aiohttp-3.14.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:6a5f3532125233c261cf61f32df4059cfcf482eb793c7d3db8452e3142028b86", size = 1814477, upload-time = "2026-06-01T19:37:34.173Z" }, + { url = "https://files.pythonhosted.org/packages/9c/38/86fd51be2e08d8e45c83d879d255f10391903cd9fe2a16512f7591a15873/aiohttp-3.14.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3ea81eb518a2ecb319d8ec6d1424a37c773f6634bd87d6985eb606b2faac419f", size = 1623393, upload-time = "2026-06-01T19:37:36.281Z" }, + { url = "https://files.pythonhosted.org/packages/78/49/466e947a42a88ee23c486d036e7e5d1b097f1bafd8084ad9c9a0a92f0f43/aiohttp-3.14.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:32e735c3182de7b64f6941a4ede48b38c7f47d9437bd615dd30b5bda8fa1bc93", size = 1824097, upload-time = "2026-06-01T19:37:38.421Z" }, + { url = "https://files.pythonhosted.org/packages/f3/89/35f3410bc284682338a1be6b6ea0c5abfa05f063942cfaa9256608440434/aiohttp-3.14.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c21ca9a1c63d4509158f478aeb9d02914dcc52adc68d1bc9dee2452284ee5996", size = 1764790, upload-time = "2026-06-01T19:37:40.755Z" }, + { url = "https://files.pythonhosted.org/packages/42/80/2d4291bd5724d3d17e5951aff5a3e02281483fb47295f0788276ee66cd73/aiohttp-3.14.0-cp311-cp311-win32.whl", hash = "sha256:19ca5fc84130675ba11c6ca5c7da5cb65f7bf8a32cdd2b616bf49cd334688aae", size = 454176, upload-time = "2026-06-01T19:37:42.837Z" }, + { url = "https://files.pythonhosted.org/packages/59/ed/41d0ad4f6ececffc32bdf1f7b494e5498f7ca5c849ea2e3cc9bbd1668251/aiohttp-3.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:d488e6e9d3bb8ba5ae7066d5be885ae9670eba021b8c6ccb9a3a568e6b19d6e5", size = 479334, upload-time = "2026-06-01T19:37:44.776Z" }, + { url = "https://files.pythonhosted.org/packages/d1/86/c0b5e305c770053f8c3d069bb52b8196917ba91949d1962d52eb307fb0d2/aiohttp-3.14.0-cp311-cp311-win_arm64.whl", hash = "sha256:8b93618102caf12801638a01a2b478a55410ddd71bd41cfaf6f707953a49ac43", size = 450262, upload-time = "2026-06-01T19:37:46.461Z" }, + { url = "https://files.pythonhosted.org/packages/89/97/2b6889bfb6b6847520d50d95eb8c4307a45e28aaca39faf4a9454b3d1b2f/aiohttp-3.14.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b29518c9c2ec7e373e68259206a137c7f4f5439c58baaec4b5ab3ab799850a4e", size = 750194, upload-time = "2026-06-01T19:37:48.164Z" }, + { url = "https://files.pythonhosted.org/packages/21/e2/62634b7fff918ed98c3c6b2f0e70d520f7f28846cb412d451b04354c6459/aiohttp-3.14.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:dbec68ce61b64cb73cab4d33df9433427b1713c8bcccb181dce695c1b6f8e87c", size = 506966, upload-time = "2026-06-01T19:37:50.014Z" }, + { url = "https://files.pythonhosted.org/packages/dd/fb/5ce075150828c797a5106f1c2fb26034e709d4289b9d2bf8b07f1e59fac6/aiohttp-3.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3cdf534aa455593e589302990c5097aa5c92c06c4262a20da22934f9186a5fff", size = 507527, upload-time = "2026-06-01T19:37:51.96Z" }, + { url = "https://files.pythonhosted.org/packages/01/d5/405a0ae4e6b081754a3609c1c97c63a950e000a2def16046f1e736933a0e/aiohttp-3.14.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb6c657104393b5fbff01a5f59b2023db74058a8077d94475d6c25d03882a108", size = 1762420, upload-time = "2026-06-01T19:37:53.839Z" }, + { url = "https://files.pythonhosted.org/packages/ae/1d/e05a7c896b15a6bc6fb8fc5319eb437861c2c49c34559ef928add6590315/aiohttp-3.14.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:46fbbec4e4fab7428d4396a3823f9320e4560aa3113b89eeebce712c27c9ed5a", size = 1733672, upload-time = "2026-06-01T19:37:55.791Z" }, + { url = "https://files.pythonhosted.org/packages/cc/22/a72f7c459e195fa41bf4f7abd1f925b91fe91f8097e51c654229ba144a33/aiohttp-3.14.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2c2c7e05dd5335b298085abf45ddf98673934c3ee1c083d0b9ea13d4186ad500", size = 1805064, upload-time = "2026-06-01T19:37:57.931Z" }, + { url = "https://files.pythonhosted.org/packages/80/50/e85bdaba0be59ca4838005ebfef4048fcdd5f35a02b07057a9a123394440/aiohttp-3.14.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3c7139100fbaae76515b73051d8f0aa3a3ff02e415eec8a8eee8e2223d9ba955", size = 1902125, upload-time = "2026-06-01T19:38:00.225Z" }, + { url = "https://files.pythonhosted.org/packages/19/d8/51de5c6b971c27bb1ef620293b8d1ca611ec78736b34b3f6ccf68e4c8785/aiohttp-3.14.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78d6f9286a629ce52728430afe18f8ed2b6c39a1fddb3802d7244b9983910ad2", size = 1783112, upload-time = "2026-06-01T19:38:02.641Z" }, + { url = "https://files.pythonhosted.org/packages/73/ae/b4402bfde77e43dfb1b6ccff83c7b7ab63ed06b50c4754f0c5423fb374fe/aiohttp-3.14.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cc3c3e12cdaeb92d7dcf13db00e9f6b1956b910e47256e696df1cfa946d02159", size = 1586356, upload-time = "2026-06-01T19:38:04.637Z" }, + { url = "https://files.pythonhosted.org/packages/bc/05/750a3265ca4dc54a460bd0cb1121a8f2ce9171fce4a135fb47ea7fd594d2/aiohttp-3.14.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4d6a998191f5ebe3b8c28463ff72bc030250008b3193c402464efadd08b5ca02", size = 1723119, upload-time = "2026-06-01T19:38:06.713Z" }, + { url = "https://files.pythonhosted.org/packages/37/01/8c0812c50b3b1b1c37b323bf170d6be8847a8f234060485b7d1e71953f60/aiohttp-3.14.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0fc2b75ae8d169d853be2862d960be8550da6c5c65711d5476407eb3fdb006bd", size = 1757216, upload-time = "2026-06-01T19:38:08.736Z" }, + { url = "https://files.pythonhosted.org/packages/47/2a/50fb98028a26887cbe48dcc1df92a90825615bc73b5584301304090cded8/aiohttp-3.14.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:16eee56bcc72d04600bc56c1759982c2385ec0b41d3fd3521f836bf64a0957ef", size = 1770500, upload-time = "2026-06-01T19:38:11.111Z" }, + { url = "https://files.pythonhosted.org/packages/bd/32/0ffd598a2fa2b9a423daf242e700cfdabda35d6e602394ad9ae58972c1c7/aiohttp-3.14.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5a2e7ca615c3ddc15b82687e05a624e5f5cba3f1d6c20cb81172d70ea498451e", size = 1576224, upload-time = "2026-06-01T19:38:13.391Z" }, + { url = "https://files.pythonhosted.org/packages/0b/f9/b9fc381dd9b66afb33f2634c40e229d106467be0afcabe79648631ab6712/aiohttp-3.14.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:f0b7b8bbbec3ce9467ee0ebe334622fd90624f593edd3136c567811453fc4fae", size = 1794252, upload-time = "2026-06-01T19:38:15.498Z" }, + { url = "https://files.pythonhosted.org/packages/a8/fb/05d9214c975f23225a8cd5c439325e338c7c377b315480ef3871db51f54e/aiohttp-3.14.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5ba10966d4f03dd96a14365be4b8e37c327c76f11c3ca867116966cdd9f98066", size = 1760193, upload-time = "2026-06-01T19:38:17.624Z" }, + { url = "https://files.pythonhosted.org/packages/d9/4b/02992fc4fb9e1b6673ee3f888a8e587a6447afda1f6f4aca776c148c2876/aiohttp-3.14.0-cp312-cp312-win32.whl", hash = "sha256:101df7779c80c0636014a6b2c6642acd3efb5b355d48347c9d7dfb720aee9430", size = 448650, upload-time = "2026-06-01T19:38:19.545Z" }, + { url = "https://files.pythonhosted.org/packages/39/e9/246532214c3abda518477cbaaf16d420295ad8effa5233844cbb38f299ab/aiohttp-3.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:b0a5747586d4467efd1f932710b269131c9717a872dce082cd92a00c1c13123a", size = 476145, upload-time = "2026-06-01T19:38:21.505Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c3/63f8c20090048915711598b0adf475b149216d736157961de06480a45b15/aiohttp-3.14.0-cp312-cp312-win_arm64.whl", hash = "sha256:5f1c5be60add78fabb4aacd13c5a348ae79d2fcbfc7fa78da8f1eb192273b370", size = 444250, upload-time = "2026-06-01T19:38:24.027Z" }, + { url = "https://files.pythonhosted.org/packages/21/61/d11f7d9a3144bffe825247d6367cd93053666da50b94707c9129c78868d5/aiohttp-3.14.0-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:25400d710641a8040bf022a8a99f579e581ffa1c5bd42c33255d7d6f3957c127", size = 502399, upload-time = "2026-06-01T19:38:25.955Z" }, + { url = "https://files.pythonhosted.org/packages/4f/9b/a7e317625d36356844f8bb022cabd305b541f968856cc3c2e0b58e53ee6e/aiohttp-3.14.0-cp313-cp313-android_21_x86_64.whl", hash = "sha256:c5492b9929826e07cc3fcb9739ae87aab05dff6b5e67a9b73fd1700c6d008981", size = 510068, upload-time = "2026-06-01T19:38:27.828Z" }, + { url = "https://files.pythonhosted.org/packages/11/41/cc2d2cfbfbdc3126ba258f3cd27d1ac8a33492ae3c35a4583ee21f0ba7f1/aiohttp-3.14.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3366751d68d237c621264233a32f3078bbc21b7904ab90a77e03d21390c742c6", size = 481670, upload-time = "2026-06-01T19:38:29.836Z" }, + { url = "https://files.pythonhosted.org/packages/3c/07/381f4023c3b08cb616e520f566d8c58957abad54e56441d41fe67cfb0195/aiohttp-3.14.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:57ea07d28695a7a40304d42251892a8df765e5588c10ee32afeddcd5df33c0a2", size = 487591, upload-time = "2026-06-01T19:38:31.704Z" }, + { url = "https://files.pythonhosted.org/packages/fb/4d/4506fdb7a022bdf70011a3bbb4ca00c5c570026ef6a3c5bd7bc70c39089c/aiohttp-3.14.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:076cb014191ae2e65d949e1ad01f1dcfe33e32789b5172510f3e79c79fc04d50", size = 496503, upload-time = "2026-06-01T19:38:33.6Z" }, + { url = "https://files.pythonhosted.org/packages/ef/7d/c814111e04894a45d9e2defc94443879a6f118d9633d5fedfe6e2e8af5f0/aiohttp-3.14.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2f3fc37054564dee64a855b5b092d87ec35dcddfaabf7dacb1c8a2b1f83dc0a9", size = 745870, upload-time = "2026-06-01T19:38:36.013Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ee/80eee0efddfe187e7cd05027086b7ce1c0e492e82a4eda58f5c5543a44a0/aiohttp-3.14.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8fcaef74d2ab0f607d7ff85a0d15e21bb5a258c4a58df1908396eb50d7f4ed3c", size = 505588, upload-time = "2026-06-01T19:38:38.282Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f8/0f28f04eef75d52fc9c715dde7ce9c0abb810fd20cfeb0fea7afd2ab1e98/aiohttp-3.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e4c01b0bfc6209590960e68eac083cd22d5d87c21f974dd6208cafa5d3542bc8", size = 504492, upload-time = "2026-06-01T19:38:40.611Z" }, + { url = "https://files.pythonhosted.org/packages/ff/db/44c755232085545065c94378dfce38641b1aee647f4939fcd32f5b32e719/aiohttp-3.14.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f12eb7896e81caf403a2b18c9406426f1207361e7239c057ab29c076d4257e83", size = 1752111, upload-time = "2026-06-01T19:38:42.682Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6a/42e030a46743841414402a3b00cd3d78419055e86c66fb5822c14b5abfc6/aiohttp-3.14.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6c79a044cacf360ec46738d863d2f41c9300d2a06ef4a7402ea0df306a350e61", size = 1729674, upload-time = "2026-06-01T19:38:44.79Z" }, + { url = "https://files.pythonhosted.org/packages/34/26/3199beb415202e3108e7b83ecebe10914d806d33fb9860c3e4aa60a19be3/aiohttp-3.14.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:85e0675f47be4eff0636bf88c02140ea89168ae0df3ff1f3f464e9de9610d277", size = 1798808, upload-time = "2026-06-01T19:38:47.01Z" }, + { url = "https://files.pythonhosted.org/packages/bd/94/b9b6fcf0ee17c21d0d19fb8c22bf83ad18f82e702a9c3bd901a868f5e446/aiohttp-3.14.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7b33e751cab03fdc960095b1e326cb5a03f5ee577d6ded59f3d1c100f8668882", size = 1891921, upload-time = "2026-06-01T19:38:49.233Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a3/3800dbd095cb2bb165a7ea5d94d790914677e27f45638c7d80e3f34c8945/aiohttp-3.14.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26d9224c6dd7f5c749aba4f61315a894601448b28d94d12f4dea0903e26d2096", size = 1777241, upload-time = "2026-06-01T19:38:52.04Z" }, + { url = "https://files.pythonhosted.org/packages/21/2a/45be91ad1b860508557448d4cc2e165a2ee68dd865657b73bf66cc5a00fb/aiohttp-3.14.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6281aecdf2732940f4fe06bd6adec5ae4d59b78b080b8e3a6b81467301010988", size = 1579554, upload-time = "2026-06-01T19:38:54.508Z" }, + { url = "https://files.pythonhosted.org/packages/b4/3d/dc94df99ed1511fdf28314f722643ed334112643cab00223577085e788c4/aiohttp-3.14.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:23e8314e7aed8576fbe33314d218bd81447a3adbc91dc36f1163bf583cd3084c", size = 1714864, upload-time = "2026-06-01T19:38:56.788Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e4/1f1c8acbb3acd5c8f795473b92c9c3d44eb60a5692c6104256c8a1c83a0c/aiohttp-3.14.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3b54fbff46127aeafdd764cecd0d99fa2f24a0e37ea5c18a7c3a4ac450df1db3", size = 1749803, upload-time = "2026-06-01T19:38:59.367Z" }, + { url = "https://files.pythonhosted.org/packages/0b/c8/c45ea6e7ed84cebba939b9c334498a045ba19d79c61b0110df5f21580de3/aiohttp-3.14.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b27d89af91a555f58e08e4902dbcbc48862fd40095720ca705990476bd93b7ac", size = 1765023, upload-time = "2026-06-01T19:39:01.651Z" }, + { url = "https://files.pythonhosted.org/packages/a8/a1/a932941784432962fe390e1066823aaef64b4e5ac9fa595df57b5fe472a9/aiohttp-3.14.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:25d2326a4967bf705a9f9913a13005e93b6020ad8a9f6bd6bd78850d5171332e", size = 1571671, upload-time = "2026-06-01T19:39:04.044Z" }, + { url = "https://files.pythonhosted.org/packages/b0/01/e1280feac522597a4d46eb67a0cdfa053cfae263033030b761ab146f29fb/aiohttp-3.14.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:a1d209375c503472b3c0a340cdf3c55fcd82e84b46dda7caeaced59faba373ec", size = 1789904, upload-time = "2026-06-01T19:39:06.294Z" }, + { url = "https://files.pythonhosted.org/packages/fa/10/ab28818262f4d26bdb47ed5f1fc7999b69e2fc6e0370b02d0f49011f45ea/aiohttp-3.14.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:666c7c5036df57b693026398b69b41874a1931ac5b3485fd910e57bfac253869", size = 1754516, upload-time = "2026-06-01T19:39:08.788Z" }, + { url = "https://files.pythonhosted.org/packages/af/cc/c122eabd7a1b7e0c9bbdd6be60e4715905b858399145d9df872bb94f1427/aiohttp-3.14.0-cp313-cp313-win32.whl", hash = "sha256:23f094a1ef64823fd35854ddf5c7a80a078162f37f9d2f7c6142b51a6affa456", size = 448656, upload-time = "2026-06-01T19:39:11.171Z" }, + { url = "https://files.pythonhosted.org/packages/41/a5/bab07d79848a00eedd8ed979ccb302aaea3ac6eb9fa16bd0ed87135869b4/aiohttp-3.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:e03abdaa17d553f17e1d1d06bb266b3970106c78051d06795723e748d8e49d11", size = 475803, upload-time = "2026-06-01T19:39:13.439Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a0/f03ade8566c153666a3871afccbedf6d99911da006325e1fc6cf72a2de99/aiohttp-3.14.0-cp313-cp313-win_arm64.whl", hash = "sha256:acdb400538cf4769543548bb5d1eb23d39bed4f96554a6078cb728c7cb2c268b", size = 443889, upload-time = "2026-06-01T19:39:15.945Z" }, + { url = "https://files.pythonhosted.org/packages/28/03/5f36ab196a88ba5e9648ae5643e6531e67a3a8c0e96f9c6510ff41540fec/aiohttp-3.14.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:363ef9e91014e7891679bfb2ac0a7c6ea93435dbbfd10ecf41b9f06fcf506c5f", size = 503330, upload-time = "2026-06-01T19:39:18.195Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ce/8b49ec2f30f68e02f314f4832186cd45e583360a5a386058be36855d23b6/aiohttp-3.14.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:884a4edbdad77be9d0ef36142c8b504351b170df0bf62b51e784fadabf311c42", size = 509822, upload-time = "2026-06-01T19:39:20.396Z" }, + { url = "https://files.pythonhosted.org/packages/1a/fe/6edbf5d39bf29322b6816365b17ed8ede4dace164a3aea1abcd30110eb78/aiohttp-3.14.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:70ea956f6cc4a37620966b56c2e205d88ca3e6d85ec063277e414b1035cddad3", size = 483329, upload-time = "2026-06-01T19:39:22.607Z" }, + { url = "https://files.pythonhosted.org/packages/1b/5a/fae531bdbc6456fb6241f46b7b81e4d8a0dd3fc09118a0055dc7141ac1ec/aiohttp-3.14.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:ea3b9806c89f61da22fddf1f12dd524fb368e5e28f1261fbdafe5c3cd8ce893b", size = 489502, upload-time = "2026-06-01T19:39:24.881Z" }, + { url = "https://files.pythonhosted.org/packages/36/f4/48a7b0414db7fed77a03d5dde34508c026afd83510ab6bca08c313855776/aiohttp-3.14.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a071be341c2bd9b0188e62d173509f024e0a35b1c342c53c50f8daaeda8c3bd8", size = 497357, upload-time = "2026-06-01T19:39:27.197Z" }, + { url = "https://files.pythonhosted.org/packages/75/75/e85a13a370acc007fca5feb1fd1b88ac2d8426e6dadd625479b7cadd55a3/aiohttp-3.14.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:198cfe61bf253b19da1fb3e0fa122249dc4f14c12709493fed8054aa0411cc76", size = 750898, upload-time = "2026-06-01T19:39:29.563Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e4/3d637f800c724eff0e2bed64df72557444482366fd0a35b0cec0e6968f6c/aiohttp-3.14.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9dc203d6ce6b9106d54e2a93f41dfdfebfbca2d99962ba503bfd3e5921a6549e", size = 506986, upload-time = "2026-06-01T19:39:31.872Z" }, + { url = "https://files.pythonhosted.org/packages/1d/df/35161f3598bf7501d2b2a805b41ab4f45a2e34150c421bcb4ef8c0d281a7/aiohttp-3.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9e19d17ab02bf16832a2c8c0d55a486792c5b1645665652ee9531aebcc30cb72", size = 508033, upload-time = "2026-06-01T19:39:34.137Z" }, + { url = "https://files.pythonhosted.org/packages/e5/39/b36e5d3d31e850fb4691dd3e941684ac490a2559249f6fa634b6b0fdf020/aiohttp-3.14.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d925fba0c14d5b498a8028b0107beebdfd16c5d48d702ff54f879cb017aaaca3", size = 1746213, upload-time = "2026-06-01T19:39:36.654Z" }, + { url = "https://files.pythonhosted.org/packages/b1/28/24e1409e605a9aa5d84abe0e2acb365354b70ae56d40948101cabe3341ab/aiohttp-3.14.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d33e61021222ce7f9792bcac870d6f58d8adfceda33ab857b01264f4560f2c5f", size = 1705862, upload-time = "2026-06-01T19:39:38.968Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d0/e5eb3ff1daeaf644c7e36a957517672494122628e067c38b263fa04eda77/aiohttp-3.14.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:44eca38755d0105bb32f47d085f5dd449846a449e1245fc105889e3279dcf8e3", size = 1798909, upload-time = "2026-06-01T19:39:41.334Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ba/8943f906f0570342886ababb9a722a44e360f786a028c5e0b0e29e3f735b/aiohttp-3.14.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f13087e06f68fea4941c21a0c541c00553aa16e4f8fd7bbe2b198df761e964d6", size = 1868892, upload-time = "2026-06-01T19:39:43.807Z" }, + { url = "https://files.pythonhosted.org/packages/3a/05/27df32c844b2156e1675a8d8ec22d963e3c8ba469ed7ceb1863320c7b521/aiohttp-3.14.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff82be7f1ef73634cb77890a770743239bc3d487b848669be1c599889336dc0a", size = 1751659, upload-time = "2026-06-01T19:39:46.398Z" }, + { url = "https://files.pythonhosted.org/packages/7f/62/da182e5910ab912b2e88aa919b61a16046a37a95714a5795b02eb57b2d18/aiohttp-3.14.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a150c0875ac8fd87f1c398650841308a30d65facf7416b12dbdb9cfdcbe5a48c", size = 1578775, upload-time = "2026-06-01T19:39:48.902Z" }, + { url = "https://files.pythonhosted.org/packages/66/e3/53c67097e8a5ce98625e91e3fa7f43c9c6940de680345d03b3509a72a078/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:edc01ea4e1ec5a1649a28866262bf24195889ff7b27bdd947029a6086741de9b", size = 1710090, upload-time = "2026-06-01T19:39:51.392Z" }, + { url = "https://files.pythonhosted.org/packages/dd/55/0e2732ca598c7a4dfe8a775662376d0ca2977cb1030e48386d4da5d9a456/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:540632bf882ff8fc88f2e1697be0761578e89e0d79fb4a8a6d65dc5da7e729d4", size = 1715016, upload-time = "2026-06-01T19:39:53.807Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/f0b73730798c9ca525afc30b39f1f81bbe24e245d9654c54d3b39d63212d/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:860a86bc2c80237f5dff52edcf427e10a8d8352271fd84845429a3e60199e02c", size = 1763810, upload-time = "2026-06-01T19:39:56.31Z" }, + { url = "https://files.pythonhosted.org/packages/71/cc/11acb6c4518f448323405a7312b6f255d0f974a34373ad1db7633c4aadc8/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5cbd50e6a50d6b99283a826b18cbdebf65b0797689a7535cb0e9dd37be0f63c3", size = 1573064, upload-time = "2026-06-01T19:39:58.718Z" }, + { url = "https://files.pythonhosted.org/packages/de/2d/28c31dde0a7dc98c0ee7d0da2ddcec3f7688c4fc131e5989e278d0c03c0a/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:20144819e99db593e22bbd2f3f2691a5e149f879142d6b8670254708853ff4fb", size = 1775765, upload-time = "2026-06-01T19:40:01.195Z" }, + { url = "https://files.pythonhosted.org/packages/b8/69/155c4ef3aec96417d47024800472b33b16c5d8a665371dcd044c2afdf25d/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:26b6d79aa54cb4ed50cc7d41ed14e99e0f1fc8e7c2d42f2e05b37aea897b2b52", size = 1733716, upload-time = "2026-06-01T19:40:03.631Z" }, + { url = "https://files.pythonhosted.org/packages/5f/44/6126116fd8a316b712bb615660b855c78466bb67ba1bb1742427eafcf7ac/aiohttp-3.14.0-cp314-cp314-win32.whl", hash = "sha256:106ed074a856f3e21d186b8579e2c8afb6da598e267cdaab01059e13db2fc44d", size = 453684, upload-time = "2026-06-01T19:40:06.277Z" }, + { url = "https://files.pythonhosted.org/packages/a2/d7/eff4c58a88c5cac5e38b55f44fb8a6d3929c3cbd77356e383e094d3220bd/aiohttp-3.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:4f770846edae8f00ecc57af825bce811f787f87a7dcf0e90d191790efe5b31f7", size = 481758, upload-time = "2026-06-01T19:40:08.653Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ed/17b5bd9fbcb46e688f02e572f517754a9a75831e7b54702f027761dc4fa5/aiohttp-3.14.0-cp314-cp314-win_arm64.whl", hash = "sha256:acf1581c4f21ed4b80a2dded504d87b055a071a84d5737ea966435f768275ac6", size = 450557, upload-time = "2026-06-01T19:40:11.03Z" }, + { url = "https://files.pythonhosted.org/packages/12/34/6180103ce9aabc8ebff3f7bb55a1228ffe60f61042823031d9692cb7b101/aiohttp-3.14.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6aa1a40f9cbb3da9f80714c5966b8946c21e6a2530d809b9498b33161e3c8733", size = 787878, upload-time = "2026-06-01T19:40:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/92/e9/08954a40e8b7baa3d8beadd2b074b186e9b1e9c8ddabc288678a6265de50/aiohttp-3.14.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b62af5a8cc96a194eaa01a9ed7b34a3ffa58d3d8daaa1a0d7a749353ad12d228", size = 524400, upload-time = "2026-06-01T19:40:15.972Z" }, + { url = "https://files.pythonhosted.org/packages/08/6a/b5965a634ac4d5ba99a463314cf4ab214ca073fcdc38a15e0294273701fc/aiohttp-3.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6eb63b1417efaf7d1002a6ad034a40d44376afcc16508a57f8e74b49ad26a095", size = 527904, upload-time = "2026-06-01T19:40:18.28Z" }, + { url = "https://files.pythonhosted.org/packages/06/b4/932bcdd850c354d9bcca30f360e475d7852e30413fbbd44b182782ed5432/aiohttp-3.14.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c20b9ad156a79eb97be5cf9e069eec01d2f0dc8472ffbd75299a8b2d4c2cbbde", size = 1912162, upload-time = "2026-06-01T19:40:20.825Z" }, + { url = "https://files.pythonhosted.org/packages/c6/85/ce79bab0310d2e3fd2d7bc7e44412abeff7c8338f8a21dd0f2f1714989e5/aiohttp-3.14.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:40ae7b0642c25632c7eabc4a04754012691864d2a1b93becf7cddb76027b838a", size = 1778813, upload-time = "2026-06-01T19:40:23.726Z" }, + { url = "https://files.pythonhosted.org/packages/05/54/ba62ac2d1bc87e010aad23751e383b8794e45d931df67677313a2da78823/aiohttp-3.14.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:95f5217e76a046b9f228a101717ef8d42b1eb3d9d196d15202db5bf41df88936", size = 1899969, upload-time = "2026-06-01T19:40:26.406Z" }, + { url = "https://files.pythonhosted.org/packages/dc/82/7cc7907725d83a19f31551334061e1ab8e108b1d7ac52632a2a844a4acb5/aiohttp-3.14.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1a4a9f17e85b80878c176695c1998c790e83731d8271881e5d356488652a1f9e", size = 1991771, upload-time = "2026-06-01T19:40:29.061Z" }, + { url = "https://files.pythonhosted.org/packages/d0/1c/a57de71a4508c93a830b77c28af3d08cd97f606dedfc6b94275347744508/aiohttp-3.14.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:145262119b07d7f95abc1839add35ba2bfc84551d4b4660ca11542c0b215455b", size = 1868606, upload-time = "2026-06-01T19:40:31.843Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ae/3839726cd49150a53ed340cc24ce5ba09d4c2117020ef9d45542bec5eb2f/aiohttp-3.14.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:49a33ded29b0b2fa7a367a02cf0fb89af602bb87542a16177ec8ce1c9c51d12a", size = 1665437, upload-time = "2026-06-01T19:40:35.01Z" }, + { url = "https://files.pythonhosted.org/packages/35/1e/c237923232c7da7f0392ea25d89fc5e60c0e93f685f4ebca8e7bcdd5271c/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2cc736a9c9fc2bc4dd71fd404815741b6573df27c3f985948ec4076989ac57de", size = 1834090, upload-time = "2026-06-01T19:40:37.733Z" }, + { url = "https://files.pythonhosted.org/packages/98/02/a5a7a2524f92d3911761b405a7c067c751891942144adc13e2ad79611e39/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b4141a3e5342ee3053a9cab54d25b64ed28289c1041e4c54b3d99839314d90ce", size = 1816907, upload-time = "2026-06-01T19:40:40.46Z" }, + { url = "https://files.pythonhosted.org/packages/fa/76/a8b9f0d09234d516af9f2d7dd715557f33b5da3b0b56ead41d1170e86e3c/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e30871b2d58996cb81aac52d2b1d15ac05257131ef0f90f18c2115a380fbfe7c", size = 1840382, upload-time = "2026-06-01T19:40:43.48Z" }, + { url = "https://files.pythonhosted.org/packages/c9/8e/140e715a0a4bbc211979ea30ec8396ad2ed5bf90ab87d8058fc4668b1923/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:667b881d083ccae3900ea5a241e17e5007ca78844c53ed389bb63d48f729d9c7", size = 1659497, upload-time = "2026-06-01T19:40:46.265Z" }, + { url = "https://files.pythonhosted.org/packages/10/c7/7ba5de8af9650b9767b063c675427b8685f43fa7ce563673a7bc3af60f08/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:b584dfe615d151e9b8f0a8ecb3aee6147f2927ec5b95ba25fe621f5377510928", size = 1870829, upload-time = "2026-06-01T19:40:49.583Z" }, + { url = "https://files.pythonhosted.org/packages/cc/bc/2aaab2f85cadb26ea59c091fa2b8e370d625154b5c14b478f1b489d07551/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6199707cc40e0e9cd39c36fbc97bec416c704e1d0ddce03412bb3b3e6a90ccd0", size = 1832281, upload-time = "2026-06-01T19:40:52.303Z" }, + { url = "https://files.pythonhosted.org/packages/39/98/31b9ad9fbc01f0075ee7221002df5fd2d10b647f451ca5f30edc802d9dd6/aiohttp-3.14.0-cp314-cp314t-win32.whl", hash = "sha256:a8d93334d4961c9d566b1f046c81dee475b7c21eb730728d38237bfa70d1c8e6", size = 490597, upload-time = "2026-06-01T19:40:54.937Z" }, + { url = "https://files.pythonhosted.org/packages/59/1f/299b21441c8de42ff70fddc7cfe65e92f810abcf740739a09b56f7835364/aiohttp-3.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2d2ffe9b614f50f069068b3b52e73414e4107fc10b7efc939a76acff9251fdd2", size = 525789, upload-time = "2026-06-01T19:40:57.306Z" }, + { url = "https://files.pythonhosted.org/packages/70/11/7f83fcba9ee05d4c54d61b3f8104da0d43a59adac44dd28effc0c9a10422/aiohttp-3.14.0-cp314-cp314t-win_arm64.whl", hash = "sha256:7a3fc4358e65826c515350f199c210de747cf669998211b1ee6c2e46de364b24", size = 467399, upload-time = "2026-06-01T19:40:59.993Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, ] [[package]] @@ -25,6 +178,25 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, ] +[[package]] +name = "anthropic" +version = "0.105.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "docstring-parser" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/46/47581b8c689c743ceabf6a0f9ff48472160900ce802d26c0fb50423997b3/anthropic-0.105.2.tar.gz", hash = "sha256:0e26b90841c2dced7cc6e98d21d5517d0be33f1876b8e779f478202e28bcaa07", size = 853789, upload-time = "2026-05-29T00:21:14.104Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/75/be0c357e33a5a56c8f9db5b4212f886138d2bf59c0952d858f6b75d710ef/anthropic-0.105.2-py3-none-any.whl", hash = "sha256:e53ed5f6bf36fb1ecb9b25d8634cfd30e02fab9fb3374a0c2d5c585874757230", size = 837507, upload-time = "2026-05-29T00:21:15.528Z" }, +] + [[package]] name = "anyio" version = "4.12.1" @@ -38,6 +210,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" }, ] +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + [[package]] name = "build" version = "1.4.0" @@ -61,6 +242,76 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" }, ] +[[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/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { 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" @@ -70,6 +321,69 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, ] +[[package]] +name = "cftime" +version = "1.6.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/65/dc/470ffebac2eb8c54151eb893055024fe81b1606e7c6ff8449a588e9cd17f/cftime-1.6.5.tar.gz", hash = "sha256:8225fed6b9b43fb87683ebab52130450fc1730011150d3092096a90e54d1e81e", size = 326605, upload-time = "2025-10-13T18:56:26.352Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/f6/9da7aba9548ede62d25936b8b448acd7e53e5dcc710896f66863dcc9a318/cftime-1.6.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:474e728f5a387299418f8d7cb9c52248dcd5d977b2a01de7ec06bba572e26b02", size = 512733, upload-time = "2025-10-13T18:56:00.189Z" }, + { url = "https://files.pythonhosted.org/packages/1f/d5/d86ad95fc1fd89947c34b495ff6487b6d361cf77500217423b4ebcb1f0c2/cftime-1.6.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ab9e80d4de815cac2e2d88a2335231254980e545d0196eb34ee8f7ed612645f1", size = 492946, upload-time = "2025-10-13T18:56:01.262Z" }, + { url = "https://files.pythonhosted.org/packages/4f/93/d7e8dd76b03a9d5be41a3b3185feffc7ea5359228bdffe7aa43ac772a75b/cftime-1.6.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ad24a563784e4795cb3d04bd985895b5db49ace2cbb71fcf1321fd80141f9a52", size = 1689856, upload-time = "2025-10-13T19:39:12.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/8d/86586c0d75110f774e46e2bd6d134e2d1cca1dedc9bb08c388fa3df76acd/cftime-1.6.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a3cda6fd12c7fb25eff40a6a857a2bf4d03e8cc71f80485d8ddc65ccbd80f16a", size = 1718573, upload-time = "2025-10-13T18:56:02.788Z" }, + { url = "https://files.pythonhosted.org/packages/bb/fe/7956914cfc135992e89098ebbc67d683c51ace5366ba4b114fef1de89b21/cftime-1.6.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:28cda78d685397ba23d06273b9c916c3938d8d9e6872a537e76b8408a321369b", size = 1788563, upload-time = "2025-10-13T18:56:04.075Z" }, + { url = "https://files.pythonhosted.org/packages/e5/c7/6669708fcfe1bb7b2a7ce693b8cc67165eac00d3ac5a5e8f6ce1be551ff9/cftime-1.6.5-cp311-cp311-win_amd64.whl", hash = "sha256:93ead088e3a216bdeb9368733a0ef89a7451dfc1d2de310c1c0366a56ad60dc8", size = 473631, upload-time = "2025-10-13T18:56:05.159Z" }, + { url = "https://files.pythonhosted.org/packages/82/c5/d70cb1ab533ca790d7c9b69f98215fa4fead17f05547e928c8f2b8f96e54/cftime-1.6.5-cp311-cp311-win_arm64.whl", hash = "sha256:3384d69a0a7f3d45bded21a8cbcce66c8ba06c13498eac26c2de41b1b9b6e890", size = 459383, upload-time = "2026-01-02T21:16:47.317Z" }, + { url = "https://files.pythonhosted.org/packages/b6/c1/e8cb7f78a3f87295450e7300ebaecf83076d96a99a76190593d4e1d2be40/cftime-1.6.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:eef25caed5ebd003a38719bd3ff8847cd52ef2ea56c3ebdb2c9345ba131fc7c5", size = 504175, upload-time = "2025-10-13T18:56:06.398Z" }, + { url = "https://files.pythonhosted.org/packages/50/1a/86e1072b09b2f9049bb7378869f64b6747f96a4f3008142afed8955b52a4/cftime-1.6.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c87d2f3b949e45463e559233c69e6a9cf691b2b378c1f7556166adfabbd1c6b0", size = 485980, upload-time = "2025-10-13T18:56:08.669Z" }, + { url = "https://files.pythonhosted.org/packages/35/28/d3177b60da3f308b60dee2aef2eb69997acfab1e863f0bf0d2a418396ce5/cftime-1.6.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:82cb413973cc51b55642b3a1ca5b28db5b93a294edbef7dc049c074b478b4647", size = 1591166, upload-time = "2025-10-13T19:39:14.109Z" }, + { url = "https://files.pythonhosted.org/packages/d1/fd/a7266970312df65e68b5641b86e0540a739182f5e9c62eec6dbd29f18055/cftime-1.6.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85ba8e7356d239cfe56ef7707ac30feaf67964642ac760a82e507ee3c5db4ac4", size = 1642614, upload-time = "2025-10-13T18:56:09.815Z" }, + { url = "https://files.pythonhosted.org/packages/c4/73/f0035a4bc2df8885bb7bd5fe63659686ea1ec7d0cc74b4e3d50e447402e5/cftime-1.6.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:456039af7907a3146689bb80bfd8edabd074c7f3b4eca61f91b9c2670addd7ad", size = 1688090, upload-time = "2025-10-13T18:56:11.442Z" }, + { url = "https://files.pythonhosted.org/packages/88/15/8856a0ab76708553ff597dd2e617b088c734ba87dc3fd395e2b2f3efffe8/cftime-1.6.5-cp312-cp312-win_amd64.whl", hash = "sha256:da84534c43699960dc980a9a765c33433c5de1a719a4916748c2d0e97a071e44", size = 464840, upload-time = "2025-10-13T18:56:12.506Z" }, + { url = "https://files.pythonhosted.org/packages/3a/85/451009a986d9273d2208fc0898aa00262275b5773259bf3f942f6716a9e7/cftime-1.6.5-cp312-cp312-win_arm64.whl", hash = "sha256:c62cd8db9ea40131eea7d4523691c5d806d3265d31279e4a58574a42c28acd77", size = 450534, upload-time = "2026-01-02T21:16:48.784Z" }, + { url = "https://files.pythonhosted.org/packages/2e/60/74ea344b3b003fada346ed98a6899085d6fd4c777df608992d90c458fda6/cftime-1.6.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4aba66fd6497711a47c656f3a732c2d1755ad15f80e323c44a8716ebde39ddd5", size = 502453, upload-time = "2025-10-13T18:56:13.545Z" }, + { url = "https://files.pythonhosted.org/packages/1e/14/adb293ac6127079b49ff11c05cf3d5ce5c1f17d097f326dc02d74ddfcb6e/cftime-1.6.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:89e7cba699242366e67d6fb5aee579440e791063f92a93853610c91647167c0d", size = 484541, upload-time = "2025-10-13T18:56:14.612Z" }, + { url = "https://files.pythonhosted.org/packages/4f/74/bb8a4566af8d0ef3f045d56c462a9115da4f04b07c7fbbf2b4875223eebd/cftime-1.6.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2f1eb43d7a7b919ec99aee709fb62ef87ef1cf0679829ef93d37cc1c725781e9", size = 1591014, upload-time = "2025-10-13T19:39:15.346Z" }, + { url = "https://files.pythonhosted.org/packages/ba/08/52f06ff2f04d376f9cd2c211aefcf2b37f1978e43289341f362fc99f6a0e/cftime-1.6.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e02a1d80ffc33fe469c7db68aa24c4a87f01da0c0c621373e5edadc92964900b", size = 1633625, upload-time = "2025-10-13T18:56:15.745Z" }, + { url = "https://files.pythonhosted.org/packages/cf/33/03e0b23d58ea8fab94ecb4f7c5b721e844a0800c13694876149d98830a73/cftime-1.6.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:18ab754805233cdd889614b2b3b86a642f6d51a57a1ec327c48053f3414f87d8", size = 1684269, upload-time = "2025-10-13T18:56:17.04Z" }, + { url = "https://files.pythonhosted.org/packages/a4/60/a0cfba63847b43599ef1cdbbf682e61894994c22b9a79fd9e1e8c7e9de41/cftime-1.6.5-cp313-cp313-win_amd64.whl", hash = "sha256:6c27add8f907f4a4cd400e89438f2ea33e2eb5072541a157a4d013b7dbe93f9c", size = 465364, upload-time = "2025-10-13T18:56:18.05Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e8/ec32f2aef22c15604e6fda39ff8d581a00b5469349f8fba61640d5358d2c/cftime-1.6.5-cp313-cp313-win_arm64.whl", hash = "sha256:31d1ff8f6bbd4ca209099d24459ec16dea4fb4c9ab740fbb66dd057ccbd9b1b9", size = 450468, upload-time = "2026-01-02T21:16:50.193Z" }, + { url = "https://files.pythonhosted.org/packages/ea/6c/a9618f589688358e279720f5c0fe67ef0077fba07334ce26895403ebc260/cftime-1.6.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c69ce3bdae6a322cbb44e9ebc20770d47748002fb9d68846a1e934f1bd5daf0b", size = 502725, upload-time = "2025-10-13T18:56:19.424Z" }, + { url = "https://files.pythonhosted.org/packages/d8/e3/da3c36398bfb730b96248d006cabaceed87e401ff56edafb2a978293e228/cftime-1.6.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e62e9f2943e014c5ef583245bf2e878398af131c97e64f8cd47c1d7baef5c4e2", size = 485445, upload-time = "2025-10-13T18:56:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/32/93/b05939e5abd14bd1ab69538bbe374b4ee2a15467b189ff895e9a8cdaddf6/cftime-1.6.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7da5fdaa4360d8cb89b71b8ded9314f2246aa34581e8105c94ad58d6102d9e4f", size = 1584434, upload-time = "2025-10-13T19:39:17.084Z" }, + { url = "https://files.pythonhosted.org/packages/7f/89/648397f9936e0b330999c4e776ebf296ec3c6a65f9901687dbca4ab820da/cftime-1.6.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bff865b4ea4304f2744a1ad2b8149b8328b321dd7a2b9746ef926d229bd7cd49", size = 1609812, upload-time = "2025-10-13T18:56:21.971Z" }, + { url = "https://files.pythonhosted.org/packages/e7/0f/901b4835aa67ad3e915605d4e01d0af80a44b114eefab74ae33de6d36933/cftime-1.6.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e552c5d1c8a58f25af7521e49237db7ca52ed2953e974fe9f7c4491e95fdd36c", size = 1669768, upload-time = "2025-10-13T18:56:24.027Z" }, + { url = "https://files.pythonhosted.org/packages/22/d5/e605e4b28363e7a9ae98ed12cabbda5b155b6009270e6a231d8f10182a17/cftime-1.6.5-cp314-cp314-win_amd64.whl", hash = "sha256:e645b095dc50a38ac454b7e7f0742f639e7d7f6b108ad329358544a6ff8c9ba2", size = 463818, upload-time = "2025-10-13T18:56:25.376Z" }, + { url = "https://files.pythonhosted.org/packages/3d/89/a8f85ae697ff10206ec401c2621f5ca9f327554f586d62f244739ceeb347/cftime-1.6.5-cp314-cp314-win_arm64.whl", hash = "sha256:b9044d7ac82d3d8af189df1032fdc871bbd3f3dd41a6ec79edceb5029b71e6e0", size = 459862, upload-time = "2026-01-02T20:45:02.625Z" }, + { url = "https://files.pythonhosted.org/packages/ab/05/7410e12fd03a0c52717e74e6a1b49958810807dda212e23b65d43ea99676/cftime-1.6.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9ef56460cb0576e1a9161e1428c9e1a633f809a23fa9d598f313748c1ae5064e", size = 533781, upload-time = "2026-01-02T20:45:04.818Z" }, + { url = "https://files.pythonhosted.org/packages/44/ba/10e3546426d3ed9f9cc82e4a99836bb6fac1642c7830f7bdd0ac1c3f0805/cftime-1.6.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4f4873d38b10032f9f3111c547a1d485519ae64eee6a7a2d091f1f8b08e1ba50", size = 515218, upload-time = "2026-01-02T20:45:06.788Z" }, + { url = "https://files.pythonhosted.org/packages/bd/68/efa11eae867749e921bfec6a865afdba8166e96188112dde70bb8bb49254/cftime-1.6.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ccce0f4c9d3f38dd948a117e578b50d0e0db11e2ca9435fb358fd524813e4b61", size = 1579932, upload-time = "2026-01-02T20:45:11.194Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6c/0971e602c1390a423e6621dfbad9f1d375186bdaf9c9c7f75e06f1fbf355/cftime-1.6.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19cbfc5152fb0b34ce03acf9668229af388d7baa63a78f936239cb011ccbe6b1", size = 1555894, upload-time = "2026-01-02T20:45:16.351Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fc/8475a15b7c3209a4a68b563dfc5e01ce74f2d8b9822372c3d30c68ab7f39/cftime-1.6.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4470cd5ef3c2514566f53efbcbb64dd924fa0584637d90285b2f983bd4ee7d97", size = 513027, upload-time = "2026-01-02T20:45:20.023Z" }, + { url = "https://files.pythonhosted.org/packages/f7/80/4ecbda8318fbf40ad4e005a4a93aebba69e81382e5b4c6086251cd5d0ee8/cftime-1.6.5-cp314-cp314t-win_arm64.whl", hash = "sha256:034c15a67144a0a5590ef150c99f844897618b148b87131ed34fda7072614662", size = 469065, upload-time = "2026-01-02T20:45:23.398Z" }, +] + +[[package]] +name = "claude-agent-sdk" +version = "0.2.89" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "mcp" }, + { name = "sniffio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/a9/a585d8a5089339d0c39c2b85b2fca9138db1863b385ce6fc7ed4fd4bf8fb/claude_agent_sdk-0.2.89.tar.gz", hash = "sha256:6a1ad0751a255882c5422198779144c094eb74e86c3f7ef00bcd27fbd6527c30", size = 253312, upload-time = "2026-06-03T21:43:40.891Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/12/a12bfeab1a7c7f96642a2a3e08272038e19bed7a8751f9e250f91b878d2e/claude_agent_sdk-0.2.89-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c344e0e4c4a8a0c4e3d84efdffdef29d467203002ab5c898af2178498c61d82d", size = 64452653, upload-time = "2026-06-03T21:43:45.993Z" }, + { url = "https://files.pythonhosted.org/packages/08/71/26fc80a2083f8427a284a3c4e29701b6e4acd1a753bdd62555d6f4b358a6/claude_agent_sdk-0.2.89-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:f84d4f48b1f9926e24665b910013f77dfce2b0ed1dca64c3c350a383009b5dd3", size = 66513584, upload-time = "2026-06-03T21:43:51.221Z" }, + { url = "https://files.pythonhosted.org/packages/22/1b/88fe49274e9a1bb3b7623f04ca3a0a82358082bf0d29d42e9bc32050461d/claude_agent_sdk-0.2.89-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:be8663d990879578d101d4153dfad3a6ec38642a9d542f56de4f0a7051f8d284", size = 74080592, upload-time = "2026-06-03T21:43:57.602Z" }, + { url = "https://files.pythonhosted.org/packages/a5/47/56fb2e0bbf128b41edb9e15b79622cd0b41585c63f4e691287f6609af679/claude_agent_sdk-0.2.89-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:8a078e6fa06a66530bb5c58fd068a15438456f8b597bec870dd8e053a618278d", size = 74251641, upload-time = "2026-06-03T21:44:03.329Z" }, + { url = "https://files.pythonhosted.org/packages/40/ab/edbedca3e4599e9a3d96bd38ae3266ef2106bfc90fe9867181717c271030/claude_agent_sdk-0.2.89-py3-none-win_amd64.whl", hash = "sha256:a34ebd796f69ec2f2e41b0412b325de4a8aab042c2149079a07efddf04cc6899", size = 74869839, upload-time = "2026-06-03T21:44:09.736Z" }, +] + [[package]] name = "click" version = "8.3.1" @@ -87,8 +401,12 @@ name = "clio-agentic-search" version = "0.1.0" source = { editable = "." } dependencies = [ + { name = "aiohttp" }, { name = "duckdb" }, { name = "fastapi" }, + { name = "h5py" }, + { name = "httpx" }, + { name = "matplotlib" }, { name = "tenacity" }, { name = "uvicorn" }, ] @@ -98,6 +416,23 @@ ann = [ { name = "hnswlib" }, { name = "numpy" }, ] +eval = [ + { name = "aiohttp" }, + { name = "anthropic" }, + { name = "claude-agent-sdk" }, + { name = "matplotlib" }, +] +hdf5 = [ + { name = "h5py" }, +] +llm = [ + { name = "anthropic" }, + { name = "openai" }, +] +netcdf = [ + { name = "netcdf4" }, + { name = "xarray" }, +] semantic = [ { name = "sentence-transformers" }, ] @@ -122,10 +457,22 @@ dev = [ [package.metadata] requires-dist = [ + { name = "aiohttp", specifier = ">=3.13.5" }, + { name = "aiohttp", marker = "extra == 'eval'", specifier = ">=3.10.0" }, + { name = "anthropic", marker = "extra == 'eval'", specifier = ">=0.87.0" }, + { name = "anthropic", marker = "extra == 'llm'", specifier = ">=0.40.0" }, + { name = "claude-agent-sdk", marker = "extra == 'eval'", specifier = ">=0.1.56" }, { name = "duckdb", specifier = ">=1.1.0,<2.0.0" }, { name = "fastapi", specifier = ">=0.115.0,<1.0.0" }, + { name = "h5py", specifier = ">=3.16.0" }, + { name = "h5py", marker = "extra == 'hdf5'", specifier = ">=3.10.0" }, { name = "hnswlib", marker = "extra == 'ann'", specifier = ">=0.8.0" }, + { name = "httpx", specifier = ">=0.28.1" }, + { name = "matplotlib", specifier = ">=3.10.8" }, + { name = "matplotlib", marker = "extra == 'eval'", specifier = ">=3.8.0" }, + { name = "netcdf4", marker = "extra == 'netcdf'", specifier = ">=1.6.0" }, { name = "numpy", marker = "extra == 'ann'", specifier = ">=1.26.0" }, + { name = "openai", marker = "extra == 'llm'", specifier = ">=1.0.0" }, { name = "opentelemetry-api", marker = "extra == 'telemetry'", specifier = ">=1.20.0" }, { name = "opentelemetry-exporter-otlp-proto-grpc", marker = "extra == 'telemetry'", specifier = ">=1.20.0" }, { name = "opentelemetry-sdk", marker = "extra == 'telemetry'", specifier = ">=1.20.0" }, @@ -133,8 +480,9 @@ requires-dist = [ { name = "sentence-transformers", marker = "extra == 'semantic'", specifier = ">=2.2.0" }, { name = "tenacity", specifier = ">=8.2.0,<10.0.0" }, { name = "uvicorn", specifier = ">=0.30.0,<1.0.0" }, + { name = "xarray", marker = "extra == 'netcdf'", specifier = ">=2024.1.0" }, ] -provides-extras = ["semantic", "ann", "telemetry"] +provides-extras = ["semantic", "ann", "hdf5", "netcdf", "llm", "eval", "telemetry"] [package.metadata.requires-dev] dev = [ @@ -157,12 +505,153 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "contourpy" +version = "1.3.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/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, + { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, + { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, + { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, + { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, + { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, + { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, + { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, +] + +[[package]] +name = "cryptography" +version = "48.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/a9/db8f313fdcd85d767d4973515e1db101f9c71f95fced83233de224673757/cryptography-48.0.0.tar.gz", hash = "sha256:5c3932f4436d1cccb036cb0eaef46e6e2db91035166f1ad6505c3c9d5a635920", size = 832984, upload-time = "2026-05-04T22:59:38.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/3d/01f6dd9190170a5a241e0e98c2d04be3664a9e6f5b9b872cde63aff1c3dd/cryptography-48.0.0-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:0c558d2cdffd8f4bbb30fc7134c74d2ca9a476f830bb053074498fbc86f41ed6", size = 8001587, upload-time = "2026-05-04T22:57:36.803Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6e/e90527eef33f309beb811cf7c982c3aeffcce8e3edb178baa4ca3ae4a6fa/cryptography-48.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f5333311663ea94f75dd408665686aaf426563556bb5283554a3539177e03b8c", size = 4690433, upload-time = "2026-05-04T22:57:40.373Z" }, + { url = "https://files.pythonhosted.org/packages/90/04/673510ed51ddff56575f306cf1617d80411ee76831ccd3097599140efdfe/cryptography-48.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7995ef305d7165c3f11ae07f2517e5a4f1d5c18da1376a0a9ed496336b69e5f3", size = 4710620, upload-time = "2026-05-04T22:57:42.935Z" }, + { url = "https://files.pythonhosted.org/packages/14/d5/e9c4ef932c8d800490c34d8bd589d64a31d5890e27ec9e9ad532be893294/cryptography-48.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:40ba1f85eaa6959837b1d51c9767e230e14612eea4ef110ee8854ada22da1bf5", size = 4696283, upload-time = "2026-05-04T22:57:45.294Z" }, + { url = "https://files.pythonhosted.org/packages/0c/29/174b9dfb60b12d59ecfc6cfa04bc88c21b42a54f01b8aae09bb6e51e4c7f/cryptography-48.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:369a6348999f94bbd53435c894377b20ab95f25a9065c283570e70150d8abc3c", size = 5296573, upload-time = "2026-05-04T22:57:47.933Z" }, + { url = "https://files.pythonhosted.org/packages/95/38/0d29a6fd7d0d1373f0c0c88a04ba20e359b257753ac497564cd660fc1d55/cryptography-48.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a0e692c683f4df67815a2d258b324e66f4738bd7a96a218c826dce4f4bd05d8f", size = 4743677, upload-time = "2026-05-04T22:57:50.067Z" }, + { url = "https://files.pythonhosted.org/packages/30/be/eef653013d5c63b6a490529e0316f9ac14a37602965d4903efed1399f32b/cryptography-48.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:18349bbc56f4743c8b12dc32e2bccb2cf83ee8b69a3bba74ef8ae857e26b3d25", size = 4330808, upload-time = "2026-05-04T22:57:52.301Z" }, + { url = "https://files.pythonhosted.org/packages/84/9e/500463e87abb7a0a0f9f256ec21123ecde0a7b5541a15e840ea54551fd81/cryptography-48.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e8eac43dfca5c4cccc6dad9a80504436fca53bb9bc3100a2386d730fbe6b602", size = 4695941, upload-time = "2026-05-04T22:57:54.603Z" }, + { url = "https://files.pythonhosted.org/packages/e3/dc/7303087450c2ec9e7fbb750e17c2abfbc658f23cbd0e54009509b7cc4091/cryptography-48.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9ccdac7d40688ecb5a3b4a604b8a88c8002e3442d6c60aead1db2a89a041560c", size = 5252579, upload-time = "2026-05-04T22:57:57.207Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c0/7101d3b7215edcdc90c45da544961fd8ed2d6448f77577460fa75a8443f7/cryptography-48.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:bd72e68b06bb1e96913f97dd4901119bc17f39d4586a5adf2d3e47bc2b9d58b5", size = 4743326, upload-time = "2026-05-04T22:57:59.535Z" }, + { url = "https://files.pythonhosted.org/packages/ac/d8/5b833bad13016f562ab9d063d68199a4bd121d18458e439515601d3357ec/cryptography-48.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:59baa2cb386c4f0b9905bd6eb4c2a79a69a128408fd31d32ca4d7102d4156321", size = 4826672, upload-time = "2026-05-04T22:58:01.996Z" }, + { url = "https://files.pythonhosted.org/packages/98/e1/7074eb8bf3c135558c73fc2bcf0f5633f912e6fb87e868a55c454080ef09/cryptography-48.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9249e3cd978541d665967ac2cb2787fd6a62bddf1e75b3e347a594d7dacf4f74", size = 4972574, upload-time = "2026-05-04T22:58:03.968Z" }, + { url = "https://files.pythonhosted.org/packages/04/70/e5a1b41d325f797f39427aa44ef8baf0be500065ab6d8e10369d850d4a4f/cryptography-48.0.0-cp311-abi3-win32.whl", hash = "sha256:9c459db21422be75e2809370b829a87eb37f74cd785fc4aa9ea1e5f43b47cda4", size = 3294868, upload-time = "2026-05-04T22:58:06.467Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ac/8ac51b4a5fc5932eb7ee5c517ba7dc8cd834f0048962b6b352f00f41ebf9/cryptography-48.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:5b012212e08b8dd5edc78ef54da83dd9892fd9105323b3993eff6bea65dc21d7", size = 3817107, upload-time = "2026-05-04T22:58:08.845Z" }, + { url = "https://files.pythonhosted.org/packages/6b/84/70e3feea9feea87fd7cbe77efb2712ae1e3e6edf10749dc6e95f4e60e455/cryptography-48.0.0-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:3cb07a3ed6431663cd321ea8a000a1314c74211f823e4177fefa2255e057d1ec", size = 7986556, upload-time = "2026-05-04T22:58:11.172Z" }, + { url = "https://files.pythonhosted.org/packages/89/6e/18e07a618bb5442ba10cf4df16e99c071365528aa570dfcb8c02e25a303b/cryptography-48.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8c7378637d7d88016fa6791c159f698b3d3eed28ebf844ac36b9dc04a14dae18", size = 4684776, upload-time = "2026-05-04T22:58:13.712Z" }, + { url = "https://files.pythonhosted.org/packages/be/6a/4ea3b4c6c6759794d5ee2103c304a5076dc4b19ae1f9fe47dba439e159e9/cryptography-48.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc90c0b39b2e3c65ef52c804b72e3c58f8a04ab2a1871272798e5f9572c17d20", size = 4698121, upload-time = "2026-05-04T22:58:16.448Z" }, + { url = "https://files.pythonhosted.org/packages/2f/59/6ff6ad6cae03bb887da2a5860b2c9805f8dac969ef01ce563336c49bd1d1/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:76341972e1eff8b4bea859f09c0d3e64b96ce931b084f9b9b7db8ef364c30eff", size = 4690042, upload-time = "2026-05-04T22:58:18.544Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b4/fc334ed8cfd705aca282fe4d8f5ae64a8e0f74932e9feecb344610cf6e4d/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:55b7718303bf06a5753dcdccf2f3945cf18ad7bffde41b61226e4db31ab89a9c", size = 5282526, upload-time = "2026-05-04T22:58:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/11/08/9f8c5386cc4cd90d8255c7cdd0f5baf459a08502a09de30dc51f553d38dc/cryptography-48.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:a64697c641c7b1b2178e573cbc31c7c6684cd56883a478d75143dbb7118036db", size = 4733116, upload-time = "2026-05-04T22:58:23.627Z" }, + { url = "https://files.pythonhosted.org/packages/b8/77/99307d7574045699f8805aa500fa0fb83422d115b5400a064ddd306d7750/cryptography-48.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:561215ea3879cb1cbbf272867e2efda62476f240fb58c64de6b393ae19246741", size = 4316030, upload-time = "2026-05-04T22:58:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/fd/36/a608b98337af3cb2aff4818e406649d30572b7031918b04c87d979495348/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:ad64688338ed4bc1a6618076ba75fd7194a5f1797ac60b47afe926285adb3166", size = 4689640, upload-time = "2026-05-04T22:58:27.747Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a6/825010a291b4438aecc1f568bc428189fc1175515223632477c07dc0a6df/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:906cbf0670286c6e0044156bc7d4af9cbb0ef6db9f73e52c3ec56ba6bdde5336", size = 5237657, upload-time = "2026-05-04T22:58:29.848Z" }, + { url = "https://files.pythonhosted.org/packages/b9/09/4e76a09b4caa29aad535ddc806f5d4c5d01885bd978bd984fbc6ca032cae/cryptography-48.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:ea8990436d914540a40ab24b6a77c0969695ed52f4a4874c5137ccf7045a7057", size = 4732362, upload-time = "2026-05-04T22:58:32.009Z" }, + { url = "https://files.pythonhosted.org/packages/18/78/444fa04a77d0cb95f417dda20d450e13c56ba8e5220fc892a1658f44f882/cryptography-48.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c18684a7f0cc9a3cb60328f496b8e3372def7c5d2df39ac267878b05565aaaae", size = 4819580, upload-time = "2026-05-04T22:58:34.254Z" }, + { url = "https://files.pythonhosted.org/packages/38/85/ea67067c70a1fd4be2c63d35eeed82658023021affccc7b17705f8527dd2/cryptography-48.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9be5aafa5736574f8f15f262adc81b2a9869e2cfe9014d52a44633905b40d52c", size = 4963283, upload-time = "2026-05-04T22:58:36.376Z" }, + { url = "https://files.pythonhosted.org/packages/75/54/cc6d0f3deac3e81c7f847e8a189a12b6cdd65059b43dad25d4316abd849a/cryptography-48.0.0-cp314-cp314t-win32.whl", hash = "sha256:c17dfe85494deaeddc5ce251aebd1d60bbe6afc8b62071bb0b469431a000124f", size = 3270954, upload-time = "2026-05-04T22:58:38.791Z" }, + { url = "https://files.pythonhosted.org/packages/49/67/cc947e288c0758a4e5473d1dcb743037ab7785541265a969240b8885441a/cryptography-48.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27241b1dc9962e056062a8eef1991d02c3a24569c95975bd2322a8a52c6e5e12", size = 3797313, upload-time = "2026-05-04T22:58:40.746Z" }, + { url = "https://files.pythonhosted.org/packages/f2/63/61d4a4e1c6b6bab6ce1e213cd36a24c415d90e76d78c5eb8577c5541d2e8/cryptography-48.0.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:58d00498e8933e4a194f3076aee1b4a97dfec1a6da444535755822fe5d8b0b86", size = 7983482, upload-time = "2026-05-04T22:58:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ac/f5b5995b87770c693e2596559ffafe195b4033a57f14a82268a2842953f3/cryptography-48.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:614d0949f4790582d2cc25553abd09dd723025f0c0e7c67376a1d77196743d6e", size = 4683266, upload-time = "2026-05-04T22:58:46.064Z" }, + { url = "https://files.pythonhosted.org/packages/ec/c6/8b14f67e18338fbc4adb76f66c001f5c3610b3e2d1837f268f47a347dbbb/cryptography-48.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ce4bfae76319a532a2dc68f82cc32f5676ee792a983187dac07183690e5c66f", size = 4696228, upload-time = "2026-05-04T22:58:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/ea/73/f808fbae9514bd91b47875b003f13e284c8c6bdfd904b7944e803937eec1/cryptography-48.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:2eb992bbd4661238c5a397594c83f5b4dc2bc5b848c365c8f991b6780efcc5c7", size = 4689097, upload-time = "2026-05-04T22:58:50.9Z" }, + { url = "https://files.pythonhosted.org/packages/93/01/d86632d7d28db8ae83221995752eeb6639ffb374c2d22955648cf8d52797/cryptography-48.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:22a5cb272895dce158b2cacdfdc3debd299019659f42947dbdac6f32d68fe832", size = 5283582, upload-time = "2026-05-04T22:58:53.017Z" }, + { url = "https://files.pythonhosted.org/packages/02/e1/50edc7a50334807cc4791fc4a0ce7468b4a1416d9138eab358bfc9a3d70b/cryptography-48.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2b4d59804e8408e2fea7d1fbaf218e5ec984325221db76e6a241a9abd6cdd95c", size = 4730479, upload-time = "2026-05-04T22:58:55.611Z" }, + { url = "https://files.pythonhosted.org/packages/6f/af/99a582b1b1641ff5911ac559beb45097cf79efd4ead4657f578ef1af2d47/cryptography-48.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:984a20b0f62a26f48a3396c72e4bc34c66e356d356bf370053066b3b6d54634a", size = 4326481, upload-time = "2026-05-04T22:58:57.607Z" }, + { url = "https://files.pythonhosted.org/packages/90/ee/89aa26a06ef0a7d7611788ffd571a7c50e368cc6a4d5eef8b4884e866edb/cryptography-48.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5a5ed8fde7a1d09376ca0b40e68cd59c69fe23b1f9768bd5824f54681626032a", size = 4688713, upload-time = "2026-05-04T22:59:00.077Z" }, + { url = "https://files.pythonhosted.org/packages/70/ba/bcb1b0bb7a33d4c7c0c4d4c7874b4a62ae4f56113a5f4baefa362dfb1f0f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:8cd666227ef7af430aa5914a9910e0ddd703e75f039cef0825cd0da71b6b711a", size = 5238165, upload-time = "2026-05-04T22:59:02.317Z" }, + { url = "https://files.pythonhosted.org/packages/c9/70/ca4003b1ce5ca3dc3186ada51908c8a9b9ff7d5cab83cc0d43ee14ec144f/cryptography-48.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9071196d81abc88b3516ac8cdfad32e2b66dd4a5393a8e68a961e9161ddc6239", size = 4729947, upload-time = "2026-05-04T22:59:05.255Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/4ec7cf774207905aef1a8d11c3750d5a1db805eb380ee4e16df317870128/cryptography-48.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1e2d54c8be6152856a36f0882ab231e70f8ec7f14e93cf87db8a2ed056bf160c", size = 4822059, upload-time = "2026-05-04T22:59:07.802Z" }, + { url = "https://files.pythonhosted.org/packages/1e/75/a2e55f99c16fcac7b5d6c1eb19ad8e00799854d6be5ca845f9259eae1681/cryptography-48.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a5da777e32ffed6f85a7b2b3f7c5cbc88c146bfcd0a1d7baf5fcc6c52ee35dd4", size = 4960575, upload-time = "2026-05-04T22:59:09.851Z" }, + { url = "https://files.pythonhosted.org/packages/b8/23/6e6f32143ab5d8b36ca848a502c4bcd477ae75b9e1677e3530d669062578/cryptography-48.0.0-cp39-abi3-win32.whl", hash = "sha256:77a2ccbbe917f6710e05ba9adaa25fb5075620bf3ea6fb751997875aff4ae4bd", size = 3279117, upload-time = "2026-05-04T22:59:12.019Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9a/0fea98a70cf1749d41d738836f6349d97945f7c89433a259a6c2642eefeb/cryptography-48.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:16cd65b9330583e4619939b3a3843eec1e6e789744bb01e7c7e2e62e33c239c8", size = 3792100, upload-time = "2026-05-04T22:59:14.884Z" }, + { url = "https://files.pythonhosted.org/packages/be/d2/024b5e06be9d44cb021fb0e1a03d34d63989cf56a0fe62f3dfbab695b9b4/cryptography-48.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:84cf79f0dc8b36ac5da873481716e87aef31fcfa0444f9e1d8b4b2cece142855", size = 3950391, upload-time = "2026-05-04T22:59:17.415Z" }, + { url = "https://files.pythonhosted.org/packages/bc/17/3861e17c56fa0fd37491a14a8673fdb77c57fc5693cafe745ea8b06dba75/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:fdfef35d751d510fcef5252703621574364fec16418c4a1e5e1055248401054b", size = 4637126, upload-time = "2026-05-04T22:59:20.197Z" }, + { url = "https://files.pythonhosted.org/packages/f0/0a/7e226dbff530f21480727eb764973a7bff2b912f8e15cd4f129e71b56d1d/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:0890f502ddf7d9c6426129c3f49f5c0a39278ed7cd6322c8755ffca6ee675a13", size = 4667270, upload-time = "2026-05-04T22:59:22.647Z" }, + { url = "https://files.pythonhosted.org/packages/3b/f2/5a72274ca9f1b2a8b44a662ee0bf1b435909deb473d6f97bcd035bcdbc71/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:ecde28a596bead48b0cfd2a1b4416c3d43074c2d785e3a398d7ec1fc4d0f7fbb", size = 4636797, upload-time = "2026-05-04T22:59:24.912Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e1/48cedb2fe63626e91ded1edad159e2a4fb8b6906c4425eb7749673077ce7/cryptography-48.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:4defde8685ae324a9eb9d818717e93b4638ef67070ac9bc15b8ca85f63048355", size = 4666800, upload-time = "2026-05-04T22:59:27.474Z" }, + { url = "https://files.pythonhosted.org/packages/a2/ca/7e8365deec19afb2b2c7be7c1c0aa8f99633b54e90c570999acda93260fc/cryptography-48.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:db63bf618e5dea46c07de12e900fe1cdd2541e6dc9dbae772a70b7d4d4765f6a", size = 3739536, upload-time = "2026-05-04T22:59:29.61Z" }, +] + [[package]] name = "cuda-bindings" version = "12.9.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-pathfinder" }, + { name = "cuda-pathfinder", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/45/e7/b47792cc2d01c7e1d37c32402182524774dadd2d26339bd224e0e913832e/cuda_bindings-12.9.4-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c912a3d9e6b6651853eed8eed96d6800d69c08e94052c292fec3f282c5a817c9", size = 12210593, upload-time = "2025-10-21T14:51:36.574Z" }, @@ -181,6 +670,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b8/5e/db279a3bfbd18d59d0598922a3b3c1454908d0969e8372260afec9736376/cuda_pathfinder-1.3.4-py3-none-any.whl", hash = "sha256:fb983f6e0d43af27ef486e14d5989b5f904ef45cedf40538bfdcbffa6bb01fb2", size = 30878, upload-time = "2026-02-11T18:50:31.008Z" }, ] +[[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 = "distlib" version = "0.4.0" @@ -190,6 +688,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" }, ] +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, +] + +[[package]] +name = "docstring-parser" +version = "0.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", hash = "sha256:292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015", size = 29341, upload-time = "2026-04-14T04:09:19.867Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" }, +] + [[package]] name = "duckdb" version = "1.4.4" @@ -251,6 +767,160 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9c/0f/5d0c71a1aefeb08efff26272149e07ab922b64f46c63363756224bd6872e/filelock-3.24.3-py3-none-any.whl", hash = "sha256:426e9a4660391f7f8a810d71b0555bce9008b0a1cc342ab1f6947d37639e002d", size = 24331, upload-time = "2026-02-19T00:48:18.465Z" }, ] +[[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/75/2b/a7f1545bdf5da69c4bda0cea2a5781f0ad2a6623e0277267672db43c5fe6/fonttools-4.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b8ae05d9eacf6081414d759c0a352769ac28ce31280d6bb8e77b03f9e3c449f", size = 2881793, upload-time = "2026-05-14T12:02:56.645Z" }, + { url = "https://files.pythonhosted.org/packages/49/50/965308c703f085f225db2886813b27e015b8b3438c350b22dd65b52c2a2c/fonttools-4.63.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79cdc9f567aec74a72918fd060283911406750cbc9fd28c1316023deb6ce31a9", size = 2428130, upload-time = "2026-05-14T12:02:58.891Z" }, + { url = "https://files.pythonhosted.org/packages/d8/38/6937fbd7f2dc3a6b48725851bc2c15ec949b9af14d9bbcb5fe83cdf9bdf9/fonttools-4.63.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c14b4fd138c4bafcca294765c547914e1aa431ae1ca94ab99d8db08c958bd3b", size = 5111952, upload-time = "2026-05-14T12:03:01.263Z" }, + { url = "https://files.pythonhosted.org/packages/0b/43/a81f20050a3115b57d62c8e781446949512eac36690dc384ccea65ff4cc1/fonttools-4.63.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76ac49f929aecaf82d83250b8347e099d7aecba0f4726c1d9b6df3b8bb5fe18", size = 5082308, upload-time = "2026-05-14T12:03:03.211Z" }, + { url = "https://files.pythonhosted.org/packages/67/00/cdd9d4944ca6ae280d01e69cc37bde3bf663630b837a6fc6d2cd65d80e0e/fonttools-4.63.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dcf076a4474fe0d7367e5bbf5b052c7284fa1feca729c04176ce513521afd8a0", size = 5087932, upload-time = "2026-05-14T12:03:05.147Z" }, + { url = "https://files.pythonhosted.org/packages/f5/f1/0aa0dbea778c75adbef223c42019fd47d22262b905974d62d829545d485f/fonttools-4.63.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7dd683fef0663e9f0f45cf541d788d24caa3ec9db50796b588e1757d8b3bc007", size = 5213271, upload-time = "2026-05-14T12:03:07.238Z" }, + { url = "https://files.pythonhosted.org/packages/a8/99/253e4056e1f0e67b9390125a154b73b5eb73ad521bece95c004858fdeec2/fonttools-4.63.0-cp311-cp311-win32.whl", hash = "sha256:afefc1ed0a59785a7fb06ea7e1678e849c193e1e387db783579bc7b3056fcfcb", size = 2304473, upload-time = "2026-05-14T12:03:09.271Z" }, + { url = "https://files.pythonhosted.org/packages/08/60/defa5e69641db890a63be281f41345f4c33b157824eaf0b9fad3e08b0dcb/fonttools-4.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:063e08bd17bd5a90127a14123de0d6a952dbc847695fd98b63c043d58057f90c", size = 2356389, upload-time = "2026-05-14T12:03:11.53Z" }, + { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" }, + { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" }, + { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" }, + { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" }, + { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8d/d8fec3dcde2963f8c908fb315e5ff2cd0ac34f82394bbbf73a2aa5145ce3/fonttools-4.63.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd7e9857e5e63738b9d9fd707bc1f59c8b09e5177726d23664db393c59bb08bd", size = 2876062, upload-time = "2026-05-14T12:03:32.554Z" }, + { url = "https://files.pythonhosted.org/packages/ef/71/d935dc54e4ff121bfdd11e08702db63a7e6f25af21d8a3d7b7212df53641/fonttools-4.63.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c2a2a42198b696a6f48fad91709afb55176e66a5e566131219dba372fb7f8c59", size = 2424594, upload-time = "2026-05-14T12:03:34.86Z" }, + { url = "https://files.pythonhosted.org/packages/8e/40/e76320afa1df918e146155ef239b1719ee266092e96f5423bfd075affba1/fonttools-4.63.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e874792a8212b44583ea02189d9e693906b2f78b261f372f95d6c563210ac1d", size = 5024840, upload-time = "2026-05-14T12:03:36.745Z" }, + { url = "https://files.pythonhosted.org/packages/ce/36/0b805d8c485f872f65a509cbe3b58a5d0d17bee855333b54a150c79d3061/fonttools-4.63.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22135da48a348785c5e2d5d2d9d6bec5ed44adacbaeb9db12d9493bf6c6bfa68", size = 4975801, upload-time = "2026-05-14T12:03:38.833Z" }, + { url = "https://files.pythonhosted.org/packages/c8/26/2cee03d0aa083ab022da5c07aff9ed3f689da1defb81ad6917c9627896da/fonttools-4.63.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccf41f2efdf56994d22d73bef4ced1052161958169428d06ba9724ea9e9a64be", size = 4965009, upload-time = "2026-05-14T12:03:41.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" }, + { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" }, + { url = "https://files.pythonhosted.org/packages/27/d2/23d25e3f247b328be58d04a4c9f894178a0d1eda7d42867cfb388adaf416/fonttools-4.63.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fd1e3094f42d806d3d7c79162fc59e5910fcbe3a7360c385b8da969bc4493745", size = 2875338, upload-time = "2026-05-14T12:03:50.052Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/7dfa0c761cb3b2964e2a84c4dc986c926a87de0cb9fb60d5b28ded3f2914/fonttools-4.63.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6e528da43bc3791085f8cb6141b1d13e459226790240340fcbb4625649238b03", size = 2422661, upload-time = "2026-05-14T12:03:52.154Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/64cfa18a7a1621d17b7f4502b2b0ed8a135a90c3db51ea590ee99043e76b/fonttools-4.63.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b2248c5decb223562f7902ff6325077a073f608ee8e33e88ad88db734eb9f49", size = 5010526, upload-time = "2026-05-14T12:03:54.647Z" }, + { url = "https://files.pythonhosted.org/packages/36/e1/a8933a72c45a87177fbde2696e0d0755c8c9062f8c077a961c6215fa27b1/fonttools-4.63.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:308f957cdeaf8abe4e5f2f124902ef405448af92c90f80e302a3b771c2e6116b", size = 4923946, upload-time = "2026-05-14T12:03:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/872e6e233b8c5e8b41413796ff18b7fe479661bd40147e071b450dfad7a1/fonttools-4.63.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bf00f21eb5fb721dbaf73d1e9da6d02a1af7768f2ebcf9798be98beab8ba90f6", size = 4962489, upload-time = "2026-05-14T12:03:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/30/c4/83c24f2ec38b90cfda84bf4b1a1f49df80e84a1db4e7ac6e0d41bf23bc39/fonttools-4.63.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1aaa4b9c75798400ac043ce04d74e7830376c85095a5a6ed7cba2f17a266bf4", size = 5071870, upload-time = "2026-05-14T12:04:02.122Z" }, + { url = "https://files.pythonhosted.org/packages/de/40/3ae22b60ff1d41ce0bd044b31238cdc72cef99f28b976f1e128ebd618c9b/fonttools-4.63.0-cp314-cp314-win32.whl", hash = "sha256:22693918177bd9ceabec4736d338045f357769416fc6b0b2508eefef75b08616", size = 2295026, upload-time = "2026-05-14T12:04:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d4/98078064ccc76b45cb0f6c002452011e93c4bd26f6850344f0951cc1fe89/fonttools-4.63.0-cp314-cp314-win_amd64.whl", hash = "sha256:7d782fac32985914c351556f68ac0855391572bcd87de50e05970d3cd4c96fc5", size = 2347454, upload-time = "2026-05-14T12:04:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/49/4e/652d1580c5f4e39f7d103b0c793e4773129ad633dce4addd0cf4dfebde02/fonttools-4.63.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6db5140a60a5d731d21ec076745b40a310607731b0a565b50776393188649001", size = 2958152, upload-time = "2026-05-14T12:04:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/0e/55/ad864c9a9b219f552eb46b32cd7906c466e5a578ba0c3abfcc0fe7413eb6/fonttools-4.63.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d76edbff9014094dbf03bd2d074709dfa6ec7aba13d838c937a2b33d2d6a86e", size = 2460809, upload-time = "2026-05-14T12:04:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/0aa8db70f18cf52e49b4ed5ecec68547f981160bf5ded3b5aed6faa0a6f9/fonttools-4.63.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eac00b9118c3c2f87d272e45341871c5b3066baa3c86897fa634a7c3fb59096", size = 5148649, upload-time = "2026-05-14T12:04:12.747Z" }, + { url = "https://files.pythonhosted.org/packages/7f/63/18e4369c25043096f1048e0c9915951adc4f842bd81c6b18155824d6fa99/fonttools-4.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51394295f1a51de8b5f30bdb1e1b9a4231536c7064ef5c6e211eec19fa36036f", size = 4932147, upload-time = "2026-05-14T12:04:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/a1/3f/67f3eac2ffd8a98446c5022f8ed3864eac878a5ff7af8df4c8286dba16cc/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9e12f105d2b6342c559c298afb674006bb2893afc7102dcf8a1b55b0486b4e40", size = 5027237, upload-time = "2026-05-14T12:04:17.675Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ba/4e6214cb38a7b04779e97bb7636de9a5c7f20af7018d03dee0b64c08510a/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:796f27556dbe094c4824f75ca85267e4df776c79036c8441469a4df37038c196", size = 5053933, upload-time = "2026-05-14T12:04:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/34/3b/214dcc19ee31d3d38fb5ad2755c11ef0514e5dc300bbaf41c0b69f393799/fonttools-4.63.0-cp314-cp314t-win32.whl", hash = "sha256:948428a275741f0b64b113c955425a953314f4b9ab9997f73a72c83e68e569c8", size = 2359326, upload-time = "2026-05-14T12:04:24.22Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/3ff1a9b523058c2eeb6a9d50f5574e2a738200d0d94107d5bc4105e8da3f/fonttools-4.63.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6d4741eb179121cab9eea4cb2393d24492373a260d7945006358c08cfbf45419", size = 2425829, upload-time = "2026-05-14T12:04:26.829Z" }, + { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" }, + { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" }, + { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" }, + { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" }, + { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" }, + { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" }, + { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" }, + { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" }, + { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" }, + { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" }, + { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" }, + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + [[package]] name = "fsspec" version = "2026.2.0" @@ -332,6 +1002,57 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, ] +[[package]] +name = "h5py" +version = "3.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/db/33/acd0ce6863b6c0d7735007df01815403f5589a21ff8c2e1ee2587a38f548/h5py-3.16.0.tar.gz", hash = "sha256:a0dbaad796840ccaa67a4c144a0d0c8080073c34c76d5a6941d6818678ef2738", size = 446526, upload-time = "2026-03-06T13:49:08.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/95/a825894f3e45cbac7554c4e97314ce886b233a20033787eda755ca8fecc7/h5py-3.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:719439d14b83f74eeb080e9650a6c7aa6d0d9ea0ca7f804347b05fac6fbf18af", size = 3721663, upload-time = "2026-03-06T13:47:49.599Z" }, + { url = "https://files.pythonhosted.org/packages/bf/3b/38ff88b347c3e346cda1d3fc1b65a7aa75d40632228d8b8a5d7b58508c24/h5py-3.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c3f0a0e136f2e95dd0b67146abb6668af4f1a69c81ef8651a2d316e8e01de447", size = 3087630, upload-time = "2026-03-06T13:47:51.249Z" }, + { url = "https://files.pythonhosted.org/packages/98/a8/2594cef906aee761601eff842c7dc598bea2b394a3e1c00966832b8eeb7c/h5py-3.16.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a6fbc5367d4046801f9b7db9191b31895f22f1c6df1f9987d667854cac493538", size = 4823472, upload-time = "2026-03-06T13:47:53.085Z" }, + { url = "https://files.pythonhosted.org/packages/52/a0/c1f604538ff6db22a0690be2dc44ab59178e115f63c917794e529356ab23/h5py-3.16.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:fb1720028d99040792bb2fb31facb8da44a6f29df7697e0b84f0d79aff2e9bd3", size = 5027150, upload-time = "2026-03-06T13:47:55.043Z" }, + { url = "https://files.pythonhosted.org/packages/2e/fd/301739083c2fc4fd89950f9bcfce75d6e14b40b0ca3d40e48a8993d1722c/h5py-3.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:314b6054fe0b1051c2b0cb2df5cbdab15622fb05e80f202e3b6a5eee0d6fe365", size = 4814544, upload-time = "2026-03-06T13:47:56.893Z" }, + { url = "https://files.pythonhosted.org/packages/4c/42/2193ed41ccee78baba8fcc0cff2c925b8b9ee3793305b23e1f22c20bf4c7/h5py-3.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ffbab2fedd6581f6aa31cf1639ca2cb86e02779de525667892ebf4cc9fd26434", size = 5034013, upload-time = "2026-03-06T13:47:59.01Z" }, + { url = "https://files.pythonhosted.org/packages/f7/20/e6c0ff62ca2ad1a396a34f4380bafccaaf8791ff8fccf3d995a1fc12d417/h5py-3.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:17d1f1630f92ad74494a9a7392ab25982ce2b469fc62da6074c0ce48366a2999", size = 3191673, upload-time = "2026-03-06T13:48:00.626Z" }, + { url = "https://files.pythonhosted.org/packages/f2/48/239cbe352ac4f2b8243a8e620fa1a2034635f633731493a7ff1ed71e8658/h5py-3.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:85b9c49dd58dc44cf70af944784e2c2038b6f799665d0dcbbc812a26e0faa859", size = 2673834, upload-time = "2026-03-06T13:48:02.579Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c0/5d4119dba94093bbafede500d3defd2f5eab7897732998c04b54021e530b/h5py-3.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5313566f4643121a78503a473f0fb1e6dcc541d5115c44f05e037609c565c4d", size = 3685604, upload-time = "2026-03-06T13:48:04.198Z" }, + { url = "https://files.pythonhosted.org/packages/b0/42/c84efcc1d4caebafb1ecd8be4643f39c85c47a80fe254d92b8b43b1eadaf/h5py-3.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:42b012933a83e1a558c673176676a10ce2fd3759976a0fedee1e672d1e04fc9d", size = 3061940, upload-time = "2026-03-06T13:48:05.783Z" }, + { url = "https://files.pythonhosted.org/packages/89/84/06281c82d4d1686fde1ac6b0f307c50918f1c0151062445ab3b6fa5a921d/h5py-3.16.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:ff24039e2573297787c3063df64b60aab0591980ac898329a08b0320e0cf2527", size = 5198852, upload-time = "2026-03-06T13:48:07.482Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e9/1a19e42cd43cc1365e127db6aae85e1c671da1d9a5d746f4d34a50edb577/h5py-3.16.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:dfc21898ff025f1e8e67e194965a95a8d4754f452f83454538f98f8a3fcb207e", size = 5405250, upload-time = "2026-03-06T13:48:09.628Z" }, + { url = "https://files.pythonhosted.org/packages/b7/8e/9790c1655eabeb85b92b1ecab7d7e62a2069e53baefd58c98f0909c7a948/h5py-3.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:698dd69291272642ffda44a0ecd6cd3bda5faf9621452d255f57ce91487b9794", size = 5190108, upload-time = "2026-03-06T13:48:11.26Z" }, + { url = "https://files.pythonhosted.org/packages/51/d7/ab693274f1bd7e8c5f9fdd6c7003a88d59bedeaf8752716a55f532924fbb/h5py-3.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2b2c02b0a160faed5fb33f1ba8a264a37ee240b22e049ecc827345d0d9043074", size = 5419216, upload-time = "2026-03-06T13:48:13.322Z" }, + { url = "https://files.pythonhosted.org/packages/03/c1/0976b235cf29ead553e22f2fb6385a8252b533715e00d0ae52ed7b900582/h5py-3.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:96b422019a1c8975c2d5dadcf61d4ba6f01c31f92bbde6e4649607885fe502d6", size = 3182868, upload-time = "2026-03-06T13:48:15.759Z" }, + { url = "https://files.pythonhosted.org/packages/14/d9/866b7e570b39070f92d47b0ff1800f0f8239b6f9e45f02363d7112336c1f/h5py-3.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:39c2838fb1e8d97bcf1755e60ad1f3dd76a7b2a475928dc321672752678b96db", size = 2653286, upload-time = "2026-03-06T13:48:17.279Z" }, + { url = "https://files.pythonhosted.org/packages/0f/9e/6142ebfda0cb6e9349c091eae73c2e01a770b7659255248d637bec54a88b/h5py-3.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:370a845f432c2c9619db8eed334d1e610c6015796122b0e57aa46312c22617d9", size = 3671808, upload-time = "2026-03-06T13:48:19.737Z" }, + { url = "https://files.pythonhosted.org/packages/b0/65/5e088a45d0f43cd814bc5bec521c051d42005a472e804b1a36c48dada09b/h5py-3.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42108e93326c50c2810025aade9eac9d6827524cdccc7d4b75a546e5ab308edb", size = 3045837, upload-time = "2026-03-06T13:48:21.854Z" }, + { url = "https://files.pythonhosted.org/packages/da/1e/6172269e18cc5a484e2913ced33339aad588e02ba407fafd00d369e22ef3/h5py-3.16.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:099f2525c9dcf28de366970a5fb34879aab20491589fa89ce2863a84218bb524", size = 5193860, upload-time = "2026-03-06T13:48:24.071Z" }, + { url = "https://files.pythonhosted.org/packages/bd/98/ef2b6fe2903e377cbe870c3b2800d62552f1e3dbe81ce49e1923c53d1c5c/h5py-3.16.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9300ad32dea9dfc5171f94d5f6948e159ed93e4701280b0f508773b3f582f402", size = 5400417, upload-time = "2026-03-06T13:48:25.728Z" }, + { url = "https://files.pythonhosted.org/packages/bc/81/5b62d760039eed64348c98129d17061fdfc7839fc9c04eaaad6dee1004e4/h5py-3.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:171038f23bccddfc23f344cadabdfc9917ff554db6a0d417180d2747fe4c75a7", size = 5185214, upload-time = "2026-03-06T13:48:27.436Z" }, + { url = "https://files.pythonhosted.org/packages/28/c4/532123bcd9080e250696779c927f2cb906c8bf3447df98f5ceb8dcded539/h5py-3.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7e420b539fb6023a259a1b14d4c9f6df8cf50d7268f48e161169987a57b737ff", size = 5414598, upload-time = "2026-03-06T13:48:29.49Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/a27997f84341fc0dfcdd1fe4179b6ba6c32a7aa880fdb8c514d4dad6fba3/h5py-3.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:18f2bbcd545e6991412253b98727374c356d67caa920e68dc79eab36bf5fedad", size = 3175509, upload-time = "2026-03-06T13:48:31.131Z" }, + { url = "https://files.pythonhosted.org/packages/a5/23/bb8647521d4fd770c30a76cfc6cb6a2f5495868904054e92f2394c5a78ff/h5py-3.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:656f00e4d903199a1d58df06b711cf3ca632b874b4207b7dbec86185b5c8c7d4", size = 2647362, upload-time = "2026-03-06T13:48:33.411Z" }, + { url = "https://files.pythonhosted.org/packages/48/3c/7fcd9b4c9eed82e91fb15568992561019ae7a829d1f696b2c844355d95dd/h5py-3.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9c9d307c0ef862d1cd5714f72ecfafe0a5d7529c44845afa8de9f46e5ba8bd65", size = 3678608, upload-time = "2026-03-06T13:48:35.183Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b7/9366ed44ced9b7ef357ab48c94205280276db9d7f064aa3012a97227e966/h5py-3.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8c1eff849cdd53cbc73c214c30ebdb6f1bb8b64790b4b4fc36acdb5e43570210", size = 3054773, upload-time = "2026-03-06T13:48:37.139Z" }, + { url = "https://files.pythonhosted.org/packages/58/a5/4964bc0e91e86340c2bbda83420225b2f770dcf1eb8a39464871ad769436/h5py-3.16.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:e2c04d129f180019e216ee5f9c40b78a418634091c8782e1f723a6ca3658b965", size = 5198886, upload-time = "2026-03-06T13:48:38.879Z" }, + { url = "https://files.pythonhosted.org/packages/f1/16/d905e7f53e661ce2c24686c38048d8e2b750ffc4350009d41c4e6c6c9826/h5py-3.16.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:e4360f15875a532bc7b98196c7592ed4fc92672a57c0a621355961cafb17a6dd", size = 5404883, upload-time = "2026-03-06T13:48:41.324Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f2/58f34cb74af46d39f4cd18ea20909a8514960c5a3e5b92fd06a28161e0a8/h5py-3.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3fae9197390c325e62e0a1aa977f2f62d994aa87aab182abbea85479b791197c", size = 5192039, upload-time = "2026-03-06T13:48:43.117Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ca/934a39c24ce2e2db017268c08da0537c20fa0be7e1549be3e977313fc8f5/h5py-3.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:43259303989ac8adacc9986695b31e35dba6fd1e297ff9c6a04b7da5542139cc", size = 5421526, upload-time = "2026-03-06T13:48:44.838Z" }, + { url = "https://files.pythonhosted.org/packages/3e/14/615a450205e1b56d16c6783f5ccd116cde05550faad70ae077c955654a75/h5py-3.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:fa48993a0b799737ba7fd21e2350fa0a60701e58180fae9f2de834bc39a147ab", size = 3183263, upload-time = "2026-03-06T13:48:47.117Z" }, + { url = "https://files.pythonhosted.org/packages/7b/48/a6faef5ed632cae0c65ac6b214a6614a0b510c3183532c521bdb0055e117/h5py-3.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:1897a771a7f40d05c262fc8f37376ec37873218544b70216872876c627640f63", size = 2663450, upload-time = "2026-03-06T13:48:48.707Z" }, + { url = "https://files.pythonhosted.org/packages/5d/32/0c8bb8aedb62c772cf7c1d427c7d1951477e8c2835f872bc0a13d1f85f86/h5py-3.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:15922e485844f77c0b9d275396d435db3baa58292a9c2176a386e072e0cf2491", size = 3760693, upload-time = "2026-03-06T13:48:50.453Z" }, + { url = "https://files.pythonhosted.org/packages/1d/1f/fcc5977d32d6387c5c9a694afee716a5e20658ac08b3ff24fdec79fb05f2/h5py-3.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:df02dd29bd247f98674634dfe41f89fd7c16ba3d7de8695ec958f58404a4e618", size = 3181305, upload-time = "2026-03-06T13:48:52.221Z" }, + { url = "https://files.pythonhosted.org/packages/f5/a1/af87f64b9f986889884243643621ebbd4ac72472ba8ec8cec891ac8e2ca1/h5py-3.16.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:0f456f556e4e2cebeebd9d66adf8dc321770a42593494a0b6f0af54a7567b242", size = 5074061, upload-time = "2026-03-06T13:48:54.089Z" }, + { url = "https://files.pythonhosted.org/packages/cc/d0/146f5eaff3dc246a9c7f6e5e4f42bd45cc613bce16693bcd4d1f7c958bf5/h5py-3.16.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:3e6cb3387c756de6a9492d601553dffea3fe11b5f22b443aac708c69f3f55e16", size = 5279216, upload-time = "2026-03-06T13:48:56.75Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9d/12a13424f1e604fc7df9497b73c0356fb78c2fb206abd7465ce47226e8fd/h5py-3.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8389e13a1fd745ad2856873e8187fd10268b2d9677877bb667b41aebd771d8b7", size = 5070068, upload-time = "2026-03-06T13:48:59.169Z" }, + { url = "https://files.pythonhosted.org/packages/41/8c/bbe98f813722b4873818a8db3e15aa3e625b59278566905ac439725e8070/h5py-3.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:346df559a0f7dcb31cf8e44805319e2ab24b8957c45e7708ce503b2ec79ba725", size = 5300253, upload-time = "2026-03-06T13:49:02.033Z" }, + { url = "https://files.pythonhosted.org/packages/32/9e/87e6705b4d6890e7cecdf876e2a7d3e40654a2ae37482d79a6f1b87f7b92/h5py-3.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4c6ab014ab704b4feaa719ae783b86522ed0bf1f82184704ed3c9e4e3228796e", size = 3381671, upload-time = "2026-03-06T13:49:04.351Z" }, + { url = "https://files.pythonhosted.org/packages/96/91/9fad90cfc5f9b2489c7c26ad897157bce82f0e9534a986a221b99760b23b/h5py-3.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:faca8fb4e4319c09d83337adc80b2ca7d5c5a343c2d6f1b6388f32cfecca13c1", size = 2740706, upload-time = "2026-03-06T13:49:06.347Z" }, +] + [[package]] name = "hf-xet" version = "1.2.0" @@ -398,6 +1119,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, ] +[[package]] +name = "httpx-sse" +version = "0.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" }, +] + [[package]] name = "huggingface-hub" version = "1.4.1" @@ -470,6 +1200,96 @@ 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 = "jiter" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/b5/55f06bb281d92fb3cc86d14e1def2bd908bb77693183e7cb1f5a3c388b0c/jiter-0.15.0.tar.gz", hash = "sha256:4251acc80e2b7c9b7b8823456ea0fceeb0734dac2df7636d3c711b38476b5a76", size = 166640, upload-time = "2026-05-19T10:09:48.361Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/13/daa722f5765c393576f466378f9dfd29d77c9bed939e0688f96afa3601ea/jiter-0.15.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0f862193b8696249d22ec433e85fd2ab0ad9596bc3e45e6c0bc55e8aeba97be2", size = 310899, upload-time = "2026-05-19T10:07:12.89Z" }, + { url = "https://files.pythonhosted.org/packages/7f/82/2d2551829b082f4b6d82b9f939b031fb808a10aab1ec0664f82e150bb9a2/jiter-0.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1303d4d68a9b051ea90502402063ecf3807da00ad2affa19ca1ae3b90b3c5f67", size = 314963, upload-time = "2026-05-19T10:07:14.539Z" }, + { url = "https://files.pythonhosted.org/packages/2a/0a/8b1a51466f7fe9f31dbe4bc7e0ca848674f9825e0f737b929b97e8c60aa7/jiter-0.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:392b8ab019e5502d08aff85c6272209c24bc2cbe706ea82a56368f524236614a", size = 341730, upload-time = "2026-05-19T10:07:15.869Z" }, + { url = "https://files.pythonhosted.org/packages/f6/2a/e71dea19822e2e404e83992a08c1d6b9b617bb944f28c9c2fbd85d02c91e/jiter-0.15.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:773b6eb282ce11ee19f05f6b2d4404fa308e5bbd353b0b80a0262caad6db2cd7", size = 366214, upload-time = "2026-05-19T10:07:17.259Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/97e1fa539d124a509a00ab7f669289d1c1d236ecabf12948a18f16c91082/jiter-0.15.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2c0c44d569ce0f2850f5c926f8caeb5f245fbc84475aeb36efccc2103e6dbd", size = 459527, upload-time = "2026-05-19T10:07:18.741Z" }, + { url = "https://files.pythonhosted.org/packages/d1/7a/4a68d331aef8cf2e2393c14a3aacb635c62aa86071b0229899fb5baaa907/jiter-0.15.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:032396229564bca02440396bd327710719f724f5e7b7e9f7a8eb3faa4a2c2281", size = 375451, upload-time = "2026-05-19T10:07:20.208Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7e/1c445c2b6f0e30a274dc8082e0c3c7825411cce80d726bccd697c98cc8d3/jiter-0.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3d37768fce7f88dd2a8c6091f2325dea27d30d30d5c6e7a1c0f0af77723b708", size = 349428, upload-time = "2026-05-19T10:07:22.372Z" }, + { url = "https://files.pythonhosted.org/packages/00/94/e20d38984fc17a636371bffd2ae0f698124fdc8e75ef969cd2da6ba7cea7/jiter-0.15.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:2c9cb907439d20bd0c7d7565ca01ee52234203208433749bae5b516907526928", size = 355405, upload-time = "2026-05-19T10:07:23.916Z" }, + { url = "https://files.pythonhosted.org/packages/94/fa/4d09f814779d0ea80a28ed8e4c6662ec9a4a8ecef0ac52190ebac6262d14/jiter-0.15.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9100ddbec09741cc66feb0fc6773f8bdbd0e3c345689368f260082ff85dcc0cd", size = 393688, upload-time = "2026-05-19T10:07:25.854Z" }, + { url = "https://files.pythonhosted.org/packages/54/9d/8eb5d4fb8bf7e93a75964a5da71a75c67c864baf7fa3f98598187b3c7e57/jiter-0.15.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ae1b0d82ac2d987f9ea512b1c9adfcc71a28de3dea3a6039b54d76cffda9901e", size = 520853, upload-time = "2026-05-19T10:07:27.303Z" }, + { url = "https://files.pythonhosted.org/packages/e7/2c/5e07874e59e623a943a0acf1552a80d05b70f31b402287a8fc6d7ec634c7/jiter-0.15.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8020c99ec13a7db2b6f96cbe82ef4721c88b426a4892f27478044af0284615ef", size = 551016, upload-time = "2026-05-19T10:07:28.846Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/d2d34422143474cadc15b60d482b1c35683dbc5c63c24346ddd0df09bcaf/jiter-0.15.0-cp311-cp311-win32.whl", hash = "sha256:42bfb257930800cf43e7c62c832402c704ab60797c992faf88d20e903eac8f32", size = 209518, upload-time = "2026-05-19T10:07:30.431Z" }, + { url = "https://files.pythonhosted.org/packages/1d/7d/52778b930e5cc3e52a37d950b1c10494244308b4329b25a0ff0d88303a81/jiter-0.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:860a74063284a2ae9bfedd694f299cc2c68e2696c5f3d440cc9d18bb81b9dd04", size = 200565, upload-time = "2026-05-19T10:07:32.125Z" }, + { url = "https://files.pythonhosted.org/packages/3b/4f/d9b4067feb69b3fa6eb0488e1b59e2ad5b463fe39f59e527eab2aca00bb0/jiter-0.15.0-cp311-cp311-win_arm64.whl", hash = "sha256:37a10c377ce3a4a85f4a67f28b7afe093154cde77eaf248a72e856aa08b4d865", size = 195488, upload-time = "2026-05-19T10:07:33.846Z" }, + { url = "https://files.pythonhosted.org/packages/44/53/4f6bddbcde3c71e56d0aa1337ec95950f3d27dd4153e25aadf0feac71751/jiter-0.15.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0e90a1c315a0226ec822d973817967f9223b7701546c8c2a7913e7ab0926294d", size = 308793, upload-time = "2026-05-19T10:07:35.25Z" }, + { url = "https://files.pythonhosted.org/packages/01/84/c01099b59a285a1ebba64ae93f62bfa036675340fd1b0045ae65890a0442/jiter-0.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8c9004af7c8d67cce7f1aae1026fb55607f4aa600710d08ede3a3ce4aeefe7e0", size = 309570, upload-time = "2026-05-19T10:07:36.919Z" }, + { url = "https://files.pythonhosted.org/packages/58/64/8fb7f9d45bb98190355454cd04dad8d8f27223d6bd52f83af07f637168a6/jiter-0.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c210f8b35dc6f30aafd4b4365ca89b9d1189f21ab49b8e68fa6322a847aef138", size = 336783, upload-time = "2026-05-19T10:07:38.694Z" }, + { url = "https://files.pythonhosted.org/packages/c3/b6/f5739011d009b3a30f6a53c5240979030ba29ae46a8c67e3a15759f7c37d/jiter-0.15.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f30bae8bc1c2d613e28e5af3e8cceb09b742f1c8a8a5f839fb67afaffc03b61", size = 363555, upload-time = "2026-05-19T10:07:40.832Z" }, + { url = "https://files.pythonhosted.org/packages/e5/12/98a9d9f766665e8a3b6252454e17cb0c464606a28cf2fa09399b003345fa/jiter-0.15.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c60e71b6d10cfc284c9bf36bd885e8d44c46f688ce50aa91b5edd90181dea687", size = 452255, upload-time = "2026-05-19T10:07:42.62Z" }, + { url = "https://files.pythonhosted.org/packages/e8/d5/60f972840f79c5e7544fce567c56f1e4e50468f996baba3e78d823dd62a6/jiter-0.15.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ab068bce62a45aa3e7367eceaffb5dde60b7eb853be8dece45132e3d0ff4879", size = 373559, upload-time = "2026-05-19T10:07:44.201Z" }, + { url = "https://files.pythonhosted.org/packages/ee/cf/d46ef1234ba335aabc2f013210db8e0821a22f5e644a2e9449df199ecc23/jiter-0.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa248c9eb220197d363f688818dac2fd4b2f0cd7d843ca7105d652034823427d", size = 346055, upload-time = "2026-05-19T10:07:46.005Z" }, + { url = "https://files.pythonhosted.org/packages/f0/63/4d2749d8d54d230bad9b3a6b0d00cc28c6ff6b2fdffc26a8ccf76cc5a974/jiter-0.15.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2a77aadd57cac1682e4401a72724d2796d89a4ba129b1a5812aa94ee480826eb", size = 351406, upload-time = "2026-05-19T10:07:47.855Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b9/9965b990035d8773328e0a8c8b457a87bf2b19f6c4126d9d99296be5d16a/jiter-0.15.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2ae901f3a55bfafdde31d289590fa25e3245735a2b1e8c7cc15871710a002871", size = 389357, upload-time = "2026-05-19T10:07:49.665Z" }, + { url = "https://files.pythonhosted.org/packages/2d/55/9ddf903deda1413e87fed792f416b7123daee5b8efbad6a202a7421c36a5/jiter-0.15.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f0b271b462769543716f92d3a4f90527df6ef5ed05ee95ec4137f513e21e1b77", size = 517263, upload-time = "2026-05-19T10:07:51.537Z" }, + { url = "https://files.pythonhosted.org/packages/e8/76/a0c40ad064d3a20a4fde231e35d56e9a01ce82164278180e82d5daf85469/jiter-0.15.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2fb6a5d26af81fc0f00f9360a891e05cf755e149bba391c4d563adc54812973d", size = 548646, upload-time = "2026-05-19T10:07:53.196Z" }, + { url = "https://files.pythonhosted.org/packages/23/4f/eca9b954942916ba2f453891b8593ab444cd872396fe66a3936616f236f3/jiter-0.15.0-cp312-cp312-win32.whl", hash = "sha256:c2f6bb8b5216ab9e7873bc08b5d7bef2b8abbb578a3069bf1cd14a45d71d771d", size = 206427, upload-time = "2026-05-19T10:07:55.307Z" }, + { url = "https://files.pythonhosted.org/packages/95/bf/8ead82a87495149542748e828d153fd232a512a22c83b02c4815c1a9c7d8/jiter-0.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:40b2c7e92c44a84d748d21706c68dc6ff8161d80b59c99d774721a0d2317d7c7", size = 197300, upload-time = "2026-05-19T10:07:56.651Z" }, + { url = "https://files.pythonhosted.org/packages/f4/e4/9b8a78fb2d894471bc344e37f1949bdd784bd914d031dba0ba3a40c71dd7/jiter-0.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:cc0bc345cf2df9d1c00ac443f50d543c1ccfa8b0422cb85b1ab70d681c0b255b", size = 192702, upload-time = "2026-05-19T10:07:58.307Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f4/f708c900ecee41b2025ef8413d5351e5649eb2125c506f6720cc69b06f5c/jiter-0.15.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1c11465f97e2abf45a014b83b730222f8f1c5335e802c7055a67d50de6f1f4e3", size = 307829, upload-time = "2026-05-19T10:07:59.704Z" }, + { url = "https://files.pythonhosted.org/packages/86/59/db537c0949e83668c38481d426b9f2fd5ab758c4ee53a811dd0a510626a0/jiter-0.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d1e7b1776f0797956c509e123d0952d10d293a9492dea9f288ab9570ec01d1a5", size = 308445, upload-time = "2026-05-19T10:08:01.184Z" }, + { url = "https://files.pythonhosted.org/packages/37/38/ea0e13b18c30ef951da0d47d39e7fa9edb82a93a62990ffbd7cea9b622d4/jiter-0.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:351a341c2105aa430b7047e30f1bf7975f6313b00165d3fc07be2edaf741f279", size = 336181, upload-time = "2026-05-19T10:08:02.688Z" }, + { url = "https://files.pythonhosted.org/packages/58/fc/2303901b16c4ba05865588990a420c0b4156270b44379c20931544a1d962/jiter-0.15.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4ab395feec8d249ec4044e228e98a7033f043426a265df439dc3698823f0a4e4", size = 362985, upload-time = "2026-05-19T10:08:04.394Z" }, + { url = "https://files.pythonhosted.org/packages/5b/6f/11bace093c52e7d4d26c8e606ccd7ae8c972189622469ec0d9e28161e28b/jiter-0.15.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a2a438005b6f22d0273413484d6094d7c2c5d10ec1b3a3bf128e0d1d3ba53258", size = 453292, upload-time = "2026-05-19T10:08:05.967Z" }, + { url = "https://files.pythonhosted.org/packages/22/db/987f2f086ca4d7a6582eb4ccd513f9b26b42d9e4243a087609a3137a8fc7/jiter-0.15.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f18f85e4218d1b40f000f42a92239a7a61a902cd42c65e6c360dbd17dcb20894", size = 373501, upload-time = "2026-05-19T10:08:07.857Z" }, + { url = "https://files.pythonhosted.org/packages/8f/7c/89fbcabb2739b7a5b8dc959a1b6c5761f6484f5fed3486854b3c789bb1de/jiter-0.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1aa62e277fc1cbd80e6deacae6f4d983b41b3d7728e0645c5d741a6149bba45", size = 344683, upload-time = "2026-05-19T10:08:09.431Z" }, + { url = "https://files.pythonhosted.org/packages/30/6f/6cca7692e7dddfec6d8d76c54dc97f2af2a41df4ac0674b999df1f09a5f3/jiter-0.15.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:6550fa135c7deb8ead6af49ed7ff648532ea8334a1447fe34a36315ef79c5c29", size = 350892, upload-time = "2026-05-19T10:08:11.352Z" }, + { url = "https://files.pythonhosted.org/packages/39/14/0338d6190cb8e6d22e677ab1d4eabd4117f67cca70c54cd04b82ff64e068/jiter-0.15.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:066f8f33f18b2419cd8213b2436fa7fbc9c499f315971cfa3ce1f9820c001b1b", size = 388723, upload-time = "2026-05-19T10:08:12.912Z" }, + { url = "https://files.pythonhosted.org/packages/90/31/cc19f4a1bdb6afb09ce6a2f2615aa8d44d994eba0d8e6105ed1af920e736/jiter-0.15.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:75e8a04e91432dde9f1838373cf93d23726c79d3e908d319acf0e796f85592e7", size = 516648, upload-time = "2026-05-19T10:08:14.808Z" }, + { url = "https://files.pythonhosted.org/packages/49/9f/833c541512cd091b63c10c0381973dfe11bc7a503a818c16384417e0c81e/jiter-0.15.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:a97261f1fccb8e50ecd2890a96e46efdc3f57c80a197324c6777827231eca712", size = 547382, upload-time = "2026-05-19T10:08:16.927Z" }, + { url = "https://files.pythonhosted.org/packages/d2/11/e7b70e91f90bc4477e8eee9e8a5f7cf3cb41b4525d6394dc98a714eb8f7f/jiter-0.15.0-cp313-cp313-win32.whl", hash = "sha256:c77496cb10bd7549690fbbab3e5ec05857b83e49276f4a9423a766ddd2afcd4c", size = 205845, upload-time = "2026-05-19T10:08:18.401Z" }, + { url = "https://files.pythonhosted.org/packages/4b/23/5c20d9ad6f02c493e4023e5d2d09e1c1f15fe2753c9102c544aff068a88e/jiter-0.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b15741f501469009ae0ae90b7147958a664a7dede40aa7ff174a8a4645f546d0", size = 196842, upload-time = "2026-05-19T10:08:20.131Z" }, + { url = "https://files.pythonhosted.org/packages/6b/11/1eb400ef248e8c925fd883fbe325daf5e42cd1b0d308539dd332bd4f7ffc/jiter-0.15.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d6a60072b44c3c2b797a7ddcbcbbf2b34ea3cfd4721580fbfd2a09d9d9b84ba", size = 192212, upload-time = "2026-05-19T10:08:21.807Z" }, + { url = "https://files.pythonhosted.org/packages/8a/60/2fd8d7c79da8acf9b7b277c7616847773779356b92acfc9bb158452174da/jiter-0.15.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ef1fd24d9413f6209e00d3d5a453e67acfe004a25cc6c8e8484faed4311ab9e8", size = 315065, upload-time = "2026-05-19T10:08:23.218Z" }, + { url = "https://files.pythonhosted.org/packages/46/f4/008fb7d65e8ac2abf00811651a661e025c4ba80bbc6f378450384ddd3aed/jiter-0.15.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:144f8e72cb53dab146347b91cceac01f5481237f2b93b4a339a1ee8f8878b67c", size = 339444, upload-time = "2026-05-19T10:08:24.701Z" }, + { url = "https://files.pythonhosted.org/packages/00/55/90b0c7b9c6896c0f2a591dd36d36b71d22e09674bfef178fa03ba3f81499/jiter-0.15.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:553fcac2ef2cb990877f9fc0833b8b629a3e6a5670b6b5fd58219b41a653ddc4", size = 347779, upload-time = "2026-05-19T10:08:26.408Z" }, + { url = "https://files.pythonhosted.org/packages/51/6b/69666cec5000fd57734c118437394516c749ae8dbeea9fb66d6fef9c4775/jiter-0.15.0-cp313-cp313t-win_amd64.whl", hash = "sha256:774f93f65031856bf14ad9f59bdcab8b8cad501e5ceabd51ba3525f76937a25b", size = 200395, upload-time = "2026-05-19T10:08:28.055Z" }, + { url = "https://files.pythonhosted.org/packages/39/04/a6aa62cd27e8149b0d28df5561f10f6cceaf7935a9ccf3f1c5a05f9a0cd8/jiter-0.15.0-cp313-cp313t-win_arm64.whl", hash = "sha256:f1e1754960f38ec40613a07e5e372df67acb3b890fb383b6fb3de3e49ddbf3c7", size = 190516, upload-time = "2026-05-19T10:08:29.35Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/079f350ebf7859d081de30aa890f9e3be68516f754f3ba32366ffff4dcee/jiter-0.15.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:ac0d9ddea4350974be7a221fc25895f251a8fee748c889bdced2141c0fec1a49", size = 308884, upload-time = "2026-05-19T10:08:31.667Z" }, + { url = "https://files.pythonhosted.org/packages/04/4e/a2c30a7f69b48c03b20935d647479106fe932f6e63f75faf53937197e05d/jiter-0.15.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:01a8222cf05ab1128e239421156c207949808acaaea2bdfd33130ae666786e86", size = 310028, upload-time = "2026-05-19T10:08:33.304Z" }, + { url = "https://files.pythonhosted.org/packages/40/90/2e7cdfd3cf8ca967be38c48f5cf474d79f089efaf559a40f15984a77ae69/jiter-0.15.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:182226cbc930c9fab81bc2e41a4da672f89539906dadb05e75670ac07b94f71f", size = 337485, upload-time = "2026-05-19T10:08:35.259Z" }, + { url = "https://files.pythonhosted.org/packages/9b/11/15a1aa28b120b8ee5b4f1fb894c125046225f09847738bd64233d3b84883/jiter-0.15.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:71683c38c825452999b5717fcae07ea708e8c93003e808be4319c1b02e3d176e", size = 364223, upload-time = "2026-05-19T10:08:36.694Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/f442e8af5f3d0dcf47b39e83a0efd9ee45ea946aa6d04625dc3181eae3b6/jiter-0.15.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30f2218e6a9e5c18bc10fe6d41ac189c442c88eacf11bad9f28ef95a9bef00e6", size = 456387, upload-time = "2026-05-19T10:08:38.143Z" }, + { url = "https://files.pythonhosted.org/packages/da/f4/37f2d2c9f64f49af7da652ed7532bb5a2372e588e6927c3fdd76f911db65/jiter-0.15.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5157de9f76eb4bc5ea74a1219366a25f945ad305641d74e04f59c54087091aa9", size = 374461, upload-time = "2026-05-19T10:08:39.869Z" }, + { url = "https://files.pythonhosted.org/packages/60/28/edcfbbbf0cb15436f36664a8908a0df47ab9006298d4cd937dc08ea932d6/jiter-0.15.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90c5db5527c221249a876160663ab891ace358c17f7b9c93ec1478b7f0550e5c", size = 345924, upload-time = "2026-05-19T10:08:41.668Z" }, + { url = "https://files.pythonhosted.org/packages/47/13/89fba6398dab7f202b7278c4b4aac122399d2c0183971c4a57a3b7088df5/jiter-0.15.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:3e4540b8e74e4268811ac05db226a6a128ff572e7e0ce3f1163b693cadb184cd", size = 352283, upload-time = "2026-05-19T10:08:43.091Z" }, + { url = "https://files.pythonhosted.org/packages/1b/da/0f6af8cef2c565a1ab44d970f268c43ccaa72707386ea6388e6fe2b6cd26/jiter-0.15.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:62ebd14e47e9aed9df4472afcb2663668ce4d74891cd54f86bf6e44029d6dc89", size = 389985, upload-time = "2026-05-19T10:08:44.915Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ec/b9cb7d6d29e24ee14910266157d2a279d7a8f60ee0df7fa840882976ba64/jiter-0.15.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0be6f5ad41a809f303f416d17cec92a7a725902fb9b4f3de3d19362ac0ef8554", size = 517695, upload-time = "2026-05-19T10:08:46.486Z" }, + { url = "https://files.pythonhosted.org/packages/64/5e/6d1bda880723aae0ad86b4b763f044362448efe31e3e819635d41cb03451/jiter-0.15.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:813dfbb17d65328bf86e5f0905dd277ba2265d3ca20556e86c0c7035b7182e5a", size = 548868, upload-time = "2026-05-19T10:08:48.026Z" }, + { url = "https://files.pythonhosted.org/packages/0c/72/7de501cf38dcacaf35098796f3a50e0f2e338baba18a58946c618544b809/jiter-0.15.0-cp314-cp314-win32.whl", hash = "sha256:50e51156192722a9c58db112837d3f8ef96fb3c5ecc14e95f409134b08b158ec", size = 206380, upload-time = "2026-05-19T10:08:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/1e/a9/e19addf4b0c1bdce52c6da12351e6bc42c340c45e7c09e2158e46d293ccc/jiter-0.15.0-cp314-cp314-win_amd64.whl", hash = "sha256:30ce1a5d16b5641dc935d50ef775af6a0871e3d14ab05d6fc54dff371b78e558", size = 197687, upload-time = "2026-05-19T10:08:51.088Z" }, + { url = "https://files.pythonhosted.org/packages/f2/c9/776b1db01db25fc6c1d58d1979a37b0a9fe787e5f5b1d062d2eaacb77923/jiter-0.15.0-cp314-cp314-win_arm64.whl", hash = "sha256:510c8b3c17a0ed9ac69850c0438dada3c9b82d9c4d589fcb62002a5a9cf3a866", size = 192571, upload-time = "2026-05-19T10:08:52.451Z" }, + { url = "https://files.pythonhosted.org/packages/a0/f6/45bb4670bacf300fd2c7abadbfb3af376e5f1b6ae75fd9bc069891d15870/jiter-0.15.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7553333dd0930c104a5a0db8df72bf7219fe663d731383b576bb6ed6351c984d", size = 317151, upload-time = "2026-05-19T10:08:53.867Z" }, + { url = "https://files.pythonhosted.org/packages/d7/68/ed635ad5acd7b73e454283083bbb7c8205ad10e88b0d9d7d793b09fe8226/jiter-0.15.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2143ab06181d2b029eedcb6af3cebe95f11bbac62441781860f98ee9330a6a6", size = 341243, upload-time = "2026-05-19T10:08:55.383Z" }, + { url = "https://files.pythonhosted.org/packages/5d/db/3ff4176b817b8ea33879e71e13d8bc2b0d481a7ed3fe9e080f333d415c16/jiter-0.15.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6eac374c5c975709b69c10f09afd199df74150172156ad10c8d4fd785b7da995", size = 363629, upload-time = "2026-05-19T10:08:56.928Z" }, + { url = "https://files.pythonhosted.org/packages/ab/24/5f8270e0ba9c883582f96f722f8a0b58015c7ce1f8c6d4571cf394e99b6b/jiter-0.15.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b3b3b775e33d3bfaec9899edc526ae97b0da0bf9d071a46124ba419149a414f8", size = 456198, upload-time = "2026-05-19T10:08:58.618Z" }, + { url = "https://files.pythonhosted.org/packages/45/5b/76fc02b0b5c54c3d18c60653156e2f76fde1816f9b4722db68d6ee2c897e/jiter-0.15.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3071db3346334beae1360b46da4606da57bf3528c167b3c38533afaf9f2c5", size = 373710, upload-time = "2026-05-19T10:09:00.151Z" }, + { url = "https://files.pythonhosted.org/packages/c4/52/4310821b0ea9277994d3e1f49fc6a4b34e4800caebacb2c0af81da59a454/jiter-0.15.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6694a173ecabc12eb60efbc0b474464ead1951ff65cd8b1e72100715c64512b", size = 349901, upload-time = "2026-05-19T10:09:01.621Z" }, + { url = "https://files.pythonhosted.org/packages/93/fe/67648c35b3594fba8854ac64cc8a826d8bcd18324bbdb53d77697c60b6ef/jiter-0.15.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:a254e10b593624d230c365b6d616b22ca0ad65e63a16e6631c2b3466022e6ba8", size = 352438, upload-time = "2026-05-19T10:09:03.216Z" }, + { url = "https://files.pythonhosted.org/packages/cb/28/0a1879d07ad6b3e025a2750027363452ced93c2d16d1c9d4b153ffd51c91/jiter-0.15.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d8d2955167274e15d79a7a020afdd9b39c990eb80b2d89fca695d92dcfdd38ec", size = 388152, upload-time = "2026-05-19T10:09:04.741Z" }, + { url = "https://files.pythonhosted.org/packages/c1/78/46c6f6b56ba85c90021f4afd72ed42f691f8f84daacb5fe27277070e3858/jiter-0.15.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:acf4ee4d1fc55917239fe72972fb292dd773055d05eb040d36f4326e02cc2c0e", size = 517707, upload-time = "2026-05-19T10:09:06.231Z" }, + { url = "https://files.pythonhosted.org/packages/ca/cb/720662d4c88fcad606e826fef5424365527ba43ce4868a479aed8f8c507e/jiter-0.15.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:e7196e56f1cd69af1dbb07dff02dcfb260a50b45a82d409d92a06fedb32473b5", size = 548241, upload-time = "2026-05-19T10:09:08.093Z" }, + { url = "https://files.pythonhosted.org/packages/60/e3/935b8034fd143f21125c87d51404a9e0e1449186a494405721ff5d1d695e/jiter-0.15.0-cp314-cp314t-win32.whl", hash = "sha256:7f6163c0f10b055245f814dcc59f4818da60dfe72f3e72ab89fc24b6bd5e9c52", size = 207950, upload-time = "2026-05-19T10:09:09.616Z" }, + { url = "https://files.pythonhosted.org/packages/93/59/984fd9ece895953dad3e0880a650e766f5a2da2c5514f0eafdaaabbeb5f9/jiter-0.15.0-cp314-cp314t-win_amd64.whl", hash = "sha256:980c256edb05b78a111b99c4de3b1d32e31634b867fd1fc2cf726e7b7bba9854", size = 200055, upload-time = "2026-05-19T10:09:11.367Z" }, + { url = "https://files.pythonhosted.org/packages/0e/a4/cf8d779feb133a27a2e3bc833bccb9e13aa332cdf820497ebf72c10ce8c3/jiter-0.15.0-cp314-cp314t-win_arm64.whl", hash = "sha256:66b1880df2d01e206e8339769d1c7c1753bcb653efd6289e203f6f24ebada0c0", size = 191244, upload-time = "2026-05-19T10:09:12.74Z" }, + { url = "https://files.pythonhosted.org/packages/65/43/1fc62172aa98b50a7de9a25554060db510f85c89cfbed0dfe13e1907a139/jiter-0.15.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:411fa4dfa5a7ae3d11491027ffb9beadec3996010a986862db70d91abba1c750", size = 305585, upload-time = "2026-05-19T10:09:35.995Z" }, + { url = "https://files.pythonhosted.org/packages/e8/c4/dd58fcd9e2df83666e5c1c1347bef58ce919cd8efc3ffa38aeea62ce493b/jiter-0.15.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:2b0074e2f56eb2dacca1689760fd2852a068f85a0547a157b82cb4cafeb6768b", size = 306936, upload-time = "2026-05-19T10:09:37.435Z" }, + { url = "https://files.pythonhosted.org/packages/39/86/b695e16f1180c07f43ea98e73ecd21cf63fa2e1b0c1103739013784d11ae/jiter-0.15.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:913d02d29c9606643418d9ccfc3b72492ab25a6bf7889934e09a3490f8d3438b", size = 342453, upload-time = "2026-05-19T10:09:39.294Z" }, + { url = "https://files.pythonhosted.org/packages/34/56/55d76614af37fe3f22a3347d1e410d2a15da581997cb2da499a625000bb5/jiter-0.15.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b15d3ec9b0449c40e85319bdb4caa8b77ab526e74f5532ed94bec15e2f66822c", size = 345606, upload-time = "2026-05-19T10:09:40.727Z" }, + { url = "https://files.pythonhosted.org/packages/73/38/505941b2b092fd5bbbd60a52a880db1173f1690ae6751bed3af1c9ddcb4e/jiter-0.15.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:631f13a3d04e97d4e083993b10f4b99530e3a10d953e2eb5e196b7dc7f812ce0", size = 303769, upload-time = "2026-05-19T10:09:42.203Z" }, + { url = "https://files.pythonhosted.org/packages/e7/95/a06692b29e77473f286e1ec1f426d3ca44d7b5843be8ad21d7a5f3fcdcc0/jiter-0.15.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:b6c0ffae686c39bf3737be60793783267628783ea42545632c10b291105aee45", size = 305128, upload-time = "2026-05-19T10:09:43.657Z" }, + { url = "https://files.pythonhosted.org/packages/23/85/7270d7ad41d6061a25b950c6bf91d638bd9aacb113200a8c8d57a055fd67/jiter-0.15.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d54fb5b31dea401a41af3f8a7d2512e9b6a6a005491e6166c7e4ffab9639a9c", size = 340459, upload-time = "2026-05-19T10:09:45.452Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8d/302cb2057b7513327b4d575cff6b1d066ee6431a5357fc3f8867cd684406/jiter-0.15.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d5d6090cdc1b7c9e780dfb04949a990adb1e301a2fc0bbcee7de4638d33f9a", size = 344469, upload-time = "2026-05-19T10:09:46.864Z" }, +] + [[package]] name = "joblib" version = "1.5.3" @@ -479,6 +1299,139 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" }, ] +[[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]] +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 = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, + { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, + { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, + { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, +] + [[package]] name = "librt" version = "0.8.1" @@ -638,6 +1591,95 @@ 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.10.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/8c/290f021104741fea63769c31494f5324c0cd249bf536a65a4350767b1f22/matplotlib-3.10.9-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:68cfdcede415f7c8f5577b03303dd94526cdb6d11036cecdc205e08733b2d2bb", size = 8306860, upload-time = "2026-04-24T00:12:01.207Z" }, + { url = "https://files.pythonhosted.org/packages/51/18/325cd32ece1120d1da51cc4e4294c6580190699490183fc2fe8cb6d61ec5/matplotlib-3.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfca0129678bd56379db26c52b5d77ed7de314c047492fbdc763aa7501710cfb", size = 8199254, upload-time = "2026-04-24T00:12:04.239Z" }, + { url = "https://files.pythonhosted.org/packages/79/db/e28c1b83e3680740aa78925f5fb2ae4d16207207419ad75ea9fe604f8676/matplotlib-3.10.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e436d155fa8a3399dc62683f8f5d0e2e50d25d0144a73edd73f82eec8f4abfb", size = 8777092, upload-time = "2026-04-24T00:12:06.793Z" }, + { url = "https://files.pythonhosted.org/packages/55/fa/3ce7adfe9ba101748f465211660d9c6374c876b671bdb8c2bb6d347e8b94/matplotlib-3.10.9-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56fc0bd271b00025c6edfdc7c2dcd247372c8e1544971d62e1dc7c17367e8bf9", size = 9595691, upload-time = "2026-04-24T00:12:09.706Z" }, + { url = "https://files.pythonhosted.org/packages/36/c4/6960a76686ed668f2c60f84e9799ba4c0d56abdb36b1577b60c1d061d1ec/matplotlib-3.10.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5a6104ed666402ba5106d7f36e0e0cdca4e8d7fa4d39708ca88019e2835a2eb", size = 9659771, upload-time = "2026-04-24T00:12:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0d/271aace3342157c64700c9ff4c59c7b392f3dbab393692e8db6fbe7ab96c/matplotlib-3.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:d730e984eddf56974c3e72b6129c7ca462ac38dc624338f4b0b23eb23ecba00f", size = 8205112, upload-time = "2026-04-24T00:12:15.773Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ee/cb57ad4754f3e7b9174ce6ce66d9205fb827067e48a9f58ac09d7e7d6b77/matplotlib-3.10.9-cp311-cp311-win_arm64.whl", hash = "sha256:51bf0ddbdc598e060d46c16b5590708f81a1624cefbaaf62f6a81bf9285b8c80", size = 8132310, upload-time = "2026-04-24T00:12:18.645Z" }, + { url = "https://files.pythonhosted.org/packages/35/c6/5581e26c72233ebb2a2a6fed2d24fb7c66b4700120b813f51b0555acf0b6/matplotlib-3.10.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0c3c28d9fbcc1fe7a03be236d73430cf6409c41fb2383a7ac52fe932b072cb1", size = 8319908, upload-time = "2026-04-24T00:12:21.323Z" }, + { url = "https://files.pythonhosted.org/packages/b7/18/4880dd762e40cd360c1bf06e890c5a97b997e91cb324602b1a19950ad5ce/matplotlib-3.10.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cb28c2bd769aa3e98322c6ab09854cbcc52ab69d2759d681bba3e327b2b320", size = 8216016, upload-time = "2026-04-24T00:12:23.4Z" }, + { url = "https://files.pythonhosted.org/packages/32/91/d024616abdba99e83120e07a20658976f6a343646710760c4a51df126029/matplotlib-3.10.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae20801130378b82d647ff5047c07316295b68dc054ca6b3c13519d0ea624285", size = 8789336, upload-time = "2026-04-24T00:12:26.096Z" }, + { url = "https://files.pythonhosted.org/packages/5c/04/030a2f61ef2158f5e4c259487a92ac877732499fb33d871585d89e03c42d/matplotlib-3.10.9-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c63ebcd8b4b169eb2f5c200552ae6b8be8999a005b6b507ed76fb8d7d674fe2", size = 9604602, upload-time = "2026-04-24T00:12:29.052Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c2/541e4d09d87bb6b5830fc28b4c887a9a8cf4e1c6cee698a8c05552ae2003/matplotlib-3.10.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d75d11c949914165976c621b2324f9ef162af7ebf4b057ddf95dd1dba7e5edcf", size = 9670966, upload-time = "2026-04-24T00:12:32.131Z" }, + { url = "https://files.pythonhosted.org/packages/04/a1/4571fc46e7702de8d0c2dc54ad1b2f8e29328dea3ee90831181f7353d93c/matplotlib-3.10.9-cp312-cp312-win_amd64.whl", hash = "sha256:d091f9d758b34aaaaa6331d13574bf01891d903b3dec59bfff458ef7551de5d6", size = 8217462, upload-time = "2026-04-24T00:12:35.226Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d0/2269edb12aa30c13c8bcc9382892e39943ce1d28aab4ec296e0381798e81/matplotlib-3.10.9-cp312-cp312-win_arm64.whl", hash = "sha256:10cc5ce06d10231c36f40e875f3c7e8050362a4ee8f0ee5d29a6b3277d57bb42", size = 8136688, upload-time = "2026-04-24T00:12:37.442Z" }, + { url = "https://files.pythonhosted.org/packages/aa/d3/8d4f6afbecb49fc04e060a57c0fce39ea51cc163a6bd87303ccd698e4fa6/matplotlib-3.10.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b580440f1ff81a0e34122051a3dfabb7e4b7f9e380629929bde0eff9af72165f", size = 8320331, upload-time = "2026-04-24T00:12:39.688Z" }, + { url = "https://files.pythonhosted.org/packages/63/d9/9e14bc7564bf92d5ffa801ae5fac819ce74b925dfb55e3ebde61a3bbad3e/matplotlib-3.10.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b1b745c489cd1a77a0dc1120a05dc87af9798faebc913601feb8c73d89bf2d1e", size = 8216461, upload-time = "2026-04-24T00:12:42.494Z" }, + { url = "https://files.pythonhosted.org/packages/8a/17/4402d0d14ccf1dfc70932600b68097fbbf9c898a4871d2cbbe79c7801a32/matplotlib-3.10.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8f3bcac1ca5ed000a6f4337d47ba67dfddf37ed6a46c15fd7f014997f7bf865f", size = 8790091, upload-time = "2026-04-24T00:12:44.789Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0b/322aeec06dd9b91411f92028b37d447342770a24392aa4813e317064dad5/matplotlib-3.10.9-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a8d66a55def891c33147ba3ba9bfcabf0b526a43764c818acbb4525e5ed0838", size = 9605027, upload-time = "2026-04-24T00:12:47.583Z" }, + { url = "https://files.pythonhosted.org/packages/74/88/5f13482f55e7b00bcfc09838b093c2456e1379978d2a146844aae05350ad/matplotlib-3.10.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d843374407c4017a6403b59c6c81606773d136f3259d5b6da3131bc814542cc2", size = 9671269, upload-time = "2026-04-24T00:12:50.878Z" }, + { url = "https://files.pythonhosted.org/packages/c5/e0/0840fd2f93da988ec660b8ad1984abe9f25d2aed22a5e394ff1c68c88307/matplotlib-3.10.9-cp313-cp313-win_amd64.whl", hash = "sha256:f4399f64b3e94cd500195490972ae1ee81170df1636fa15364d157d5bdd7b921", size = 8217588, upload-time = "2026-04-24T00:12:53.784Z" }, + { url = "https://files.pythonhosted.org/packages/47/b9/d706d06dd605c49b9f83a2aed8c13e3e5db70697d7a80b7e3d7915de6b17/matplotlib-3.10.9-cp313-cp313-win_arm64.whl", hash = "sha256:ba7b3b8ef09eab7df0e86e9ae086faa433efbfbdb46afcb3aa16aabf779469a8", size = 8136913, upload-time = "2026-04-24T00:12:56.501Z" }, + { url = "https://files.pythonhosted.org/packages/9b/45/6e32d96978264c8ca8c4b1010adb955a1a49cfaf314e212bbc8908f04a61/matplotlib-3.10.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:09218df8a93712bd6ea133e83a153c755448cf7868316c531cffcc43f69d1cc9", size = 8368019, upload-time = "2026-04-24T00:12:58.896Z" }, + { url = "https://files.pythonhosted.org/packages/86/0a/c8e3d3bba245f0f7fc424937f8ff7ef77291a36af3edb97ccd78aa93d84f/matplotlib-3.10.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:82368699727bfb7b0182e1aa13082e3c08e092fa1a25d3e1fd92405bff96f6d4", size = 8264645, upload-time = "2026-04-24T00:13:01.406Z" }, + { url = "https://files.pythonhosted.org/packages/3d/aa/5bf5a14fe4fed73a4209a155606f8096ff797aad89c6c35179026571133e/matplotlib-3.10.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3225f4e1edcb8c86c884ddf79ebe20ecd0a67d30188f279897554ccd8fded4dc", size = 8802194, upload-time = "2026-04-24T00:13:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/dd/5e/b4be852d6bba6fd15893fadf91ff26ae49cb91aac789e95dde9d342e664f/matplotlib-3.10.9-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de2445a0c6690d21b7eb6ce071cebad6d40a2e9bdf10d039074a96ba19797b99", size = 9622684, upload-time = "2026-04-24T00:13:06.647Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/ed428c971139112ef730f62770654d609467346d09d4b62617e1afd68a5a/matplotlib-3.10.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b2b9516251cb89ff618d757daec0e2ed1bf21248013844a853d87ef85ab3081d", size = 9680790, upload-time = "2026-04-24T00:13:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/e7/09/052e884aaf2b985c63cb79f715f1d5b6a3eaa7de78f6a52b9dbc077d5b53/matplotlib-3.10.9-cp313-cp313t-win_amd64.whl", hash = "sha256:e9fae004b941b23ff2edcf1567a857ed77bafc8086ffa258190462328434faf8", size = 8287571, upload-time = "2026-04-24T00:13:13.087Z" }, + { url = "https://files.pythonhosted.org/packages/f4/38/ae27288e788c35a4250491422f3db7750366fc8c97d6f36fbdecfc1f5518/matplotlib-3.10.9-cp313-cp313t-win_arm64.whl", hash = "sha256:6b63d9c7c769b88ab81e10dc86e4e0607cf56817b9f9e6cf24b2a5f1693b8e38", size = 8188292, upload-time = "2026-04-24T00:13:15.546Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e6/3bd8afd04949f02eabc1c17115ea5255e19cacd4d06fc5abdde4eeb0052c/matplotlib-3.10.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:172db52c9e683f5d12eaf57f0f54834190e12581fe1cc2a19595a8f5acb4e77d", size = 8321276, upload-time = "2026-04-24T00:13:18.318Z" }, + { url = "https://files.pythonhosted.org/packages/41/86/86231232fff41c9f8e4a1a7d7a597d349a02527109c3af7d618366122139/matplotlib-3.10.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97e35e8d39ccc85859095e01a53847432ba9a53ddf7986f7a54a11b73d0e143f", size = 8218218, upload-time = "2026-04-24T00:13:20.974Z" }, + { url = "https://files.pythonhosted.org/packages/85/8f/becc9722cafc64f5d2eb0b7c1bf5f585271c618a45dbd8fabeb021f898b6/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aba1615dabe83188e19d4f75a253c6a08423e04c1425e64039f800050a69de6b", size = 9608145, upload-time = "2026-04-24T00:13:23.228Z" }, + { url = "https://files.pythonhosted.org/packages/32/5d/f7e914f7d9325abff4057cee62c0fa70263683189f774473cbfb534cd13b/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34cf8167e023ad956c15f36302911d5406bd99a9862c1a8499ea6f7c0e015dc2", size = 9885085, upload-time = "2026-04-24T00:13:25.849Z" }, + { url = "https://files.pythonhosted.org/packages/a5/fd/fa69f2221534e80cc5772ac2b7d222011a2acafc2ec7216d5dd174c864ae/matplotlib-3.10.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:59476c6d29d612b8e9bb6ce8c5b631be6ba8f9e3a2421f22a02b192c7dd28716", size = 9672358, upload-time = "2026-04-24T00:13:28.906Z" }, + { url = "https://files.pythonhosted.org/packages/ab/1a/5a4f747a8b271cbb024946d2dd3c913ab5032ba430626f8c3528ada96b4b/matplotlib-3.10.9-cp314-cp314-win_amd64.whl", hash = "sha256:336b9acc64d309063126edcdaca00db9373af3c476bb94388fe9c5a53ad13e6f", size = 8349970, upload-time = "2026-04-24T00:13:31.904Z" }, + { url = "https://files.pythonhosted.org/packages/64/dc/95d60ecaefe30680a154b52ea96ab4b0dab547f1fd6aa12f5fb655e89cae/matplotlib-3.10.9-cp314-cp314-win_arm64.whl", hash = "sha256:2dc9477819ffd78ad12a20df1d9d6a6bd4fec6aaa9072681465fddca052f1456", size = 8272785, upload-time = "2026-04-24T00:13:34.511Z" }, + { url = "https://files.pythonhosted.org/packages/70/a0/005d68bc8b8418300ce6591f18586910a8526806e2ab663933d9f20a41e9/matplotlib-3.10.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:da4e09638420548f31c354032a6250e473c68e5a4e96899b4844cf39ddea23fe", size = 8367999, upload-time = "2026-04-24T00:13:36.962Z" }, + { url = "https://files.pythonhosted.org/packages/22/05/1236cc9290be70b2498af20ca348add76e3fffe7f67b477db5133a84f3ea/matplotlib-3.10.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:345f6f68ecc8da0ca56fad2ea08fde1a115eda530079eca185d50a7bc3e146c6", size = 8264543, upload-time = "2026-04-24T00:13:39.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c2/071f5a5ff6c5bd63aaaf2f45c811d9bf2ced94bde188d9e1a519e21d0cba/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4edcfbd8565339aa62f1cd4012f7180926fdbe71850f7b0d3c379c175cd6b66c", size = 9622800, upload-time = "2026-04-24T00:13:42.296Z" }, + { url = "https://files.pythonhosted.org/packages/95/57/da7d1f10a85624b9e7db68e069dd94e58dc41dbf9463c5921632ecbe3661/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6be157fe17fc37cb95ac1d7374cf717ce9259616edec911a78d9d26dae8522d4", size = 9888561, upload-time = "2026-04-24T00:13:45.026Z" }, + { url = "https://files.pythonhosted.org/packages/67/b2/ef8d6bb59b0edb6c16c968b70f548aa13b54348972def5aa6ac85df67145/matplotlib-3.10.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4e42042d54db34fda4e95a7bd3e5789c2a995d2dad3eb8850232ee534092fbbf", size = 9680884, upload-time = "2026-04-24T00:13:48.066Z" }, + { url = "https://files.pythonhosted.org/packages/61/1c/d21bfeb9931881ebe96bcfcff27c7ae4b160ae0ec291a714c42641a56d75/matplotlib-3.10.9-cp314-cp314t-win_amd64.whl", hash = "sha256:c27df8b3848f32a83d1767566595e43cfaa4460380974da06f4279a7ec143c39", size = 8432333, upload-time = "2026-04-24T00:13:51.008Z" }, + { url = "https://files.pythonhosted.org/packages/78/23/92493c3e6e1b635ccfff146f7b99e674808787915420373ac399283764c2/matplotlib-3.10.9-cp314-cp314t-win_arm64.whl", hash = "sha256:a49f1eadc84ca85fd72fa4e89e70e61bf86452df6f971af04b12c60761a0772c", size = 8324785, upload-time = "2026-04-24T00:13:53.633Z" }, + { url = "https://files.pythonhosted.org/packages/63/e2/9f66ca6a651a52abfe0d4964ce01439ed34f3f1e119de10ff3a07f403043/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:42fb814efabe95c06c1994d8ab5a8385f43a249e23badd3ba931d4308e5bca20", size = 8304420, upload-time = "2026-04-24T00:14:04.57Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e8/467c03568218792906aa87b5e7bb379b605e056ed0c74fe00c051786d925/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f76e640a5268850bfda54b5131b1b1941cc685e42c5fa98ed9f2d64038308cba", size = 8197981, upload-time = "2026-04-24T00:14:07.233Z" }, + { url = "https://files.pythonhosted.org/packages/6f/87/afead29192170917537934c6aff4b008c805fff7b1ccea0c79120d96beda/matplotlib-3.10.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3fc0364dfbe1d07f6d15c5ebd0c5bf89e126916e5a8667dd4a7a6e84c36653d4", size = 8774002, upload-time = "2026-04-24T00:14:09.816Z" }, +] + +[[package]] +name = "mcp" +version = "1.27.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "httpx" }, + { name = "httpx-sse" }, + { name = "jsonschema" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "python-multipart" }, + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "sse-starlette" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, + { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/27/3c/347cf965d313f5d41764e7d46bea6ffe7d9ef13b983cc429b0340962a082/mcp-1.27.2.tar.gz", hash = "sha256:8e02db104096d1c25b28e64bde29a5c32b31bc241710213e12fd4d84985bdfef", size = 621116, upload-time = "2026-05-29T17:16:04.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/11/252c6f971dc4f16af1d98a1c469d8ba523aab00d1bb76b4d3bc1ff32eacc/mcp-1.27.2-py3-none-any.whl", hash = "sha256:d6ff5160c6ca65d93013626efb3fc249de683c30b2d8570755ceddd490344de5", size = 220498, upload-time = "2026-05-29T17:16:02.442Z" }, +] + [[package]] name = "mdurl" version = "0.1.2" @@ -656,6 +1698,123 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, ] +[[package]] +name = "multidict" +version = "6.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" }, + { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" }, + { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" }, + { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" }, + { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" }, + { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" }, + { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" }, + { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" }, + { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" }, + { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" }, + { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" }, + { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" }, + { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" }, + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" }, + { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" }, + { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" }, + { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" }, + { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" }, + { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" }, + { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" }, + { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" }, + { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" }, + { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" }, + { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" }, + { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" }, + { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" }, + { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" }, + { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" }, + { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" }, + { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" }, + { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" }, + { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" }, + { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" }, + { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" }, + { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" }, + { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" }, + { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" }, + { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" }, + { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" }, + { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" }, + { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" }, + { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" }, + { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, +] + [[package]] name = "mypy" version = "1.19.1" @@ -704,6 +1863,35 @@ 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 = "netcdf4" +version = "1.7.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "cftime" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/34/b6/0370bb3af66a12098da06dc5843f3b349b7c83ccbdf7306e7afa6248b533/netcdf4-1.7.4.tar.gz", hash = "sha256:cdbfdc92d6f4d7192ca8506c9b3d4c1d9892969ff28d8e8e1fc97ca08bf12164", size = 838352, upload-time = "2026-01-05T02:27:38.593Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/de/38ed7e1956943d28e8ea74161e97c3a00fb98d6d08943b4fd21bae32c240/netcdf4-1.7.4-cp311-abi3-macosx_13_0_x86_64.whl", hash = "sha256:dec70e809cc65b04ebe95113ee9c85ba46a51c3a37c058d2b2b0cadc4d3052d8", size = 23427499, upload-time = "2026-01-05T02:27:06.568Z" }, + { url = "https://files.pythonhosted.org/packages/e5/70/2f73c133b71709c412bc81d8b721e28dc6237ba9d7dad861b7bfbb70408a/netcdf4-1.7.4-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:75cf59100f0775bc4d6b9d4aca7cbabd12e2b8cf3b9a4fb16d810b92743a315a", size = 22847667, upload-time = "2026-01-05T02:27:09.421Z" }, + { url = "https://files.pythonhosted.org/packages/77/ce/43a3c0c41a6e2e940d87feea79d29aa88302211ac122604838f8a5a48de6/netcdf4-1.7.4-cp311-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ddfc7e9d261125c74708119440c85ea288b5fee41db676d2ba1ce9be11f96932", size = 10274769, upload-time = "2026-01-05T21:31:19.243Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7a/a8d32501bb95ecff342004a674720164f95ad616f269450b3bc13dc88ae3/netcdf4-1.7.4-cp311-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a72c9f58767779ec14cb7451c3b56bdd8fdc027a792fac2062b14e090c5617f3", size = 10123122, upload-time = "2026-01-05T21:31:22.773Z" }, + { url = "https://files.pythonhosted.org/packages/18/68/e89b4fa9242e59326c849c39ce0f49eb68499603c639405a8449900a4f15/netcdf4-1.7.4-cp311-abi3-win_amd64.whl", hash = "sha256:9476e1f23161ae5159cd1548c50c8a37922e77d76583e247133f256ef7b825fc", size = 21299637, upload-time = "2026-01-05T02:27:11.856Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fc/edd41a3607241027aa4533e7f18e0cd647e74dde10a63274c65350f59967/netcdf4-1.7.4-cp311-abi3-win_arm64.whl", hash = "sha256:876ad9d58f09c98741c066c726164c45a098a58fb90e5fac9e74de4bb8a793fd", size = 2386377, upload-time = "2026-01-05T02:27:13.808Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3e/1e83534ba68459bc5ae39df46fa71003984df58aabf31f7dcd6e22ecddb0/netcdf4-1.7.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56688c03444fffe0d0c7512cb45245e650389cd841c955b30e4552fa681c4cd9", size = 10519821, upload-time = "2026-01-05T02:27:15.413Z" }, + { url = "https://files.pythonhosted.org/packages/c0/8c/a15d6fe97f81d6d5202b17838a9a298b5955b3e9971e20609195112829b5/netcdf4-1.7.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ecf471ba8a6ddb2200121949bedfa0095db228822f38227d5da680694a38358", size = 10371133, upload-time = "2026-01-05T02:27:17.224Z" }, + { url = "https://files.pythonhosted.org/packages/d8/2b/684b15dd4791f8be295b2f6fa97377bbc07a768478a63b7d3c4951712e36/netcdf4-1.7.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5841de0735e8e4875b367c668e81d334287858d64dd9f3e3e2261e808c84922", size = 10395635, upload-time = "2026-01-05T02:27:19.655Z" }, + { url = "https://files.pythonhosted.org/packages/37/dc/44d21524cf1b1c64254f92e22395a7a10f70c18f3a13a18ac9db258760f7/netcdf4-1.7.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86fac03a8c5b250d57866e7d98918a64742e4b0de1681c5c86bac5726bab8aee", size = 10237725, upload-time = "2026-01-05T02:27:22.298Z" }, + { url = "https://files.pythonhosted.org/packages/d4/9d/c3ddf54296ad8f18f02f77f23452bdb0971aece1b87e84bab9d734bf72cc/netcdf4-1.7.4-cp314-cp314t-macosx_13_0_x86_64.whl", hash = "sha256:ad083d260301b5add74b1669c75ab0df03bdf986decfcc092cb45eec2615b5f1", size = 23515258, upload-time = "2026-01-05T02:27:24.837Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/bc0346e995d436d03fab682b7fbd2a9adcf0db6a05790b8f24853bf08170/netcdf4-1.7.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:7f22014092cc9da3f056b0368e2e38c42afd5725c87ad4843eb2f467e16dd4f6", size = 22910171, upload-time = "2026-01-05T02:27:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/30/6b/f9bc3f43c55e2dac72ee9f98d77860789bdd5d50c29adf164a6bdb303078/netcdf4-1.7.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:224a15434c165a5e0225e5831f591edf62533044b1ce62fdfee815195bbd077d", size = 10567579, upload-time = "2026-01-05T02:27:29.382Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d5/e7685c66b7f011c73cd746127f986358a26c642a4e4a1aa5ab51481b6586/netcdf4-1.7.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31a2318305de6831a18df25ad0df9f03b6d68666af0356d4f6057d66c02ffeb6", size = 10255032, upload-time = "2026-01-05T02:27:31.744Z" }, + { url = "https://files.pythonhosted.org/packages/a6/14/7506738bb6c8bc373b01e5af8f3b727f83f4f496c6b108490ea2609dc2cf/netcdf4-1.7.4-cp314-cp314t-win_amd64.whl", hash = "sha256:6c4a0aa9446c3a616ef3be015b629dc6173643f8b09546de26a4e40e272cd1ed", size = 22289653, upload-time = "2026-01-05T02:27:34.294Z" }, + { url = "https://files.pythonhosted.org/packages/af/2e/39d5e9179c543f2e6e149a65908f83afd9b6d64379a90789b323111761db/netcdf4-1.7.4-cp314-cp314t-win_arm64.whl", hash = "sha256:034220887d48da032cb2db5958f69759dbb04eb33e279ec6390571d4aea734fe", size = 2531682, upload-time = "2026-01-05T02:27:37.062Z" }, +] + [[package]] name = "networkx" version = "3.6.1" @@ -838,7 +2026,7 @@ name = "nvidia-cudnn-cu12" version = "9.10.2.21" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12" }, + { name = "nvidia-cublas-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" }, @@ -849,7 +2037,7 @@ name = "nvidia-cufft-cu12" version = "11.3.3.83" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12" }, + { name = "nvidia-nvjitlink-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" }, @@ -876,9 +2064,9 @@ name = "nvidia-cusolver-cu12" version = "11.7.3.90" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12" }, - { name = "nvidia-cusparse-cu12" }, - { name = "nvidia-nvjitlink-cu12" }, + { name = "nvidia-cublas-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cusparse-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-nvjitlink-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" }, @@ -889,7 +2077,7 @@ name = "nvidia-cusparse-cu12" version = "12.5.8.93" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12" }, + { name = "nvidia-nvjitlink-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" }, @@ -935,6 +2123,25 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" }, ] +[[package]] +name = "openai" +version = "2.41.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3c/a6/5815fe2e2aca74b36c650d1bd43b69827cee568073d0d2d9b6fc5aaac80c/openai-2.41.0.tar.gz", hash = "sha256:db5c362acd6604b84f076abbefa66826ea4b46ecba2954ed866e6a149a1352c0", size = 783525, upload-time = "2026-06-03T22:39:40.719Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/51/d82bb424e8aa372190c5233253a2ceb399a778747d18b42cff487411e663/openai-2.41.0-py3-none-any.whl", hash = "sha256:20cc7952e8501c7e5773dd2ef7be437bae9cb549044902e1041a83a54516e375", size = 1353378, upload-time = "2026-06-03T22:39:38.964Z" }, +] + [[package]] name = "opentelemetry-api" version = "1.39.1" @@ -1026,6 +2233,66 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" }, ] +[[package]] +name = "pandas" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/16/b5c76b838fd9bf6ce84d3a53346b8874ec05c5f0040d75ef2c320100cd2a/pandas-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:455f6f8139d4282188f526868dbc3c828470e88a3d9d59a891bd46a455f21b98", size = 10338495, upload-time = "2026-05-11T18:52:11.558Z" }, + { url = "https://files.pythonhosted.org/packages/5a/b0/a4ffc4ae74d2d822200dcc46898987d8eb6032d1e2b219cae39da6f5cbcc/pandas-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4e15135e2ee5df1063313e2425ceef8ac0f4ae775893815b0923651b806a5639", size = 9938250, upload-time = "2026-05-11T18:52:17.005Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b2/3323601a52caee42c019e370090ca4544b241437240ca04f786cce82b0cf/pandas-3.0.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:05f1f1752b8533ea03f7f39a9c15b1a058d067bb48f4748948e7a8691e0510f2", size = 10770558, upload-time = "2026-05-11T18:52:19.865Z" }, + { url = "https://files.pythonhosted.org/packages/32/f1/bbecd2f867b97abebe0f9b53d750f862251b40337e061b36676ded3d920f/pandas-3.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a1e45c80cceb3b4a21bc5939d52e8cbd8d9b7305309219d59e9754d9ce09e27", size = 11274611, upload-time = "2026-05-11T18:52:22.622Z" }, + { url = "https://files.pythonhosted.org/packages/7f/4f/eafabf2d5fae5adf143b4d18d3706c5efdc368a7c4eb1ee8a3eddabbd0f6/pandas-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:14da8316da4d0c5a77618425996bfb1248ca87fc2c1486e6fde4652bd18b5824", size = 11784670, upload-time = "2026-05-11T18:52:25.4Z" }, + { url = "https://files.pythonhosted.org/packages/49/44/1eb20389301b57b19cc099a1c2f662501f72f08a65f912d05822613c1532/pandas-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a55066a0505dae0ba2b50a46637db34b46f9094c65c5d4800794ef6335010938", size = 12353708, upload-time = "2026-05-11T18:52:28.139Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/c321f13b5ba1819fc8dca456c7fce578da2dcfecff1abbf0eaddf8406c0f/pandas-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6674ab18ad8c57802867264b00e15e7bb904700cdd9046e3b2fa1fce237439ea", size = 9907609, upload-time = "2026-05-11T18:52:30.982Z" }, + { url = "https://files.pythonhosted.org/packages/53/85/1b7f563ebc6357c27233a02a96b589bcce1fa9c6eb89fb4f0e56421d277e/pandas-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:5cc09a68b3120e0f54870dede8287a7bb1fa463907e4fcec1ea77cab6179bf7a", size = 9165596, upload-time = "2026-05-11T18:52:33.334Z" }, + { url = "https://files.pythonhosted.org/packages/24/f1/392f8c5bfc16f66a0d2d41561c01627c228fe7ed2a0d056ef11315042570/pandas-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fed2ff7fd9779120e388e285fc029bd5cf9490cdd2e4166a9ee22c0e49a9ab09", size = 10357846, upload-time = "2026-05-11T18:52:36.143Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3d/b16412745651e855f357e5e66930248688378853a6e2698a214e331fba1f/pandas-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b168fc218fd80a6cbdbdbc1a97ddc7889ed057d7eb45f50d866ceab5f39904c4", size = 9899550, upload-time = "2026-05-11T18:52:38.976Z" }, + { url = "https://files.pythonhosted.org/packages/31/a8/fa2535168fffcedf67f4f6de28d2dd903a747ca7c8ea6989451aaeb3a92f/pandas-3.0.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0383c72c75cdcca61a9e116e611143902dbfd08bff356829c2f6d1cf40a9ca8c", size = 10412965, upload-time = "2026-05-11T18:52:41.915Z" }, + { url = "https://files.pythonhosted.org/packages/65/b6/09b01cdbc15224e2850365192d17b7bdebb8bdbd8780ed221fcdf0d9a515/pandas-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6dc0b3fd2169c9157deed50b4d519553a3655c8c6a96027136d654592be973a9", size = 10894600, upload-time = "2026-05-11T18:52:45.02Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a4/2eb28f2fccb4ced4a2c79ab2a5dee9ade1ebf44922ebad6fea158c9f95d4/pandas-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e65d5407dc0b394f509699650e4a2ec01c0514f21850f453fa60f3be79a5dbf", size = 11422824, upload-time = "2026-05-11T18:52:48.058Z" }, + { url = "https://files.pythonhosted.org/packages/f8/45/830bb57f533a4604b355e07edcb8ea18cf88b5f94e5fca92f27052d7c597/pandas-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f8894dc474d648fe7b6ff0ca9b0bd73950d19952bc1a6534540762c5d79d305c", size = 11950889, upload-time = "2026-05-11T18:52:50.905Z" }, + { url = "https://files.pythonhosted.org/packages/b9/c5/fc1b368f303087d20e8c9bf3d6ceb186263cfac0ade735cd938538bea839/pandas-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c7be265b62cef88e253a941e4698604973736dcfe242fdb5198f0f7bc473cdcc", size = 9755463, upload-time = "2026-05-11T18:52:53.386Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/fda8f9705b1b09c6ebe14bfc0fa0e4ec8584d54ea673628f157ff55131af/pandas-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:557409bc4178e70ee8d9ddb494798e51ebf6ea59330f6be22c51bab2a7db6c49", size = 9066158, upload-time = "2026-05-11T18:52:56.038Z" }, + { url = "https://files.pythonhosted.org/packages/c5/90/62d8302883c44308c477e222c3daf7c813a34c8e96985882fbd53d964352/pandas-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:67b3b64c11910cfa29f4e94a14d3bff9ee693b6fc76055e7cad549cee0aec5fa", size = 10331071, upload-time = "2026-05-11T18:52:58.838Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ae/6a6493c783a101f165e4356953ba3c74d6f77f0042fa7d753da9dfbb640c/pandas-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:39436b377d56d2a2e52d0395bdbee171f01068e99af5250509aceeb929f765c7", size = 9875690, upload-time = "2026-05-11T18:53:01.431Z" }, + { url = "https://files.pythonhosted.org/packages/62/7c/5df8e9f56c69a2769fbe9382a5ef8f2658c007e376434e1e2cbb57ad895f/pandas-3.0.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4be06d68f9ddcfc645b87534911da79a8fbffc7573c80e0edcf42a5020624d8", size = 10381634, upload-time = "2026-05-11T18:53:04.393Z" }, + { url = "https://files.pythonhosted.org/packages/99/68/1237369725aa617bb358263d535803e3053fdbc593513ec5ed9c9896b5b6/pandas-3.0.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a4eeb6830daf35a71cc09649bd823e2b542dac246cdee9614c6e4bd65028cd6a", size = 10891243, upload-time = "2026-05-11T18:53:07.643Z" }, + { url = "https://files.pythonhosted.org/packages/25/93/77d108e8af7222b4a503ebde0e30215b1c2e4f8e53a526431890f22d5586/pandas-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1928e07221f82db493cd4af1e23c1bfca524a19a4699887975bff68f49a72bfb", size = 11388659, upload-time = "2026-05-11T18:53:10.634Z" }, + { url = "https://files.pythonhosted.org/packages/d0/bd/eff5b4399f332ac386c853f6cd2bd3fa2ca0061b9f36ecd9c4d7c4265649/pandas-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51b1fe551acb77dac643c6fda86084d8d446c10fe64b06a9cc29c4cc8540e7f2", size = 11942880, upload-time = "2026-05-11T18:53:13.536Z" }, + { url = "https://files.pythonhosted.org/packages/2c/20/559ace4200982c3887d0b86bfd0d856a2143ef8ddab63cc07934951a964c/pandas-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:a82d532a3351d435432cd913edbccaf8b8e01d4dd0e5ced5a8d2e8ecd94c7e44", size = 9757091, upload-time = "2026-05-11T18:53:16.306Z" }, + { url = "https://files.pythonhosted.org/packages/3a/66/69055a09fe200f29f922a3eeec4804611900b95f52d932ece3393c3c0c19/pandas-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:275c14e0fce14a2ec20eee474aecd305478ea3c1e6f6a9d8fe219a165542717e", size = 9057282, upload-time = "2026-05-11T18:53:18.768Z" }, + { url = "https://files.pythonhosted.org/packages/57/0e/efe801b0e6811e8e650cd21b7f2608e30f08a7067e2bf6e8752b0d56ee3c/pandas-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:46997386d528eb40376ecd6b033cf4a8a1e5282580f68f43de875b78cba2199d", size = 10767016, upload-time = "2026-05-11T18:53:21.227Z" }, + { url = "https://files.pythonhosted.org/packages/ea/dc/eb55135a1d5f0f0519f28da1f609a206d2cad1f9c35c32d51e38dd7261ae/pandas-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:261e308dfb22448384b7580cf719d2f998fe2966c92893c3e77d14008af1f066", size = 10420210, upload-time = "2026-05-11T18:53:23.982Z" }, + { url = "https://files.pythonhosted.org/packages/c6/3e/b1d5d955ce33ffecb407465a60bc32769d74fcf68224b7ae67ae11d4dea4/pandas-3.0.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd1a5d1def6a46002e964510bdc67c368aa0951df5d1d9f8365336f5a1f490cd", size = 10336126, upload-time = "2026-05-11T18:53:26.731Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/a01261711ab60a22d71b862f0de20e4c504bf80457270ad8cb42110f6abc/pandas-3.0.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d72828c20c6d6e83e1e22a6a3b47b326b71664112fa9705dcbccfd7a39b62085", size = 10728051, upload-time = "2026-05-11T18:53:29.125Z" }, + { url = "https://files.pythonhosted.org/packages/e9/21/ea191195e587b18cf682e97f433f81b2d0fbe341380e80a3e0d6e4403c8e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d26cbe1fcfc12e8fd900e2454163e466b2d3af84f7c75481df7683ffc073d870", size = 11350796, upload-time = "2026-05-11T18:53:32.056Z" }, + { url = "https://files.pythonhosted.org/packages/64/69/f0eaaf54939f0e8c6768fd06be9af2cef9b36048b96dfb9e1b2c685a807e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e91cec1879ada0624fc3dc9953c5cbd60208e59c0db28f540c5d6d47502422f", size = 11799741, upload-time = "2026-05-11T18:53:34.985Z" }, + { url = "https://files.pythonhosted.org/packages/45/a4/865e0e510cae5fc2194de4db28be638952de942571ba9125934fd9c01d47/pandas-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:08d789b41f87e0905880e293cedf6197ce71fe67cc081358b1e148a491b9bd13", size = 10499958, upload-time = "2026-05-11T18:53:37.857Z" }, + { url = "https://files.pythonhosted.org/packages/86/54/effdcc3c0ff7a08037889200e148ebe94c16c4f653be078c7b3675955df1/pandas-3.0.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3650109c0f22879df8bd6179ab9ee3d7f1d1d4e7e0094a3f0032d9f51e2e64ac", size = 10336065, upload-time = "2026-05-11T18:53:41.099Z" }, + { url = "https://files.pythonhosted.org/packages/68/10/bf2d6738d72748b961a3751ab89522d58c54efc36a8e1a12161216cd45cf/pandas-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:bab900348131a7db1f69a7309ef141fd5680f1487094193bcbbb61791573bf8f", size = 9926101, upload-time = "2026-05-11T18:53:43.515Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e9/e35cf11c8a136e757b956f5f0efdcaa50aecde85ea055f1898dfc68262f3/pandas-3.0.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba7e08b9ac1d54569cd1e256e3668975ed624d6826f7b68df0342b012007bddb", size = 10457553, upload-time = "2026-05-11T18:53:46.394Z" }, + { url = "https://files.pythonhosted.org/packages/58/3b/1cdec6772bdbaf7b25dab360c59f03cadf05492dd724c6540af905389b07/pandas-3.0.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d71c63ae4ebdbf70209742096f1fc46a83a0613c99d4b23766cced9ff8cd62a", size = 10914065, upload-time = "2026-05-11T18:53:49.134Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/1ef644445fcd72e3627bceec77e3560636f87ddce4ed841afe76b83b5bf9/pandas-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3a2ec42c98ffa2565a67e08e218d06d72576d758d90facb7c00805194d8f360", size = 11459188, upload-time = "2026-05-11T18:53:52.527Z" }, + { url = "https://files.pythonhosted.org/packages/7e/49/4d8d4f42cbc9c4adc7a1870f269c02cbd6cd40d059622c06fb298addcbad/pandas-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:335f62418ed562cfc3c49e9e196375c28b729dcef8543abf4f9438e381bf3c76", size = 11982966, upload-time = "2026-05-11T18:53:55.043Z" }, + { url = "https://files.pythonhosted.org/packages/38/55/792619469bab9882d8bbd5865d45a72f6478762d04a9af4bf0d08c503e95/pandas-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:3c20a521bbb85902f79f7270c80a59e1b5452d96d170c034f207181870f97ac5", size = 9876755, upload-time = "2026-05-11T18:53:58.067Z" }, + { url = "https://files.pythonhosted.org/packages/2a/af/33c469653b0ba03b50c3a98192d4c07f0c75c66b263ceb097fce0ee97d31/pandas-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:a2d2dff8a04f3917b55ab3910c32990f8ddf7eceba114947838cefa976a68977", size = 9198658, upload-time = "2026-05-11T18:54:00.733Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/b8c257bd76b8bd060c3a9151c1fca05e9b9c5e3af5d0f549c0356f6d143d/pandas-3.0.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0d589105b3c14645af1738ff279b2995102d8f7a03b0a66dc8d95550eb513e04", size = 10787242, upload-time = "2026-05-11T18:54:03.564Z" }, + { url = "https://files.pythonhosted.org/packages/54/eb/f19206ffb0bf1919002969aa448b4702c6594845156a6f8050674855aac3/pandas-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:13fc1e853d9e04743d11ba75a985ccbc2a317fe07d8af61e445a6fd24dacd6a6", size = 10436369, upload-time = "2026-05-11T18:54:06.311Z" }, + { url = "https://files.pythonhosted.org/packages/fd/24/c7c39fb4fe22b71a0c2d78bf0c585c600092d85f94f086d2b3b2f6ca27e2/pandas-3.0.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:819959dab7bbd0049c15623fbac4e29a191b9528160a61fb1032242d8ced2d9c", size = 10358306, upload-time = "2026-05-11T18:54:09.085Z" }, + { url = "https://files.pythonhosted.org/packages/16/ec/dd2a9eb7fa1204df88c0864164e35b228ac581062ac612ba0a67fd812e4c/pandas-3.0.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:60ae316d3fd75d1858d450d0db0103ea2be3e7d4a95ec2f064f7e2ae63f7b028", size = 10758394, upload-time = "2026-05-11T18:54:11.956Z" }, + { url = "https://files.pythonhosted.org/packages/95/6e/00c61ea8e85b4f6d8d35e11852a1a4998fc7fafc91c6a602d1cc9c972d64/pandas-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd3a518890b400d32f9023722dc9a9a5c969f00b415419a3c06c043f09bb5d7d", size = 11375717, upload-time = "2026-05-11T18:54:14.539Z" }, + { url = "https://files.pythonhosted.org/packages/31/89/8fc1c268969fac43688d65fd92e67df24bd128d53cb4d2eee534cd307399/pandas-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c39be2d709d01fa972a0cabc522389fceca4f3969332ba25a7d6c5802cf976a", size = 11828897, upload-time = "2026-05-11T18:54:17.146Z" }, + { url = "https://files.pythonhosted.org/packages/56/3b/e7d20dea247a3e6dc0bd8a6953854afbedc03951def4e7371e05e7263e25/pandas-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4db8c527972a821cf5286b40ccc57642a39bc62e62022b42f99f8a67fca8c3a1", size = 10900855, upload-time = "2026-05-11T18:54:19.72Z" }, + { url = "https://files.pythonhosted.org/packages/0f/54/68a0978d1ef8502b8492099beaa6e7a0c1b32e3b5d4f677f5810cb08711c/pandas-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1", size = 9466464, upload-time = "2026-05-11T18:54:22.754Z" }, +] + [[package]] name = "pathspec" version = "1.0.4" @@ -1035,6 +2302,93 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" }, ] +[[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/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { 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" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + [[package]] name = "platformdirs" version = "4.9.2" @@ -1078,6 +2432,117 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/74/c3/24a2f845e3917201628ecaba4f18bab4d18a337834c1df2a159ee9d22a42/prometheus_client-0.24.1-py3-none-any.whl", hash = "sha256:150db128af71a5c2482b36e588fc8a6b95e498750da4b17065947c16070f4055", size = 64057, upload-time = "2026-01-14T15:26:24.42Z" }, ] +[[package]] +name = "propcache" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/f1/8a8cc1c2c7e7934ab77e0163414f736fadbc0f5e8dd9673b952355ac175b/propcache-0.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:74b70780220e2dd89175ca24b81b68b67c83db499ae611e7f2313cb329801c78", size = 90744, upload-time = "2026-05-08T20:59:45.799Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f4/651b1225e976bd1a2ba5cfba0c29d096581c2636b437e3a9a7ab6276270a/propcache-0.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a4840ab0ae0216d952f4b53dc6d0b992bfc2bedbfe360bdd9b548bc184c08959", size = 52033, upload-time = "2026-05-08T20:59:47.408Z" }, + { url = "https://files.pythonhosted.org/packages/15/a8/8ede85d6aa1f79fc7dc2f8fd2c8d65920b8272c3892903c8a1affde48cfb/propcache-0.5.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c6844ba6364fb12f403928a82cfd295ab103a2b315c77c747b2dbe4a41894ea7", size = 52754, upload-time = "2026-05-08T20:59:49.202Z" }, + { url = "https://files.pythonhosted.org/packages/7d/fe/b3551b41bbc2f5b5bb088fc6920567cd43101253e68fbaa261339eb96fe1/propcache-0.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2293949b855ce597f2826452d17c2d545fb5622379c4ea6fdf525e9b8e8a2511", size = 57573, upload-time = "2026-05-08T20:59:50.778Z" }, + { url = "https://files.pythonhosted.org/packages/83/27/ab851ebd1b7172e3e161f5f8d39e315d54a91bea246f01f4d872d3376aef/propcache-0.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0fd59b5af35f74da48d905dcbad55449ba13be91823cb05a9bd590bbf5b61660", size = 60645, upload-time = "2026-05-08T20:59:52.227Z" }, + { url = "https://files.pythonhosted.org/packages/95/7d/466b3d18022e9897cbda9c735c493c5bd747d7a4c6f5ea1480b4cec434b6/propcache-0.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29f9309a2e42b0d273be006fdb4be2d6c39a47f6f57d8fb1cf9f81481df81b66", size = 61563, upload-time = "2026-05-08T20:59:53.866Z" }, + { url = "https://files.pythonhosted.org/packages/27/1b/16ab7f2cf2041da2f60d156ba64c2484eadf9168075b4ff43c3ef60045af/propcache-0.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5aaa2b923c1944ac8febd6609cb373540a5563e7cbcb0fd770f75dace2eb817b", size = 58888, upload-time = "2026-05-08T20:59:55.457Z" }, + { url = "https://files.pythonhosted.org/packages/0a/67/bb777ffd907633563bf35fd859c4ce97b0512c32f4633cf5d1eb7c33512b/propcache-0.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66ea454f095ddf5b6b14f56c064c0941c4788be11e18d2464cf643bf7203ff67", size = 59253, upload-time = "2026-05-08T20:59:57.075Z" }, + { url = "https://files.pythonhosted.org/packages/b9/42/64f8d90b73fd9cdc1499b48057ff6d9cd2a98a25734c9bb62ecf07e87061/propcache-0.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:95f1e3f4760d404b13c9976c0229b2b49a3c8e2c62a9ce92efdd2b11ada75e3f", size = 57558, upload-time = "2026-05-08T20:59:58.602Z" }, + { url = "https://files.pythonhosted.org/packages/eb/02/dba5bc03c9041f2092ea55a449caf5dfe68352c6654511b29ba0654ddb69/propcache-0.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:85341b12b9d55bad0bded24cac341bb34289469e03a11f3f583ea1cc1db0326c", size = 55007, upload-time = "2026-05-08T20:59:59.837Z" }, + { url = "https://files.pythonhosted.org/packages/14/c0/43f649c7aa2a77a3b100d84e9dea3a483120ecb608bfe36ce49eaff517fe/propcache-0.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:26a4dca084132874e639895c3135dfad5eb20bae209f62d1aeb31b03e601c3c0", size = 60355, upload-time = "2026-05-08T21:00:01.144Z" }, + { url = "https://files.pythonhosted.org/packages/83/c0/435dafd27f1cb4a495381dae60e25883ccfe4020bb72818e8184c1678092/propcache-0.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3b199b9b2b3d6a7edf3183ba8a9a137a22b97f7df525feb5ae1eccf026d2a9c6", size = 59057, upload-time = "2026-05-08T21:00:02.401Z" }, + { url = "https://files.pythonhosted.org/packages/53/ae/6e292df9135d659944e96cb3389258e4a663e5b2b5f6c217ef0ddc8d2f73/propcache-0.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e59bc9e66329185b93dab73f210f1a37f81cb40f321501db8017c9aea15dba27", size = 61938, upload-time = "2026-05-08T21:00:03.638Z" }, + { url = "https://files.pythonhosted.org/packages/0b/42/314ebc50d8159055411fd6b0bda322ff510e4b1f7d2e4927940ad0f6af20/propcache-0.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:552ffadf6ad409844bc5919c42a0a83d88314cedddaea0e41e80a8b8fffe881f", size = 59731, upload-time = "2026-05-08T21:00:04.881Z" }, + { url = "https://files.pythonhosted.org/packages/b8/9b/2da6dee38871c3c8772fabc2758325a5c9077d6d18c597737dc04dd884cd/propcache-0.5.2-cp311-cp311-win32.whl", hash = "sha256:cd416c1de191973c52ff1a12a57446bfc7642797b282d7caf2162d7d1b8aa9a0", size = 38966, upload-time = "2026-05-08T21:00:06.511Z" }, + { url = "https://files.pythonhosted.org/packages/42/4e/f17363fb58c0afe05b067361cb6d86ed2d29de6506779a27547c4d183075/propcache-0.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:44e488ef40dbb452700b2b1f8188934121f6648f52c295055662d2191959ff82", size = 42135, upload-time = "2026-05-08T21:00:08.088Z" }, + { url = "https://files.pythonhosted.org/packages/c6/eb/6af6685077d22e8b33358d3c548e3282706a0b3cd85044ffba4e5dd08e3b/propcache-0.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:54adaa85a22078d1e306304a40984dc5be99d599bf3dc0a24dc98f7daeab89ab", size = 38381, upload-time = "2026-05-08T21:00:09.692Z" }, + { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" }, + { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" }, + { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" }, + { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" }, + { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" }, + { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" }, + { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" }, + { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" }, + { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" }, + { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" }, + { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" }, + { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" }, + { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" }, + { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" }, + { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" }, + { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" }, + { url = "https://files.pythonhosted.org/packages/c5/09/f049e45385503fe67db75a6b6186a7b9f0c3930366dc960522c312a825b1/propcache-0.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a", size = 94457, upload-time = "2026-05-08T21:00:36.355Z" }, + { url = "https://files.pythonhosted.org/packages/6b/65/83d1d05655baf63113731bd5a1008435e14f8d1e5a06cbe4ec5b23ad7a31/propcache-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117", size = 53835, upload-time = "2026-05-08T21:00:38.072Z" }, + { url = "https://files.pythonhosted.org/packages/a9/12/a6ba6482bb5ea3260c000c9b20881c95fa11c6b30173715668259f844ed7/propcache-0.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098", size = 54545, upload-time = "2026-05-08T21:00:39.319Z" }, + { url = "https://files.pythonhosted.org/packages/a9/19/7fa086f5764c59ec8a8e157cd93aa8497acc00aba9dcdec56bfffb32602d/propcache-0.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6ae2198be502c10f09b2516e7b5d019816924bc3183a43ce792a7bd6625e6f4", size = 59886, upload-time = "2026-05-08T21:00:40.621Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e4/5d7663dc8235956c8f5281698a3af1d351d8820341ddd890f59d9a9127f2/propcache-0.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6041d31504dc1779d700e1edcfb08eea334b357620b06681a4eabb57a74e574e", size = 63261, upload-time = "2026-05-08T21:00:41.775Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4a/15a03adee24d6350da4292caeac44c34c033d2afe5e87eb370f38854560f/propcache-0.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7eabc04151c78a9f4d5bbb5f1faf571e4defeb4b585e0fe95b60ff2dbe4d3d7", size = 64184, upload-time = "2026-05-08T21:00:43.018Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c6/979176efdaa3d239e36d503d5af63a0a773b36662ed8f52e5b6a6d9fd40e/propcache-0.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4db0ba63d693afd40d249bd93f842b5f144f8fcbb83de05660373bcf30517b1d", size = 61534, upload-time = "2026-05-08T21:00:44.507Z" }, + { url = "https://files.pythonhosted.org/packages/c8/22/63e8cd1bae4c2d2be6493b6b7d10566ddafad88137cfbc99964a1119853c/propcache-0.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1dbcf7675229b35d31abb6547d8ebc8c27a830ac3f9a794edff6254873ec7c0a", size = 61500, upload-time = "2026-05-08T21:00:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/60/5a/28e5d9acbac1cc9ccb67045e8c1b943aa8d79fdf39c93bd73cacd68008ea/propcache-0.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d310c013aad2c72f1c3f2f8dd3279d460a858c551f97aeb8c63e4693cca7b4d2", size = 59994, upload-time = "2026-05-08T21:00:47.093Z" }, + { url = "https://files.pythonhosted.org/packages/f3/40/db650677f554a95b9c01a7c9d93d629e93a15562f5deb4573c9ee136fed2/propcache-0.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:06187263ddad280d05b4d8a8b3bb7d164cbebd469236544a42e6d9b28ac6a4fa", size = 56884, upload-time = "2026-05-08T21:00:48.376Z" }, + { url = "https://files.pythonhosted.org/packages/80/45/70b39b89516ff8b96bf732fa6fded8cef20f293cb1508690101c3c07ec51/propcache-0.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3115559b8effafd63b142ea5ed53d63a16ea6469cbc63dce4ee194b42db5d853", size = 63464, upload-time = "2026-05-08T21:00:49.954Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e2/fa59d3a89eac5534293124af4f1d0d0ada091ce4a0ab4610ce03fd2bdd8d/propcache-0.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c60462af8e6dc30c35407c7237ea908d777b22862bbee27bc4699c0d8bcdc45a", size = 61588, upload-time = "2026-05-08T21:00:51.281Z" }, + { url = "https://files.pythonhosted.org/packages/0b/97/efb547a55c4bc7381cfb202d6a2239ac621045277bc1ea5dfd3a7f0516c0/propcache-0.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40314bca9ac559716fe374094fc81c11dcc34b64fd6c585360f5775690505704", size = 64667, upload-time = "2026-05-08T21:00:52.602Z" }, + { url = "https://files.pythonhosted.org/packages/92/56/f5c7d9b4b7595d5127da38974d791b2153f3d1eae6c674af3583ace92ad3/propcache-0.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cfa21e036ce1e1db2be04ba3b85d2df1bb1702fa01932d984c5464c665228ff4", size = 62463, upload-time = "2026-05-08T21:00:54.303Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3b/484a3a65fc9f9f60c41dcd17b428bace5389544e2c680994534a20755066/propcache-0.5.2-cp313-cp313-win32.whl", hash = "sha256:f156a3529f38063b6dbaf356e15602a7f95f8055b1295a438433a6386f10463d", size = 38621, upload-time = "2026-05-08T21:00:55.808Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fd/3f0f10dba4dabad3bf53102be007abf55481067952bde0fdddff439e7c61/propcache-0.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:dfed59d0a5aeb01e242e66ff0300bc4a265a7c05f612d30016f0b60b1017d757", size = 41649, upload-time = "2026-05-08T21:00:57.061Z" }, + { url = "https://files.pythonhosted.org/packages/90/ec/6ce619cc32bb500a482f811f9cd509368b4e58e638d13f2c68f370d6b475/propcache-0.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:ba338430e87ceb9c8f0cf754de38a9860560261e56c00376debd628698a7364f", size = 37636, upload-time = "2026-05-08T21:00:58.646Z" }, + { url = "https://files.pythonhosted.org/packages/1b/82/c1d268bbbf2ef981c5bf0fbbe746db617c66e3bcefe431a1aa8943fbe23a/propcache-0.5.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a592f5f3da71c8691c788c13cb6734b6d17663d2e1cb8caddf0673d01ef8847d", size = 98872, upload-time = "2026-05-08T21:00:59.889Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d4/52c871e73e864e6b34c0e2d58ac1ec5ccd149497ddc7ad2137ae98323a35/propcache-0.5.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6a997d0489e9668a384fcfd5061b857aa5361de73191cac204d04b889cfbbafa", size = 56257, upload-time = "2026-05-08T21:01:01.195Z" }, + { url = "https://files.pythonhosted.org/packages/67/f0/9b90ca2a210b3d09bcfcd96ecd0f55545c091535abce2a45de2775cfd357/propcache-0.5.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:10734b5484ea113152ee25a91dccedf81631791805d2c9ccb054958e51842c94", size = 56696, upload-time = "2026-05-08T21:01:02.941Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0e/6e9d4ba07c8e56e21ddec1e75f12148142b21ca83a51871babce095334f4/propcache-0.5.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cafca7e56c12bb02ae16d283742bef25a61122e9dab2b5b3f2ccbe589ce32164", size = 62378, upload-time = "2026-05-08T21:01:04.475Z" }, + { url = "https://files.pythonhosted.org/packages/65/19/c10badaa463dde8a27ce884f8ee2ec37e6035b7c9f5ff0c8f74f06f08dac/propcache-0.5.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f064f8d2b59177878b7615df1735cd8fe3462ed6be8c7b217d17a276489c2b7f", size = 65283, upload-time = "2026-05-08T21:01:05.959Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b6/93bea99ca80e19cef6512a8580e5b7857bbe09422d9daa7fd4ef5723306c/propcache-0.5.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f78abfa8dfc32376fd1aacf597b2f2fbbe0ea751419aee718af5d4f82537ef8c", size = 66616, upload-time = "2026-05-08T21:01:07.228Z" }, + { url = "https://files.pythonhosted.org/packages/83/e4/5c7462e50625f051f37fb38b8224f7639f667184bbd34424ec83819bb1b7/propcache-0.5.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7467da8a9822bf1a55336f877340c5bcbd3c482afc43a99771169f74a26dedc", size = 63773, upload-time = "2026-05-08T21:01:08.514Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b6/99238894047b13c823be25027e736626cd414a52a5e30d2c3347c2733529/propcache-0.5.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a6ddc6ac9e25de626c1f129c1b467d7ecd33ce2237d3fd0c4e429feef0a7ee1f", size = 63664, upload-time = "2026-05-08T21:01:09.874Z" }, + { url = "https://files.pythonhosted.org/packages/85/1e/a3a1a63116a2b8edb415a8bb9a6f0c34bd03830b1e18e8ce2904e1dc1cf4/propcache-0.5.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f22cbbac9e26a8e864c0985ff1268d5d939d53d9d9411a9824279097e03a2cb", size = 62643, upload-time = "2026-05-08T21:01:11.132Z" }, + { url = "https://files.pythonhosted.org/packages/e4/03/893cf147de2fc6543c5eaa07ad833170e7e2a2385725bbebe8c0503723bb/propcache-0.5.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:fc76378c62a0f04d0cd82fbb1a2cd2d7e28fcb40d5873f28a6c44e388aaa2751", size = 59595, upload-time = "2026-05-08T21:01:12.387Z" }, + { url = "https://files.pythonhosted.org/packages/86/3b/04c1a2e12c57766568ba75ba72b3bf2042818d4c1425fab6fc07155c7cff/propcache-0.5.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:acd2c8edba48e31e58a363b8cf4e5c7db3b04b3f9e371f601df30d9b0d244836", size = 65711, upload-time = "2026-05-08T21:01:13.676Z" }, + { url = "https://files.pythonhosted.org/packages/1c/34/80f8d0099f8d6bacc4de1624c85672681c8cd1149ca2da0e38fd120b817f/propcache-0.5.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:452b5065457eb9991ec5eb38ff41d6cd4c991c9ac7c531c4d5849ae473a9a13f", size = 64247, upload-time = "2026-05-08T21:01:14.936Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1a/8b08f3a5f1037e9e370c55883ceeeee0f6dd0416fb2d2d67b8bfc91f2a79/propcache-0.5.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3430bb2bfe1331885c427745a751e774ee679fd4344f80b97bf879815fe8fa55", size = 67102, upload-time = "2026-05-08T21:01:16.281Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/8bdb7bb7756d76e005490649d10e4a8369e610c74d619f71e1aedf889e9c/propcache-0.5.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cef6cea3922890dd6c9654971001fa797b526c16ab5e1e46c05fd6f877be7568", size = 64964, upload-time = "2026-05-08T21:01:17.57Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/50fb0b5d3968b61a510926ff8b8465f1d6e976b3ab74496d7a4b9fc42515/propcache-0.5.2-cp313-cp313t-win32.whl", hash = "sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191", size = 42546, upload-time = "2026-05-08T21:01:18.946Z" }, + { url = "https://files.pythonhosted.org/packages/ae/4c/0ddbae64321bd4a95bcbfc19307238016b5b1fee645c84626c8d539e5b74/propcache-0.5.2-cp313-cp313t-win_amd64.whl", hash = "sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7", size = 46330, upload-time = "2026-05-08T21:01:20.162Z" }, + { url = "https://files.pythonhosted.org/packages/00/d9/9cddc8efb78d8af264c5ec9f6d10b62f57c515feda8d321595f56010fb23/propcache-0.5.2-cp313-cp313t-win_arm64.whl", hash = "sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96", size = 40521, upload-time = "2026-05-08T21:01:21.399Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ea/23ee535d90ce8bcc465a3028eb3cc0ce3bd1005f4bb27710b30587de798d/propcache-0.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:46088abff4cba581dea21ae0467a480526cb25aa5f3c269e909f800328bc3999", size = 94662, upload-time = "2026-05-08T21:01:22.683Z" }, + { url = "https://files.pythonhosted.org/packages/b5/06/c5a52f419b5d8972f8d46a7577476090d8e3263ff589ce40b5ca4968d5be/propcache-0.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fc88b26f08d634f7bc819a7852e5214f5802641ab8d9fd5326892292eee1993e", size = 53928, upload-time = "2026-05-08T21:01:23.986Z" }, + { url = "https://files.pythonhosted.org/packages/63/b1/4260d67d6bd85e58a66b72d54ce15d5de789b6f3870cc6bedf8ff9667401/propcache-0.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97797ebb098e670a2f92dd66f32897e30d7615b14e7f59711de23e30a9072539", size = 54650, upload-time = "2026-05-08T21:01:25.305Z" }, + { url = "https://files.pythonhosted.org/packages/70/06/2f46c318e3307cd7a6a7481def374ce838c0fe20084b39dd54b0879d0e99/propcache-0.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba57fffe4ac99c5d30076161b5866336d97600769bad35cc68f7774b15298a4e", size = 59912, upload-time = "2026-05-08T21:01:26.545Z" }, + { url = "https://files.pythonhosted.org/packages/4c/29/fe1aebec2ce57ab985a9c382bded1124431f85078113aa222c5d278430d4/propcache-0.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:583c19759d9eec1e5b69e2fbef36a7d9c326041be9746cb822d335c8cedc2979", size = 63300, upload-time = "2026-05-08T21:01:27.937Z" }, + { url = "https://files.pythonhosted.org/packages/b4/18/2334b26768b6c82be8c69e83671b767d5ef426aa09b0cba6c2ea47816774/propcache-0.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d0326e2e5e1f3163fa306c834e48e8d490e5fae607a097a40c0648109b47ba80", size = 64208, upload-time = "2026-05-08T21:01:29.484Z" }, + { url = "https://files.pythonhosted.org/packages/2b/76/7f1bfd6afff4c5e38e36a3c6d68eb5f4b7311ea80baf693db78d95b603c4/propcache-0.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e00820e192c8dbebcafb383ebbf99030895f09905e7a0eb2e0340a0bcc2bc825", size = 61633, upload-time = "2026-05-08T21:01:31.068Z" }, + { url = "https://files.pythonhosted.org/packages/c4/46/b3ff8aba2b4953a3e50de2cf72f1b5748b8eca93b15f3dc2c84339084c09/propcache-0.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c66afea89b1e43725731d2004732a046fe6fe955d51f952c3e95a7314a284a39", size = 61724, upload-time = "2026-05-08T21:01:32.374Z" }, + { url = "https://files.pythonhosted.org/packages/c5/01/814cfcafbcff954f94c01cf30e097ddc88a076b5440fbcf4570753437d40/propcache-0.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d4dc37dec6c6cdad0b57881a5658fd14fbf53e333b1a86cf86559f190e1d9ec4", size = 60069, upload-time = "2026-05-08T21:01:33.67Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/5c6f7622d510cc666a300687e06fd060c1a43361c0c9b20d284f06d8096a/propcache-0.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5570dbcc97571c15f68068e529c92715a12f8d54030e272d264b377e22bd17a5", size = 57099, upload-time = "2026-05-08T21:01:34.915Z" }, + { url = "https://files.pythonhosted.org/packages/55/27/9cb0b4c679124085327957d42521c99dba04c88c90c3e55a6f0b633ebccc/propcache-0.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f814362777a9f841adddb200ecdf8f5cb1e5a3c4b7a86378edbd6ccb26edd702", size = 63391, upload-time = "2026-05-08T21:01:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/f0/9d/7258aaa5bdf60fc6f27591eef6fe52768cb0beda7140be477c8b12c9794a/propcache-0.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:196913dea116aeb5a2ba95af4ddcb7ea85559ae07d8eee8751688310d09168c3", size = 61626, upload-time = "2026-05-08T21:01:37.545Z" }, + { url = "https://files.pythonhosted.org/packages/8e/0d/41c602003e8a9b16fe1e7eadf62c7bfba9d5474370b24200bf48b315f45f/propcache-0.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6e7b8719005dd1175be4ab1cd25e9b98659a5e0347331506ec6760d2773a7fb5", size = 64781, upload-time = "2026-05-08T21:01:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f3/38e66b1856e9bd079deea015bc4a55f7767c0e4db2f7dcf69e7e680ba4ce/propcache-0.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:51f96d685ab16e88cab128cd37a52c5da540809c8b879fa047731bfcb4ad35a4", size = 62570, upload-time = "2026-05-08T21:01:40.415Z" }, + { url = "https://files.pythonhosted.org/packages/95/ca/bbfe9b910ce57dde8bb4876b4520fc02a4e89497c10de26be936758a3aaa/propcache-0.5.2-cp314-cp314-win32.whl", hash = "sha256:cc6fc3cc62e8501d3ed62894425040d2728ecddb1ed072737a5c70bd537aa9f0", size = 39436, upload-time = "2026-05-08T21:01:41.654Z" }, + { url = "https://files.pythonhosted.org/packages/61/d2/45c9defbaa1ea297035d9d4cce9e8f80daafbf19319c6007f157c6256ea9/propcache-0.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:81e3a30b0bb60caa22033dd0f8a3618d1d67356212514f62c57db75cb0ef410c", size = 42373, upload-time = "2026-05-08T21:01:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/44/68/9ea5103f41d5217d7d6ec24db90018e23aebec070c3f9a6e54d12b841fd8/propcache-0.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:0d2c9bf8528f135dbb805ce027567e09164f7efa51a2be07458a2c0420f292d0", size = 38554, upload-time = "2026-05-08T21:01:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/8a/81/fadf555f42d3b762eea8a53950b0489fdc0aa9da5f8ed9e10ce0a4e01b48/propcache-0.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4bc8ff1feffc6a61c7002ffe84634c41b822e104990ae009f44a0834430070bb", size = 99395, upload-time = "2026-05-08T21:01:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c9/c61e134a686949cf7971af3a390148b1156f7be81c73bc0cd12c873e2d48/propcache-0.5.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79aa3ff0a9b566633b642fa9caf7e21ed1c13d6feca718187873f199e1514078", size = 56653, upload-time = "2026-05-08T21:01:47.307Z" }, + { url = "https://files.pythonhosted.org/packages/cb/73/daf935ea7048ddd7ec8eec5345b4a40b619d2d178b3c0a0900796bc3c794/propcache-0.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1b31822f4474c4036bae62de9402710051d431a606d6a0f907fec79935a071aa", size = 56914, upload-time = "2026-05-08T21:01:48.573Z" }, + { url = "https://files.pythonhosted.org/packages/79/9f/aba959b435ea18617edd7cf0a7ad0b9c574b8fc7e3d2cd55fb59cb255d33/propcache-0.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fef48778b5a2a756523fdb781326b028ca75e32858b04f2cdd19f394564917", size = 62567, upload-time = "2026-05-08T21:01:49.903Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a1/859942de9a791ff42f6141736f5b37749b8f53e65edfa49638c67dd67e6a/propcache-0.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8b73ab70f1a3351fbc71f663b3e645af6dd0329100c353081cf69c37433fc6fe", size = 65542, upload-time = "2026-05-08T21:01:51.204Z" }, + { url = "https://files.pythonhosted.org/packages/b5/61/315bc0fd6c0fc7f80a528b8afd209e5fc4a875ea79571b91b8f50f442907/propcache-0.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5538d2c13d93e4698af7e092b57bc7298fd35d1d58e656ae18f23ee0d0378e03", size = 66845, upload-time = "2026-05-08T21:01:52.539Z" }, + { url = "https://files.pythonhosted.org/packages/47/f7/9f8122e3132e8e354ac41975ef8f1099be7d5a16bc7ae562734e993665c0/propcache-0.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd645f03898405cabe694fb8bc35241e3a9c332ec85627584fe3de201452b335", size = 63985, upload-time = "2026-05-08T21:01:53.847Z" }, + { url = "https://files.pythonhosted.org/packages/c8/54/c317819ec157cbf6f35df9df9657a6f82daf34d5faf15948b2f639c2192e/propcache-0.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a473b3440261e0c60706e732b2ed2f517857344fc21bf48fdfe211e2d98eb285", size = 63999, upload-time = "2026-05-08T21:01:55.179Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/387e3f7dfce0a9233df41fb888aa1c30222cb4bbbf09537c02dd9bd85fe2/propcache-0.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7afa37062e6650640e932e4cc9297d81f9f42d9944029cc386b8247dea4da837", size = 62779, upload-time = "2026-05-08T21:01:57.489Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9c/596784cb5824ed61ee960d3f8655a3f0993e107c6e98ab6c818b7fb92ccb/propcache-0.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8a90efd5777e996e42d568db9ac740b944d691e565cbfd31b2f7832f9184b2b8", size = 59796, upload-time = "2026-05-08T21:01:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/c2/3d/1a6cfa1726a48542c1e8784a0761421476a5b68e09b7f36bf95eb954aaba/propcache-0.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f19bb891234d72535764d703bfed1153cc34f4214d5bd7150aee1eec9e8f4366", size = 66023, upload-time = "2026-05-08T21:02:00.228Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0e/05fd6990369477076e4e280bcb970de760fddf0161a46e988bc95f7940ec/propcache-0.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:32775082acd2d807ee3db715c7770d38767b817870acfa08c29e057f3c4d5b56", size = 64448, upload-time = "2026-05-08T21:02:01.888Z" }, + { url = "https://files.pythonhosted.org/packages/cd/86/5f8da315a4309c62c10c0b2516b17492d5d3bbe1bb862b96604db67e2a37/propcache-0.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9282fb1a3bccd038da9f768b927b24a0c753e466c086b7c4f3c6982851eefb2d", size = 67329, upload-time = "2026-05-08T21:02:03.484Z" }, + { url = "https://files.pythonhosted.org/packages/da/d3/3368efe79ab21f0cdf86ef49895811c9cc933131d4cde1f28a624e22e712/propcache-0.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc49723e2f60d6b32a0f0b08a3fd6d13203c07f1cd9566cfce0f12a917c967a2", size = 65172, upload-time = "2026-05-08T21:02:04.745Z" }, + { url = "https://files.pythonhosted.org/packages/d5/07/127e8b0bacfb325396196f9d976a22453049b89b9b2b08477cc3145faa44/propcache-0.5.2-cp314-cp314t-win32.whl", hash = "sha256:2d7aa89ebca5acc98cba9d1472d976e394782f587bad6661003602a619fd1821", size = 43813, upload-time = "2026-05-08T21:02:06.025Z" }, + { url = "https://files.pythonhosted.org/packages/88/fb/46dad6c0ae49ed230ab1b16c890c2b6314e2403e6c412976f4a72d64a527/propcache-0.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:d447bb0b3054be5818458fbb171208b1d9ff11eba14e18ca18b90cbb45767370", size = 47764, upload-time = "2026-05-08T21:02:07.353Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/a47d0a63aa309d10d59ede6e9d4cff03a344a79d1f0f4cd0cd74997b53e0/propcache-0.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:fe67a3d11cd9b4efabfa45c3d00ffba2b26811442a73a581a94b67c2b5faccf6", size = 41140, upload-time = "2026-05-08T21:02:09.065Z" }, + { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" }, +] + [[package]] name = "protobuf" version = "6.33.5" @@ -1102,6 +2567,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e0/a9/023730ba63db1e494a271cb018dcd361bd2c917ba7004c3e49d5daf795a2/py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5", size = 22335, upload-time = "2022-10-25T20:38:27.636Z" }, ] +[[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.12.5" @@ -1214,6 +2688,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" }, ] +[[package]] +name = "pydantic-settings" +version = "2.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/60/1d1e59c9c90d54591469ada7d268251f71c24bdb765f1a8a832cee8c6653/pydantic_settings-2.14.1.tar.gz", hash = "sha256:e874d3bec7e787b0c9958277956ed9b4dd5de6a80e162188fdaff7c5e26fd5fa", size = 235551, upload-time = "2026-05-08T13:40:06.542Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/8d/f1af3832f5e6eb13ba94ee809e72b8ecb5eef226d27ee0bef7d963d943c7/pydantic_settings-2.14.1-py3-none-any.whl", hash = "sha256:6e3c7edfd8277687cdc598f56e5cff0e9bfff0910a3749deaa8d4401c3a2b9de", size = 60964, upload-time = "2026-05-08T13:40:04.958Z" }, +] + [[package]] name = "pygments" version = "2.19.2" @@ -1223,6 +2711,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, ] +[[package]] +name = "pyjwt" +version = "2.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" }, +] + +[package.optional-dependencies] +crypto = [ + { name = "cryptography" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + [[package]] name = "pyproject-hooks" version = "1.2.0" @@ -1273,6 +2784,58 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/33/29/e756e715a48959f1c0045342088d7ca9762a2f509b945f362a316e9412b7/pytest_benchmark-5.2.3-py3-none-any.whl", hash = "sha256:bc839726ad20e99aaa0d11a127445457b4219bdb9e80a1afc4b51da7f96b0803", size = 45255, upload-time = "2025-11-09T18:48:39.765Z" }, ] +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.31" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/64/7e/9b35ad8f3d9ca680f7c87a88f19612fdd8da9796c4d3b46e560ac79dcc4a/python_multipart-0.0.31.tar.gz", hash = "sha256:fc631183bb13e56db3158a4909908dfb2e23565286744e798241e63750e5d680", size = 46689, upload-time = "2026-06-04T08:27:49.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/1e/7f7f299527a5a8ad90acd5f2f78dfa6c8495c6301a3205106ea68a84de96/python_multipart-0.0.31-py3-none-any.whl", hash = "sha256:8408153d68a9773291fc1da39a8b85a50044bddbabd2dd72e9229776b7b15e28", size = 29996, upload-time = "2026-06-04T08:27:47.804Z" }, +] + +[[package]] +name = "pywin32" +version = "312" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/f5/10a6e845a00fc5e7afd0a988b744f403d4d57162a28d160a093c4d9322f0/pywin32-312-cp311-cp311-win32.whl", hash = "sha256:17948aeadbdb091f0ced6ef0841620794e68327b94ee415571c1203594b7215c", size = 6362659, upload-time = "2026-06-04T07:49:21.349Z" }, + { url = "https://files.pythonhosted.org/packages/35/c4/dcd2d62b5944b6d5db53413a5899016ccd57ffcb7278f3f81655d25d2027/pywin32-312-cp311-cp311-win_amd64.whl", hash = "sha256:d11417d84412f859b722fad0841b3614459ed0047f7542d8362e77884f6b6e8a", size = 6928825, upload-time = "2026-06-04T07:49:23.934Z" }, + { url = "https://files.pythonhosted.org/packages/b7/56/3cbb433fe4501cdba2eb9040f56a4e1a8243faa4186b25295564d1a7a79d/pywin32-312-cp311-cp311-win_arm64.whl", hash = "sha256:b2200a054ca6d6625c4842fc56a4976a4b47f96b73dbe5538c3f813a80359f47", size = 6721875, upload-time = "2026-06-04T07:49:26.416Z" }, + { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" }, + { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" }, + { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" }, + { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" }, + { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" }, + { url = "https://files.pythonhosted.org/packages/fc/2b/1f3cded5822fd49c02f40544cbb5f58c7cfd6b1694869fd476cb6170ee97/pywin32-312-cp314-cp314-win32.whl", hash = "sha256:a77a90fbb6881238d2ca9c6fd797b25817f3768fe78d214a90137ff055a75f5b", size = 6468928, upload-time = "2026-06-04T07:49:43.188Z" }, + { url = "https://files.pythonhosted.org/packages/21/82/3bf86d2e2808902013132e1ce905a7da0da53790f3836c64bf44d55e24f3/pywin32-312-cp314-cp314-win_amd64.whl", hash = "sha256:a4dd3a848290ef724347b19f301045831d8e802fa4464f491b98b1e0a081432e", size = 7024157, upload-time = "2026-06-04T07:49:45.34Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0e/73f6d6800b4f27655abd9e9f6aaeaefcddb2b946e4674efa2bab184a7f7b/pywin32-312-cp314-cp314-win_arm64.whl", hash = "sha256:9fce94568364e0155e6dfb781ac5d95903be8baf28670632beab1b523f300daa", size = 6839598, upload-time = "2026-06-04T07:49:47.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/61/caa39686032d2ebdd04ff0ab5cbe163126c0066d98e00c9018646e42393b/pywin32-312-cp315-cp315-win32.whl", hash = "sha256:5c1fbe4a937a73ae9297384a3da38518cbc694c68ad8a809b2e19acd350f03ed", size = 6471159, upload-time = "2026-06-04T07:49:50.035Z" }, + { url = "https://files.pythonhosted.org/packages/0f/cd/7e1de64a4a6f69c04214169657ccab0d93a670ea50e35eb8f489d7378249/pywin32-312-cp315-cp315-win_amd64.whl", hash = "sha256:c2f03a0f73f804a13c2735b99392b0cd426bb4f2c4d0178e5ac966a0f21618d5", size = 7025293, upload-time = "2026-06-04T07:49:54.857Z" }, + { url = "https://files.pythonhosted.org/packages/23/ed/4532e9388e65fa16b46776ef47ad631a64eda1631884488af707666350ed/pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9", size = 6840337, upload-time = "2026-06-04T07:49:57.531Z" }, +] + [[package]] name = "pyyaml" version = "6.0.3" @@ -1328,6 +2891,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] +[[package]] +name = "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 = "regex" version = "2026.2.19" @@ -1445,6 +3022,143 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" }, ] +[[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/4f/a0/acf8b6fc20bfdcd3a45bd3f57680fb198e157b7e997b9123b10763798bd2/rpds_py-2026.5.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3397a5ed7174dc2786bb214030232fc36fe8e5584fec43a9952cc542b1a12036", size = 355609, upload-time = "2026-05-28T11:58:50.78Z" }, + { url = "https://files.pythonhosted.org/packages/b6/95/f8203fd997484b1690a6869cd0e503b6c3c6be55b0ecc36d1a491fe742f0/rpds_py-2026.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:99ab6ba7bfa2cb0f96a04e3652355bf04e3f51aceb1e943b8541dab7ba4828cc", size = 348460, upload-time = "2026-05-28T11:58:52.374Z" }, + { url = "https://files.pythonhosted.org/packages/33/8c/b47326ad2f0be545a5e5c1a55937a12afaea7d392ba2837bb9680f57e6c9/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0efbe45632665e53e3db8fe1e5692db58fc5cb9bab4459d570b83efefe11164", size = 381031, upload-time = "2026-05-28T11:58:53.775Z" }, + { url = "https://files.pythonhosted.org/packages/22/0b/e83bbd97ffac6f6389b605cd4e1c8ac5761dc7e977769c9255d8c5adb7bd/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:01d17b29c0c23d82b1f4751147ec49cf451f1fc2554eb9ef5f957e55d2656ead", size = 387121, upload-time = "2026-05-28T11:58:55.243Z" }, + { url = "https://files.pythonhosted.org/packages/fd/0e/d285d1bc8864245919c61e1ca82263e4a66d337759c3a4cef72766ff9afc/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7559f72b94ae52659086c595dfa017cde03155f7832071d30959049052cb3ece", size = 501026, upload-time = "2026-05-28T11:58:56.788Z" }, + { url = "https://files.pythonhosted.org/packages/86/06/ccb2109a1e543437b5e43816f2b43b9554cc6783145528a4e3711e05c011/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e25b7088f9ccbfc0dfcaa52bf969300ca229e10ecf758974ebcbb080a4b37bb", size = 391865, upload-time = "2026-05-28T11:58:58.298Z" }, + { url = "https://files.pythonhosted.org/packages/3d/33/237173db1cfef10105b3839a24de00eb8d2a523711add4632447cdf0aedd/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613fc4ee9eaef26dc5840666214dd6fbcebcf32f46e76f4abc473059f4e13dda", size = 378012, upload-time = "2026-05-28T11:58:59.589Z" }, + { url = "https://files.pythonhosted.org/packages/97/64/1eae54e34d5161f9969295e80bd6b62a55f2b6ac5f2a5b60d02c2140e758/rpds_py-2026.5.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:85264a90ff4c05c1568dd65f5921c837614b67c60358fb4c17df3b7f2e90690a", size = 391111, upload-time = "2026-05-28T11:59:01.104Z" }, + { url = "https://files.pythonhosted.org/packages/d8/34/5bb334a5a0f65d77869217c4654f34c78a7d11b93938a3c076a2edeafc52/rpds_py-2026.5.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe71bca7d547acb17027c7fd1624ff8aae623499c498d3e7011182c4de5c25e0", size = 409225, upload-time = "2026-05-28T11:59:02.433Z" }, + { url = "https://files.pythonhosted.org/packages/16/0f/007ec21283b5b040b4ec3bd95e0402591e22bfa7d5c93dfe01c465c2d2d7/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05fa4f41f37ec97c9c260441a940450a192f78d774d2b097eee1379f1e1246a", size = 556487, upload-time = "2026-05-28T11:59:04.012Z" }, + { url = "https://files.pythonhosted.org/packages/ff/10/5437c94508169b6b22d8418fef7a66e9ffb5f3b9e9c94460f2eedafe06ff/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df1d2a1996755b24b9ecee92cb4d36c28f86f464a6a173349c26bab41e94b8c2", size = 620798, upload-time = "2026-05-28T11:59:05.485Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d5/9937dce4d6bda74157b954e7d1460db05a22f5929dccfeeba1ed27a93df0/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8895840ac4809e5f60c88fd07617cd71326e73d6e5a8aa783c5c0f7c24985de2", size = 584053, upload-time = "2026-05-28T11:59:06.837Z" }, + { url = "https://files.pythonhosted.org/packages/6c/31/750617dd0ae1752471bf43f9e41d263398fae7cde7849d23b8574a70e617/rpds_py-2026.5.1-cp311-cp311-win32.whl", hash = "sha256:3684a59b158a7683aaeb8e25352e9a9dd2122cec78f2d8530266e4f91b4c7b3f", size = 214390, upload-time = "2026-05-28T11:59:08.402Z" }, + { url = "https://files.pythonhosted.org/packages/3c/bb/3dcab0e1d9516303f2eb672a5d6f62eca5a69e2886301e9c8c54b520c39b/rpds_py-2026.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:7bd530e6a530bb3ea892f194fafa455f3516ac25ecf7143fd33c09be62b0470a", size = 231097, upload-time = "2026-05-28T11:59:09.786Z" }, + { url = "https://files.pythonhosted.org/packages/49/d6/c6bbf5cb1cf12b9732df8074b57f6ef8341ba884c95d40632ae8bddb44e4/rpds_py-2026.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:0a5ae4dbe43c1076983b72616496919872ae7bbe7a1e21cc48336bc3154d130b", size = 226361, upload-time = "2026-05-28T11:59:11.079Z" }, + { 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" }, + { url = "https://files.pythonhosted.org/packages/42/56/3fe0fb34820ff667be791b3a3c22b85e8bcba54e9c832f47438c191fa7be/rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:edf2765d84e42447f112ad877af8fe1db0089aaec5b28e88d6eab45e7fe99cea", size = 357151, upload-time = "2026-05-28T12:01:53.43Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f2/3eb9ccdb9f143b8c9b003978898cb497f942a324c077401e6b8834238e63/rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ad3773236e95f7f33991eb125224b7da66f206504d032a253a02da7e134519fb", size = 350195, upload-time = "2026-05-28T12:01:54.901Z" }, + { url = "https://files.pythonhosted.org/packages/a7/24/dbda232bc4f3ed732120692ab0d2c8402cb020516556d8bee622dcef2413/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a04df86b3f0fade39ec8fd0e0aab089b1da9fbd2b48df778a57ef96f5e7d38df", size = 381850, upload-time = "2026-05-28T12:01:56.601Z" }, + { url = "https://files.pythonhosted.org/packages/40/30/32e769839a358f78810c234f160f2cc21d1e4e47e1c0e0e0d535be5a0219/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6142dbd80c4df62a5d899f0d616d417f84e0bc8d32526c8e5589019d75d028a7", size = 387899, upload-time = "2026-05-28T12:01:58.212Z" }, + { url = "https://files.pythonhosted.org/packages/ab/86/ec84d243aadb3b34b71dd26a010d0930b2d284ff5fc9a69fec53810ee6fd/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b35217adefe87f2fe4db7e9766cabe84744bfe9616d9667be18988928c7f2dc", size = 501618, upload-time = "2026-05-28T12:01:59.888Z" }, + { url = "https://files.pythonhosted.org/packages/74/25/b60e52686bbff777a64f9e4f4d3dd57980dc846913777177a2c92e4937aa/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b95d5e11fc712b752081183a55a244c03cd00570489edd7014d8899f8ceb8162", size = 394003, upload-time = "2026-05-28T12:02:01.482Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c7/b3a6a588cc2219510ef3f42e207483a93950bedd1e3a0fd4015c95cff9e5/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:141c9498daf2ace9eda35d2b0e376f9ea8b058d84f2aef4f96fccfd449a2f251", size = 379778, upload-time = "2026-05-28T12:02:03.197Z" }, + { url = "https://files.pythonhosted.org/packages/31/00/c7dba3fc8a3da8cb3f6db1eb3386be4d79c2e97c6890d20eb9ac66ae8c43/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:6f249f8b860a200ad35193af961183ebe9132710484e6f6ce0cf89fd83c63a9a", size = 392359, upload-time = "2026-05-28T12:02:04.817Z" }, + { url = "https://files.pythonhosted.org/packages/93/dd/472ba494c70753f93745992c99855bee0636daf74e6984e5e003f150316f/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e4abbf391a70be864920858bf360f4fb380577c9a0f732438a1996726e2c195b", size = 412820, upload-time = "2026-05-28T12:02:06.401Z" }, + { url = "https://files.pythonhosted.org/packages/1d/6f/93831a3bfe789542ed0c1d0d74b78b440f055d6dc3ea4640eba2d95e6e23/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:c74005a7bb87752acf351c93897ec63ad77a07a0da7ecad9c050e32e7286ba34", size = 557243, upload-time = "2026-05-28T12:02:08.013Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ff/0b3d604614ffc77522c6b288fdbce68957eb583da1002aa65ba38ac0ee40/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:8213afbe8a3a906fb9acb2014423fe3359ee783d0bf90995f70623a3217bfa6c", size = 623541, upload-time = "2026-05-28T12:02:09.661Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ea/e7b0251441da9adfeaebcf29601d10f2a1455fcf0772fae9e7e19032bd96/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8c43a8a973270fd173bf48cdf80bbe66312421cba68d40845034f174f2389049", size = 586326, upload-time = "2026-05-28T12:02:11.47Z" }, +] + [[package]] name = "ruff" version = "0.15.2" @@ -1650,6 +3364,37 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, ] +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "sse-starlette" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "starlette" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f7/2b/58abc2d1fd397e7dde08e947e05c884d8ef2f78d5e2588c17a12d42d6994/sse_starlette-3.4.4.tar.gz", hash = "sha256:07e0fa0460138baf25cdd5fb28683472c3995dc1642225191b3832d62526bcb0", size = 31819, upload-time = "2026-05-12T17:37:17.019Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/67/805710444ea8cc75fbf70b920ed431a560c4bf9c57f7d5a3117213189399/sse_starlette-3.4.4-py3-none-any.whl", hash = "sha256:3f4dd50d8aed2771a091f3a83000323fc3844541c16b4fe585ae2420cc6df973", size = 16514, upload-time = "2026-05-12T17:37:15.601Z" }, +] + [[package]] name = "starlette" version = "0.52.1" @@ -1753,6 +3498,12 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0f/8b/4b61d6e13f7108f36910df9ab4b58fd389cc2520d54d81b88660804aad99/torch-2.10.0-2-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:418997cb02d0a0f1497cf6a09f63166f9f5df9f3e16c8a716ab76a72127c714f", size = 79423467, upload-time = "2026-02-10T21:44:48.711Z" }, { url = "https://files.pythonhosted.org/packages/d3/54/a2ba279afcca44bbd320d4e73675b282fcee3d81400ea1b53934efca6462/torch-2.10.0-2-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:13ec4add8c3faaed8d13e0574f5cd4a323c11655546f91fbe6afa77b57423574", size = 79498202, upload-time = "2026-02-10T21:44:52.603Z" }, { url = "https://files.pythonhosted.org/packages/ec/23/2c9fe0c9c27f7f6cb865abcea8a4568f29f00acaeadfc6a37f6801f84cb4/torch-2.10.0-2-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:e521c9f030a3774ed770a9c011751fb47c4d12029a3d6522116e48431f2ff89e", size = 79498254, upload-time = "2026-02-10T21:44:44.095Z" }, + { url = "https://files.pythonhosted.org/packages/36/ab/7b562f1808d3f65414cd80a4f7d4bb00979d9355616c034c171249e1a303/torch-2.10.0-3-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:ac5bdcbb074384c66fa160c15b1ead77839e3fe7ed117d667249afce0acabfac", size = 915518691, upload-time = "2026-03-11T14:15:43.147Z" }, + { url = "https://files.pythonhosted.org/packages/b3/7a/abada41517ce0011775f0f4eacc79659bc9bc6c361e6bfe6f7052a6b9363/torch-2.10.0-3-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:98c01b8bb5e3240426dcde1446eed6f40c778091c8544767ef1168fc663a05a6", size = 915622781, upload-time = "2026-03-11T14:17:11.354Z" }, + { url = "https://files.pythonhosted.org/packages/ab/c6/4dfe238342ffdcec5aef1c96c457548762d33c40b45a1ab7033bb26d2ff2/torch-2.10.0-3-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:80b1b5bfe38eb0e9f5ff09f206dcac0a87aadd084230d4a36eea5ec5232c115b", size = 915627275, upload-time = "2026-03-11T14:16:11.325Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f0/72bf18847f58f877a6a8acf60614b14935e2f156d942483af1ffc081aea0/torch-2.10.0-3-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:46b3574d93a2a8134b3f5475cfb98e2eb46771794c57015f6ad1fb795ec25e49", size = 915523474, upload-time = "2026-03-11T14:17:44.422Z" }, + { url = "https://files.pythonhosted.org/packages/f4/39/590742415c3030551944edc2ddc273ea1fdfe8ffb2780992e824f1ebee98/torch-2.10.0-3-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:b1d5e2aba4eb7f8e87fbe04f86442887f9167a35f092afe4c237dfcaaef6e328", size = 915632474, upload-time = "2026-03-11T14:15:13.666Z" }, + { url = "https://files.pythonhosted.org/packages/b6/8e/34949484f764dde5b222b7fe3fede43e4a6f0da9d7f8c370bb617d629ee2/torch-2.10.0-3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:0228d20b06701c05a8f978357f657817a4a63984b0c90745def81c18aedfa591", size = 915523882, upload-time = "2026-03-11T14:14:46.311Z" }, { url = "https://files.pythonhosted.org/packages/78/89/f5554b13ebd71e05c0b002f95148033e730d3f7067f67423026cc9c69410/torch-2.10.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:3282d9febd1e4e476630a099692b44fdc214ee9bf8ee5377732d9d9dfe5712e4", size = 145992610, upload-time = "2026-01-21T16:25:26.327Z" }, { url = "https://files.pythonhosted.org/packages/ae/30/a3a2120621bf9c17779b169fc17e3dc29b230c29d0f8222f499f5e159aa8/torch-2.10.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a2f9edd8dbc99f62bc4dfb78af7bf89499bca3d753423ac1b4e06592e467b763", size = 915607863, upload-time = "2026-01-21T16:25:06.696Z" }, { url = "https://files.pythonhosted.org/packages/6f/3d/c87b33c5f260a2a8ad68da7147e105f05868c281c63d65ed85aa4da98c66/torch-2.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:29b7009dba4b7a1c960260fc8ac85022c784250af43af9fb0ebafc9883782ebd", size = 113723116, upload-time = "2026-01-21T16:25:21.916Z" }, @@ -1872,6 +3623,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, ] +[[package]] +name = "tzdata" +version = "2026.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, +] + [[package]] name = "uvicorn" version = "0.41.0" @@ -1899,6 +3659,119 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/42/d7/394801755d4c8684b655d35c665aea7836ec68320304f62ab3c94395b442/virtualenv-20.38.0-py3-none-any.whl", hash = "sha256:d6e78e5889de3a4742df2d3d44e779366325a90cf356f15621fddace82431794", size = 5837778, upload-time = "2026-02-19T07:47:59.778Z" }, ] +[[package]] +name = "xarray" +version = "2026.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4b/a6/6fe936a798a3a38a79c7422d1a31afd2e9a14690fcb0ccff96bc01f04bf2/xarray-2026.4.0.tar.gz", hash = "sha256:c4ac9a01a945d90d5b1628e2af045099a9d4943536d4f2ee3ae963c3b222d15b", size = 3132311, upload-time = "2026-04-13T19:45:36.688Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/83/6d810a8a9ebc9c307989b418840c20e46907c74d707beb67ab566773e6fc/xarray-2026.4.0-py3-none-any.whl", hash = "sha256:d43751d9fb4a90f9249c30431684f00c41bc874f1edccd862631a40cbc0edf08", size = 1414326, upload-time = "2026-04-13T19:45:34.659Z" }, +] + +[[package]] +name = "yarl" +version = "1.24.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/12/1e8f37460ea0f7eb59c221fdaf0ed75e7ac43e97f8093b9c6f411df50a78/yarl-1.24.2.tar.gz", hash = "sha256:9ac374123c6fd7abf64d1fec93962b0bd4ee2c19751755a762a72dd96c0378f8", size = 210798, upload-time = "2026-05-19T21:31:05.599Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/c5/1ce244152ff2839645e7cae92f90e7bafcb2c52bea7ff586ac714f14f5df/yarl-1.24.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:36348bebb147b83818b9d7e673ea4debc75970afc6ffdc7e3975ad05ce5a58c1", size = 128971, upload-time = "2026-05-19T21:28:20.543Z" }, + { url = "https://files.pythonhosted.org/packages/87/5a/00f36967203ed89cb3acd2c8ed526cc3fed9418eb70ce128160a911c8499/yarl-1.24.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a97e42c8a2233f2f279ecadd9e4a037bcb5d813b78435e8eedd4db5a9e9708c", size = 91507, upload-time = "2026-05-19T21:28:22.556Z" }, + { url = "https://files.pythonhosted.org/packages/31/d0/1fb0c1cd27288f39f6974da4318c32768d72c9890984541fdf1e2e32a51d/yarl-1.24.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8d027d56f1035e339d1001ac33eceab5b2ec8e42e449787bb75e289fb9a5cd1d", size = 91343, upload-time = "2026-05-19T21:28:24.092Z" }, + { url = "https://files.pythonhosted.org/packages/03/ce/d4a646508bed2f8dec6435b40166fe9308dd191262033d3f307b2bbcaecd/yarl-1.24.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a6377060e7927187a42b7eb202090cbe2b34933a4eeaf90e3bd9e33432e5cae", size = 105704, upload-time = "2026-05-19T21:28:25.872Z" }, + { url = "https://files.pythonhosted.org/packages/4b/07/b3278e82d8bc41485bcf6d856cd0433262593de615b1d3dc43bd3f5bead4/yarl-1.24.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:17076578bce0049a5ce57d14ad1bded391b68a3b213e9b81b0097b090244999a", size = 97281, upload-time = "2026-05-19T21:28:27.352Z" }, + { url = "https://files.pythonhosted.org/packages/17/5b/4cee6e7c92e487bebe7afc797da0aa54a248ab4e776a68fe369ec29665a5/yarl-1.24.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:50713f1d4d6be6375bb178bb43d140ee1acb8abe589cd723320b7925a275be1e", size = 114020, upload-time = "2026-05-19T21:28:29.458Z" }, + { url = "https://files.pythonhosted.org/packages/5c/82/111076571545a7d4f9cca3fbd5c6f40615af58642be09f12328f48022468/yarl-1.24.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:34263e2fa8fb5bb63a0d97706cda38edbad62fddb58c7f12d6acbc092812aa50", size = 111450, upload-time = "2026-05-19T21:28:31.262Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ec/08f671f69a444d704aeecebf92af659b67b97a869942411d0a578b08c334/yarl-1.24.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49016d82f032b1bd1e10b01078a7d29ae71bf468eeae0ea22df8bab691e60003", size = 106384, upload-time = "2026-05-19T21:28:32.856Z" }, + { url = "https://files.pythonhosted.org/packages/e5/86/ce41e7a7a199340b2330d52b60f25c4074b6636dd0e60b1a80d31a9db042/yarl-1.24.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3f6d2c216318f8f32038ca3f72501ba08536f0fd18a36e858836b121b2deed9f", size = 106153, upload-time = "2026-05-19T21:28:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5d/31be8a729531ab3e55ac3e7e5c800be8c89ea98947f418b2f6ea259fb6ee/yarl-1.24.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:08d3a33218e0c64393e7610284e770409a9c31c429b078bcb24096ed0a783b8f", size = 105322, upload-time = "2026-05-19T21:28:36.642Z" }, + { url = "https://files.pythonhosted.org/packages/47/9b/b57afb22b386ae87ac9940f09878b98d8c333f89113e6fc96fcf4ca9eb64/yarl-1.24.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:5d699376c4ca3cba49bbfae3a05b5b70ded572937171ce1e0b8d87118e2ba294", size = 99057, upload-time = "2026-05-19T21:28:38.386Z" }, + { url = "https://files.pythonhosted.org/packages/a3/4f/06348c27c8389256c313e8a57d796808fc0264c915dd5e7cfd3c0e314dc7/yarl-1.24.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a1cab588b4fa14bea2e55ebea27478adfb05372f47573738e1acc4a36c0b05d2", size = 113502, upload-time = "2026-05-19T21:28:40.091Z" }, + { url = "https://files.pythonhosted.org/packages/5f/1c/284f307b298e4a17b7943b07d9d7ecc4151537f8d137ba51f3bb6c31ca20/yarl-1.24.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ec87ccc31bd21db7ad009d8572c127c1000f268517618a4cc09adba3c2a7f21c", size = 105253, upload-time = "2026-05-19T21:28:41.987Z" }, + { url = "https://files.pythonhosted.org/packages/c8/bf/0de123bec8619e45c80cbded9085f61b5b4a9eddb8abe6d25d28ee1ec866/yarl-1.24.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d1dd47a22843b212baa8d74f37796815d43bd046b42a0f41e9da433386c3136b", size = 111345, upload-time = "2026-05-19T21:28:43.93Z" }, + { url = "https://files.pythonhosted.org/packages/90/af/0248eb065e51129d2a9b2436cd1b5c772c19a6b04e5b6a186955671e3319/yarl-1.24.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7b54b9c67c2b06bd7b9a77253d242124b9c95d2c02def5a1144001ee547dd9d5", size = 106558, upload-time = "2026-05-19T21:28:45.806Z" }, + { url = "https://files.pythonhosted.org/packages/21/3c/f960d7a65ef97d8ba9b424fb5128796a4bc710fc6df2ddbbd7dfdc3bbd20/yarl-1.24.2-cp311-cp311-win_amd64.whl", hash = "sha256:f8fdbcff8b2c7c9284e60c196f693588598ddcee31e11c18e14949ce44519d45", size = 92808, upload-time = "2026-05-19T21:28:48.465Z" }, + { url = "https://files.pythonhosted.org/packages/03/1a/49fb03750e4de4d2284cd5b885a383133c34eef45bd59631b2bb8b7e81e8/yarl-1.24.2-cp311-cp311-win_arm64.whl", hash = "sha256:b32c37a7a337e90822c45797bf3d79d60875cfcccd3ecc80e9f453d87026c122", size = 87610, upload-time = "2026-05-19T21:28:50.07Z" }, + { url = "https://files.pythonhosted.org/packages/f0/da/866bcb01076ba49d2b42b309867bed3826421f1c479655eb7a607b44f20b/yarl-1.24.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b975866c184564c827e0877380f0dae57dcca7e52782128381b72feff6dfceb8", size = 129957, upload-time = "2026-05-19T21:28:51.695Z" }, + { url = "https://files.pythonhosted.org/packages/bf/1d/fcefb70922ea2268a8971d8e5874d9a8218644200fb8465f1dcad55e6851/yarl-1.24.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3b075301a2836a0e297b1b658cb6d6135df535d62efefdd60366bd589c2c82f2", size = 92164, upload-time = "2026-05-19T21:28:53.242Z" }, + { url = "https://files.pythonhosted.org/packages/29/b6/170e2b8d4e3bc30e6bfdcca53556537f5bf595e938632dfcb059311f3ff6/yarl-1.24.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8ae44649b00947634ab0dab2a374a638f52923a6e67083f2c156cd5cbd1a881d", size = 91688, upload-time = "2026-05-19T21:28:54.865Z" }, + { url = "https://files.pythonhosted.org/packages/fe/a5/c9f655d5553ea0b99fdac9d6a99ad3f9b3e73b8e5758bb46f58c9831f74c/yarl-1.24.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:507cc19f0b45454e2d6dcd62ff7d062b9f77a2812404e62dbdaec05b50faa035", size = 102902, upload-time = "2026-05-19T21:28:56.963Z" }, + { url = "https://files.pythonhosted.org/packages/5d/bc/6b9664d815d79af4ee553337f9d606c56bbf269186ada9172de45f1b5f60/yarl-1.24.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4c17bad5a530912d2111825d3f05e89bab2dd376aaa8cbc77e449e6db63e576", size = 97931, upload-time = "2026-05-19T21:28:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/98/ec/32ba48acae30fecd60928f5791188b80a9d6ee3840507ffda29fecd37b71/yarl-1.24.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f5f0cbb112838a4a293985b6ed73948a547dadcc1ba6d2089938e7abdedceef8", size = 111030, upload-time = "2026-05-19T21:29:00.148Z" }, + { url = "https://files.pythonhosted.org/packages/82/5a/6f4cd081e5f4934d2ae3a8ef4abe3afacc010d26f0035ee91b35cd7d7c37/yarl-1.24.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5ec8356b8a6afcf81fc7aeeef13b1ff7a49dec00f313394bbb9e83830d32ccd7", size = 110392, upload-time = "2026-05-19T21:29:02.155Z" }, + { url = "https://files.pythonhosted.org/packages/7a/da/323a01c349bd5fb01bb6652e314d9bb218cee630a736bdb810ad50e4013f/yarl-1.24.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e7ebcdef69dec6c6451e616f32b622a6d4a2e92b445c992f7c8e5274a6bbc4c", size = 105612, upload-time = "2026-05-19T21:29:04.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/80/264ab684f181e1a876389374519ff05d10248725535ae2ac4e8ac4e563d6/yarl-1.24.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:47a55d6cf6db2f401017a9e96e5288844e5051911fb4e0c8311a3980f5e59a7d", size = 104487, upload-time = "2026-05-19T21:29:06.491Z" }, + { url = "https://files.pythonhosted.org/packages/41/07/efabe5df87e96d7ad5959760b888344be48cd6884db127b407c6b5503adc/yarl-1.24.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3065657c80a2321225e804048597ad55658a7e76b32d6f5ee4074d04c50401db", size = 102333, upload-time = "2026-05-19T21:29:08.267Z" }, + { url = "https://files.pythonhosted.org/packages/44/0c/bcf7c42603e1009295f586d8890f2ba032c8b53310e815adf0a202c73d9f/yarl-1.24.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:cb84b80d88e19ede158619b80813968713d8d008b0e2497a576e6a0557d50712", size = 99025, upload-time = "2026-05-19T21:29:10.682Z" }, + { url = "https://files.pythonhosted.org/packages/4f/82/84482ab1a57a0f21a08afe6a7004c61d741f8f2ecc3b05c321577c612164/yarl-1.24.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:990de4f680b1c217e77ff0d6aa0029f9eb79889c11fb3e9a3942c7eba29c1996", size = 110507, upload-time = "2026-05-19T21:29:12.954Z" }, + { url = "https://files.pythonhosted.org/packages/c4/8d/a546ba1dfe1b0f290e05fef145cd07614c0f15df1a707195e512d1e39d1d/yarl-1.24.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:abb8ec0323b80161e3802da3150ef660b41d0e9be2048b76a363d93eee992c2b", size = 103719, upload-time = "2026-05-19T21:29:14.893Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b6/267f2a09213138473adfce6b8a6e17791d7fee70bd4d9003218e4dec58b0/yarl-1.24.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e7977781f83638a4c73e0f88425563d70173e0dfd90ac006a45c65036293ee3c", size = 110438, upload-time = "2026-05-19T21:29:16.485Z" }, + { url = "https://files.pythonhosted.org/packages/48/2d/1c8d89c7c5f9cad9fb2902445d94e2ab1d7aa35de029afbb8ae95c42d00f/yarl-1.24.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e30dd55825dc554ec5b66a94953b8eda8745926514c5089dfcacecb9c99b5bd1", size = 105719, upload-time = "2026-05-19T21:29:18.367Z" }, + { url = "https://files.pythonhosted.org/packages/a7/25/722e3b93bd687009afb2d59a35e13d30ddd8f80571445bb0c4e4ce26ec66/yarl-1.24.2-cp312-cp312-win_amd64.whl", hash = "sha256:7dafe10c12ddd4d120d528c4b5599c953bd7b12845347d507b95451195bb6cad", size = 92901, upload-time = "2026-05-19T21:29:20.014Z" }, + { url = "https://files.pythonhosted.org/packages/39/47/4486ccfb674c04854a1ef8aa77868b6a6f765feaf69633409d7ca4f02cb8/yarl-1.24.2-cp312-cp312-win_arm64.whl", hash = "sha256:044a09d8401fcf8681977faef6d286b8ade1e2d2e9dceda175d1cfa5ca496f30", size = 87229, upload-time = "2026-05-19T21:29:22.1Z" }, + { url = "https://files.pythonhosted.org/packages/82/62/fcf0ce677f17e5c471c06311dd25964be38a4c586993632910d2e75278bc/yarl-1.24.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:491ac9141decf49ee8030199e1ee251cdff0e131f25678817ff6aa5f837a3536", size = 128978, upload-time = "2026-05-19T21:29:23.83Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/8e63299bb71ed61a834121d9d3fe6c9fcf2a6a5d09754ff4f20f2d20baf5/yarl-1.24.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e89418f65eda18f99030386305bd44d7d504e328a7945db1ead514fbe03a0607", size = 91733, upload-time = "2026-05-19T21:29:25.375Z" }, + { url = "https://files.pythonhosted.org/packages/c1/24/16748d5dab6daec8b0ed81ccec639a1cded0f18dcc62a4f696b4fe366c37/yarl-1.24.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cdfcce633b4a4bb8281913c57fcafd4b5933fbc19111a5e3930bbd299d6102f1", size = 91113, upload-time = "2026-05-19T21:29:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/1b/66/b63fff7b71211e866624b21432d5943cbb633eb0c2872d9ee3070648f22c/yarl-1.24.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:863297ddede92ee49024e9a9b11ecb59f310ca85b60d8537f56bed9bbb5b1986", size = 103899, upload-time = "2026-05-19T21:29:28.842Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/ba1974b8533909636f7733fe86cf677e3619527c3c2fa913e0ea89c48757/yarl-1.24.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:374423f70754a2c96942ede36a29d37dc6b0cb8f92f8d009ddf3ed78d3da5488", size = 97862, upload-time = "2026-05-19T21:29:31.086Z" }, + { url = "https://files.pythonhosted.org/packages/1b/a5/123ac993b5c2ba6f554a140305620cb8f150fa543711bbc49be3ec0a65a4/yarl-1.24.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:33a29b5d00ccbf3219bb3e351d7875739c19481e030779f48cc46a7a71681a9b", size = 111060, upload-time = "2026-05-19T21:29:32.657Z" }, + { url = "https://files.pythonhosted.org/packages/23/37/c472d3af3509688392134a88a825276770a187f1daa4de3f6dc0a327a751/yarl-1.24.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a9532c57211730c515341af11fef6e9b61d157487272a096d0c04da445642592", size = 110613, upload-time = "2026-05-19T21:29:34.379Z" }, + { url = "https://files.pythonhosted.org/packages/df/88/09c28dad91e662ccfaa1b78f1c57badde74fc9d0b23e74aef644750ecd73/yarl-1.24.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:91e72cf093fd833483a97ee648e0c053c7c629f51ff4a0e7edd84f806b0c5617", size = 107012, upload-time = "2026-05-19T21:29:36.216Z" }, + { url = "https://files.pythonhosted.org/packages/07/ab/9d4f69d571a94f4d112fa7e2e007200f5a54d319f58c82ac7b7baa61f5c6/yarl-1.24.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b3177bc0a768ef3bacceb4f272632990b7bea352f1b2f1eee9d6d6ff16516f92", size = 105887, upload-time = "2026-05-19T21:29:38.746Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9a/000b2b66c0d772a499fc531d21dab92dfeb73b640a12eed6ba89f49bb2d0/yarl-1.24.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e196952aacaf3b232e265ff02980b64d483dc0972bd49bcb061171ff22ac203a", size = 103620, upload-time = "2026-05-19T21:29:40.368Z" }, + { url = "https://files.pythonhosted.org/packages/41/7c/7c1050f73450fbdaa3f0c72017059f00ce5e13366692f3dba25275a1083d/yarl-1.24.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:204e7a61ce99919c0de1bf904ab5d7aa188a129ea8f690a8f76cfb6e2844dc44", size = 100599, upload-time = "2026-05-19T21:29:42.66Z" }, + { url = "https://files.pythonhosted.org/packages/ec/b1/29e5756b3926705f5f6089bd5b9f50a56eaac550da6e260bf713ead44d04/yarl-1.24.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b156914620f0b9d78dc1adb3751141daee561cfec796088abb89ed49d220f1a", size = 110604, upload-time = "2026-05-19T21:29:44.632Z" }, + { url = "https://files.pythonhosted.org/packages/a3/4b/8415bc96e9b150cde942fbac9a8182985e58f40ce5c54c34ed015407d3ee/yarl-1.24.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8372a2b976cf70654b2be6619ab6068acabb35f724c0fda7b277fbf53d66a5cf", size = 105161, upload-time = "2026-05-19T21:29:46.755Z" }, + { url = "https://files.pythonhosted.org/packages/8b/d4/cde059abfa229553b7298a2eadde2752e723d50aeedaef86ce59da2718ee/yarl-1.24.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:f9a1e9b622ca284143aab5d885848686dcd85453bb1ca9abcdb7503e64dc0056", size = 110619, upload-time = "2026-05-19T21:29:48.972Z" }, + { url = "https://files.pythonhosted.org/packages/e7/2c/d6a6c9a61549f7b6c7e6dc6937d195bcf069582b47b7200dcd0e7b256acf/yarl-1.24.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:810e19b685c8c3c5862f6a38160a1f4e4c0916c9390024ec347b6157a45a0992", size = 107362, upload-time = "2026-05-19T21:29:51Z" }, + { url = "https://files.pythonhosted.org/packages/92/dd/3ae5fe417e9d1c353a548553326eb9935e76b6b727161563b424cc296df3/yarl-1.24.2-cp313-cp313-win_amd64.whl", hash = "sha256:7d37fb7c38f2b6edab0f845c4f85148d4c44204f52bc127021bd2bc9fdbf1656", size = 92667, upload-time = "2026-05-19T21:29:52.743Z" }, + { url = "https://files.pythonhosted.org/packages/10/cc/a7beb239f78f27fca1b053c8e8595e4179c02e62249b4687ec218c370c50/yarl-1.24.2-cp313-cp313-win_arm64.whl", hash = "sha256:1e831894be7c2954240e49791fa4b50c05a0dc881de2552cfe3ffd8631c7f461", size = 87069, upload-time = "2026-05-19T21:29:54.442Z" }, + { url = "https://files.pythonhosted.org/packages/40/0e/e08087695fc12789263821c5dc0f8dc52b5b17efd0887cacf419f8a43ba3/yarl-1.24.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:f9312b3c02d9b3d23840f67952913c9c8721d7f1b7db305289faefa878f364c2", size = 129670, upload-time = "2026-05-19T21:29:56.631Z" }, + { url = "https://files.pythonhosted.org/packages/3a/98/ab4b5ed1b1b5cd973c8a3eb994c3a6aefb6ce6d399e21bb5f0316c33815c/yarl-1.24.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a4f4d6cd615823bfc7fb7e9b5987c3f41666371d870d51058f77e2680fbe9630", size = 91916, upload-time = "2026-05-19T21:29:58.645Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b1/5297bb6a7df4782f7605bffc43b31f5044070935fbbcaa6c705a07e6ac65/yarl-1.24.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0c3063e5c0a8e8e62fae6c2596fa01da1561e4cd1da6fec5789f5cf99a8aefd8", size = 91625, upload-time = "2026-05-19T21:30:00.412Z" }, + { url = "https://files.pythonhosted.org/packages/02/a7/45baabfff76829264e623b185cff0c340d7e11bf3e1cd9ea37e7d17934bd/yarl-1.24.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fecd17873a096036c1c87ab3486f1aef7f269ada7f23f7f856f93b1cc7744f14", size = 104574, upload-time = "2026-05-19T21:30:02.544Z" }, + { url = "https://files.pythonhosted.org/packages/f3/40/3a5ab144d3d650ca37d4f4b57e56169be8af3ca34c448793e064b30baaed/yarl-1.24.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a46d1ab4ba4d32e6dc80daf8a28ce0bd83d08df52fbc32f3e288663427734535", size = 97534, upload-time = "2026-05-19T21:30:04.319Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b5/5658fef3681fb5776b4513b052bec750009f47b3a592251c705d75375798/yarl-1.24.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:73e68edf6dfd5f73f9ca127d84e2a6f9213c65bdffb736bda19524c0564fcd14", size = 111481, upload-time = "2026-05-19T21:30:05.988Z" }, + { url = "https://files.pythonhosted.org/packages/4c/06/fdcd7dde037f00866dce123ed4ba23dba94beb56fc4cf561668d27be37f2/yarl-1.24.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a296ca617f2d25fbceafb962b88750d627e5984e75732c712154d058ae8d79a3", size = 111529, upload-time = "2026-05-19T21:30:07.738Z" }, + { url = "https://files.pythonhosted.org/packages/c2/53/d81269aaafccea0d33396c03035de997b743f11e648e6e27a0df99c72980/yarl-1.24.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51b2cf5ec89a8b8470177641ed62a3ba22d74e1e898e06ad53aa77972487208", size = 107338, upload-time = "2026-05-19T21:30:09.713Z" }, + { url = "https://files.pythonhosted.org/packages/ae/04/23049463f729bd899df203a7960505a75333edd499cda8aa1d5a82b64df5/yarl-1.24.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:310fc687f7b2044ec54e372c8cbe923bb88f5c37bded0d3079e5791c2fc3cf50", size = 106147, upload-time = "2026-05-19T21:30:11.365Z" }, + { url = "https://files.pythonhosted.org/packages/14/18/04a4b5830b43ed5e4c5015b40e9f6241ad91487d71611061b4e111d6ac80/yarl-1.24.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:297a2fe352ecf858b30a98f87948746ec16f001d279f84aebdbd3bd965e2f1bd", size = 104272, upload-time = "2026-05-19T21:30:12.978Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f7/8cffdf319aee7a7c1dbd07b61d91c3e3fda460c7a93b5f93e445f3806c4c/yarl-1.24.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2a263e76b97bc42bdcd7c5f4953dec1f7cd62a1112fa7f869e57255229390d67", size = 99962, upload-time = "2026-05-19T21:30:15.001Z" }, + { url = "https://files.pythonhosted.org/packages/d7/39/b3cce3b7dbef64ac700ad4cea156a207d01bede0f507587616c364b5468e/yarl-1.24.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:822519b64cf0b474f1a0aaef1dc621438ea46bb77c94df97a5b4d213a7d8a8b1", size = 111063, upload-time = "2026-05-19T21:30:16.683Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ea/100818505e7ebf165c7242ff17fdf7d9fee79e27234aeca871c1082920d7/yarl-1.24.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b6067060d9dc594899ba83e6db6c48c68d1e494a6dab158156ed86977ca7bcb1", size = 105438, upload-time = "2026-05-19T21:30:18.769Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d2/e075a0b32aa6625087de9e653087df0759fed5de4a435fef594181102a77/yarl-1.24.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0063adad533e57171b79db3943b229d40dfafeeee579767f96541f106bac5f1b", size = 111458, upload-time = "2026-05-19T21:30:21.024Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5c/ceea7ba98b65c8eb8d947fdc52f9bedfcd43c6a57c9e3c90c17be8f324a3/yarl-1.24.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ee8e3fb34513e8dc082b586ef4910c98335d43a6fab688cd44d4851bacfce3e8", size = 107589, upload-time = "2026-05-19T21:30:23.412Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d9/5582d57e2b2db9b85eb6663a22efdd78e08805f3f5389566e9fcad254d1b/yarl-1.24.2-cp314-cp314-win_amd64.whl", hash = "sha256:afb00d7fd8e0f285ca29a44cc50df2d622ff2f7a6d933fa641577b5f9d5f3db0", size = 94424, upload-time = "2026-05-19T21:30:25.425Z" }, + { url = "https://files.pythonhosted.org/packages/92/10/7dc07a0e22806a9280f42a57361395506e800c64e22737cd7b0886feab42/yarl-1.24.2-cp314-cp314-win_arm64.whl", hash = "sha256:68cf6eacd6028ef1142bc4b48376b81566385ca6f9e7dde3b0fa91be08ffcb57", size = 88690, upload-time = "2026-05-19T21:30:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/9e/13/d5b8e2c8667db955bcb3de233f18798fefe7edf1d7429c2c9d4f9c401114/yarl-1.24.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:221ce1dd921ac4f603957f17d7c18c5cc0797fbb52f156941f92e04605d1d67b", size = 136248, upload-time = "2026-05-19T21:30:29.297Z" }, + { url = "https://files.pythonhosted.org/packages/de/46/a4a97c05c9c9b8fd266bb2a0df12992c7fbd02391eb9640583411b6dab32/yarl-1.24.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5f3224db28173a00d7afacdee07045cc4673dfab2b15492c7ae10deddbece761", size = 95084, upload-time = "2026-05-19T21:30:31.031Z" }, + { url = "https://files.pythonhosted.org/packages/95/b2/845cf2074a015e6fe0d0808cf1a2d9e868386c4220d657ebd8302b199043/yarl-1.24.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c557165320d6244ebe3a02431b2a201a20080e02f41f0cfa0ccc47a183765da8", size = 95272, upload-time = "2026-05-19T21:30:33.062Z" }, + { url = "https://files.pythonhosted.org/packages/fe/16/e69d4aa244aef45235ddfebc0e04036a6829842bc5a6a795aedc6c998d23/yarl-1.24.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:904065e6e85b1fa54d0d87438bd58c14c0bad97aad654ad1077fd9d87e8478ed", size = 101497, upload-time = "2026-05-19T21:30:34.842Z" }, + { url = "https://files.pythonhosted.org/packages/15/94/c07107715d621076863ee88b3ddf183fa5e9d4aba5769623c9979828410a/yarl-1.24.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8cec2a38d70edc10e0e856ceda886af5327a017ccbde8e1de1bd44d300357543", size = 94002, upload-time = "2026-05-19T21:30:37.724Z" }, + { url = "https://files.pythonhosted.org/packages/a9/35/fc1bbdd895b5e4010b8fdd037f7ed3aa289d3863e08231b30231ca9a0815/yarl-1.24.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e7484b9361ed222ee1ca5b4337aa4cbdcc4618ce5aff57d9ef1582fd95893fc0", size = 106524, upload-time = "2026-05-19T21:30:40.196Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/32b66d0a4ba47c296cf86d03e2c67bff58399fe6d6d84d5205c04c66cc6d/yarl-1.24.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:84f9670b89f34db07f81e53aee83e0b938a3412329d51c8f922488be7fcc4024", size = 106165, upload-time = "2026-05-19T21:30:41.888Z" }, + { url = "https://files.pythonhosted.org/packages/95/47/37cb5ff50c5e825d4d38e81bb04d1b7e96bf960f7ab89f9850b162f3f114/yarl-1.24.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:abb2759733d63a28b4956500a5dd57140f26486c92b2caedfb964ab7d9b79dbf", size = 103010, upload-time = "2026-05-19T21:30:43.985Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d2/4597912315096f7bb359e46e13bf8b60994fcbb2db29b804c0902ef4eff5/yarl-1.24.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:081c2bf54efe03774d0311172bc04fedf9ca01e644d4cd8c805688e527209bdc", size = 101128, upload-time = "2026-05-19T21:30:46.291Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d5/c8e86e120521e646013d02a8e3b8884392e28494be8f392366e50d208efc/yarl-1.24.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:86746bef442aa479107fe28132e1277237f9c24c2f00b0b0cf22b3ee0904f2bb", size = 101382, upload-time = "2026-05-19T21:30:48.085Z" }, + { url = "https://files.pythonhosted.org/packages/fa/98/70b229236118f89dbeb739b76f10225bbf53b5497725502594c9a01d699a/yarl-1.24.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:2d07d21d0bc4b17558e8de0b02fbfdf1e347d3bb3699edd00bb92e7c57925420", size = 95964, upload-time = "2026-05-19T21:30:49.785Z" }, + { url = "https://files.pythonhosted.org/packages/87/f8/56c386981e3c8648d279fdef2397ffec577e8320fd5649745e34d54faeb7/yarl-1.24.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:4fb1ac3fc5fecd8ae7453ea237e4d22b49befa70266dfe1629924245c21a0c7f", size = 106204, upload-time = "2026-05-19T21:30:51.862Z" }, + { url = "https://files.pythonhosted.org/packages/1a/1e/765afe97811ca35933e2a7de70ac57b1997ea2e4ee895719ee7a231fb7e5/yarl-1.24.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4da31a5512ed1729ca8d8aacde3f7faeb8843cde3165d6bcf7f88f74f17bb8aa", size = 101510, upload-time = "2026-05-19T21:30:53.62Z" }, + { url = "https://files.pythonhosted.org/packages/ee/78/393913f4b9039e1edd09ae8a9bbb9d539be909a8abf6d8a2084585bed4b7/yarl-1.24.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:533ded4dceb5f1f3da7906244f4e82cf46cfd40d84c69a1faf5ac506aa65ecbe", size = 105584, upload-time = "2026-05-19T21:30:55.962Z" }, + { url = "https://files.pythonhosted.org/packages/78/87/deb17b7049bbe74ea11a713b86f8f27800cc1c8648b0b797243ebb4830ba/yarl-1.24.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7b3a85525f6e7eeabcfdd372862b21ee1915db1b498a04e8bf0e389b607ff0bd", size = 103410, upload-time = "2026-05-19T21:30:57.962Z" }, + { url = "https://files.pythonhosted.org/packages/8f/be/f9f7594e23b5b93affff0318e4593c1920331bcaefda326cabcad94296a1/yarl-1.24.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a7624b1ca46ca5d7b864ef0d2f8efe3091454085ee1855b4e992314529972215", size = 102980, upload-time = "2026-05-19T21:30:59.735Z" }, + { url = "https://files.pythonhosted.org/packages/65/a4/ba80dccd3593ff1f01051a818694d07b58cb8232677ee9a22a5a1f93a9fc/yarl-1.24.2-cp314-cp314t-win_arm64.whl", hash = "sha256:e434a45ce2e7a947f951fc5a8944c8cc080b7e59f9c50ae80fd39107cf88126d", size = 91219, upload-time = "2026-05-19T21:31:01.934Z" }, + { url = "https://files.pythonhosted.org/packages/fd/4d/4b880086bd0d3e034d25647be1d830afc3e3f610e98c4ab3490af6b1b6d5/yarl-1.24.2-py3-none-any.whl", hash = "sha256:2783d9226db8797636cd6896e4de81feed252d1db72265686c9558d97a4d94b9", size = 53576, upload-time = "2026-05-19T21:31:03.909Z" }, +] + [[package]] name = "zipp" version = "3.23.0" diff --git a/src/clio_kit/__init__.py b/src/clio_kit/__init__.py index ff6d70ea..ac3a74ec 100644 --- a/src/clio_kit/__init__.py +++ b/src/clio_kit/__init__.py @@ -368,17 +368,21 @@ def search(args): """Run agentic search commands (query, index, serve, list, seed).""" if not args: - click.echo("clio-kit search: Hybrid retrieval engine for scientific corpora") + click.echo("clio-kit search: Agentic hybrid retrieval engine for scientific corpora") click.echo("\nSubcommands:") - click.echo(" query Run retrieval queries") + click.echo(" query Run retrieval queries (add --agentic for the multi-hop loop)") click.echo(" index Index documents into a namespace") click.echo(" serve Start the FastAPI server") click.echo(" list List indexed documents") click.echo(" seed Seed sample data") + click.echo("\nNamespaces: local_fs, object_s3, vector_qdrant, hdf5_data, netcdf_data") click.echo("\nUsage: uvx clio-kit search [options]") click.echo("\nExamples:") click.echo(' uvx clio-kit search query --namespace local_fs --q "pressure > 200 kPa"') - click.echo(" uvx clio-kit search index --namespace local_fs") + click.echo(' uvx clio-kit search query --namespace local_fs --q "F=ma" --formula "F=ma"') + click.echo(' uvx clio-kit search query --namespace local_fs --q "turbulence" \\') + click.echo(" --agentic --max-hops 3 --llm-rewrite") + click.echo(" uvx clio-kit search index --namespace hdf5_data") click.echo(" uvx clio-kit search serve --port 8080") return