From c230dcc11fd68d8d0a6d773fe02396bc1b1ab111 Mon Sep 17 00:00:00 2001 From: Ben Date: Mon, 16 Mar 2026 16:46:25 -0400 Subject: [PATCH 1/3] feat: add Agno integration with Hindsight memory toolkit Add hindsight-agno package providing Hindsight memory tools (retain, recall, reflect) as an Agno Toolkit, following the same pattern as Agno's Mem0Tools. Includes per-user bank isolation, global config, bank auto-creation, and memory_instructions() for system prompt injection. Also adds cookbook documentation page with architecture diagrams, quick start examples, and configuration reference. Co-Authored-By: Claude Opus 4.6 --- .../cookbook/applications/agno-memory.md | 322 +++ hindsight-docs/src/pages/cookbook/index.mdx | 6 + hindsight-integrations/agno/README.md | 186 ++ .../agno/hindsight_agno/__init__.py | 46 + .../agno/hindsight_agno/config.py | 92 + .../agno/hindsight_agno/errors.py | 7 + .../agno/hindsight_agno/tools.py | 345 ++++ hindsight-integrations/agno/pyproject.toml | 52 + hindsight-integrations/agno/tests/__init__.py | 0 .../agno/tests/test_config.py | 169 ++ .../agno/tests/test_tools.py | 1836 +++++++++++++++++ hindsight-integrations/agno/uv.lock | 1425 +++++++++++++ 12 files changed, 4486 insertions(+) create mode 100644 hindsight-docs/src/pages/cookbook/applications/agno-memory.md create mode 100644 hindsight-integrations/agno/README.md create mode 100644 hindsight-integrations/agno/hindsight_agno/__init__.py create mode 100644 hindsight-integrations/agno/hindsight_agno/config.py create mode 100644 hindsight-integrations/agno/hindsight_agno/errors.py create mode 100644 hindsight-integrations/agno/hindsight_agno/tools.py create mode 100644 hindsight-integrations/agno/pyproject.toml create mode 100644 hindsight-integrations/agno/tests/__init__.py create mode 100644 hindsight-integrations/agno/tests/test_config.py create mode 100644 hindsight-integrations/agno/tests/test_tools.py create mode 100644 hindsight-integrations/agno/uv.lock diff --git a/hindsight-docs/src/pages/cookbook/applications/agno-memory.md b/hindsight-docs/src/pages/cookbook/applications/agno-memory.md new file mode 100644 index 000000000..c114b20fc --- /dev/null +++ b/hindsight-docs/src/pages/cookbook/applications/agno-memory.md @@ -0,0 +1,322 @@ +--- +sidebar_position: 16 +--- + +# Agno + Hindsight Memory + +:::info Complete Application +This is a complete, runnable application demonstrating Hindsight integration. +[**View source on GitHub →**](https://github.com/vectorize-io/hindsight/tree/main/hindsight-integrations/agno) +::: + +Give your Agno agents persistent long-term memory. Build agents that remember users across conversations, learn preferences over time, and synthesize insights from past interactions. + +## What This Demonstrates + +- **Native Toolkit pattern** — retain, recall, and reflect registered as Agno tools via `HindsightTools` +- **Auto-injected context** — pre-recalled memories in the system prompt via `memory_instructions()` +- **Per-user memory banks** — automatic bank isolation using `RunContext.user_id` +- **Progressive learning** — the agent gets smarter with each interaction + +## Architecture + +``` +Run 1 (user: alice): + Alice: "I'm a vegetarian and I prefer window seats on flights" + │ + ├─ memory_instructions() ──► recalls prior context (empty on first run) + ├─ Agent calls retain_memory ──► stores preferences + └─ Agent responds with acknowledgement + +Run 2 (user: alice): + Alice: "Help me plan a trip to Tokyo" + │ + ├─ memory_instructions() ──► injects "User is vegetarian, prefers window seats..." + ├─ Agent calls recall_memory ──► finds dietary + travel preferences + └─ Agent recommends vegetarian restaurants, books window seats + +Run 3 (user: bob): + Bob: "What do you know about me?" + │ + ├─ memory_instructions() ──► recalls Bob's context (empty — separate bank) + └─ Agent responds that it doesn't have any info about Bob yet +``` + +Each user gets their own memory bank, so Alice's preferences never leak into Bob's conversations. + +## Prerequisites + +1. **Hindsight running** + + ```bash + export OPENAI_API_KEY=your-key + + docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \ + -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \ + -e HINDSIGHT_API_LLM_MODEL=o3-mini \ + -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \ + ghcr.io/vectorize-io/hindsight:latest + ``` + +2. **OpenAI API key** (for Agno's LLM) + + ```bash + export OPENAI_API_KEY=your-key + ``` + +3. **Install dependencies** + + ```bash + pip install hindsight-agno agno openai + ``` + +## Quick Start + +### Minimal Example + +```python +from agno.agent import Agent +from agno.models.openai import OpenAIChat +from hindsight_agno import HindsightTools + +agent = Agent( + model=OpenAIChat(id="gpt-4o-mini"), + tools=[HindsightTools( + bank_id="my-assistant", + hindsight_api_url="http://localhost:8888", + )], + markdown=True, +) + +# Store something +agent.print_response("Remember that I prefer dark mode and use vim") + +# Recall it +agent.print_response("What are my preferences?") +``` + +Run it twice — the agent still remembers on the second run. + +### Travel Planner with Per-User Memory + +A more realistic example: a travel planning agent that learns each user's preferences. + +```python +from agno.agent import Agent +from agno.models.openai import OpenAIChat +from hindsight_agno import HindsightTools, memory_instructions + +HINDSIGHT_URL = "http://localhost:8888" +USER_ID = "alice" + +# Pre-recall relevant memories for the system prompt +memories = memory_instructions( + bank_id=USER_ID, + hindsight_api_url=HINDSIGHT_URL, + query="travel preferences, dietary restrictions, and past trips", + max_results=10, +) + +agent = Agent( + model=OpenAIChat(id="gpt-4o-mini"), + tools=[HindsightTools( + bank_id=USER_ID, + hindsight_api_url=HINDSIGHT_URL, + )], + instructions=[ + "You are a travel planning assistant with long-term memory.", + "Remember user preferences (diet, seating, budget, interests) for future trips.", + "When planning trips, check memory first for relevant preferences.", + memories, + ], + markdown=True, +) + +# First run: share preferences +agent.print_response( + "I'm vegetarian, I prefer window seats, and my budget is mid-range. " + "I love museums and street food." +) + +# Second run: the agent uses stored preferences +agent.print_response("Plan a 3-day trip to Tokyo for me") +``` + +### Dynamic Per-User Banks + +When building a multi-user application, use `user_id` on the Agent to automatically isolate memory per user: + +```python +from agno.agent import Agent +from agno.models.openai import OpenAIChat +from hindsight_agno import HindsightTools + +def create_agent(user_id: str) -> Agent: + """Create an agent with per-user memory.""" + return Agent( + model=OpenAIChat(id="gpt-4o-mini"), + tools=[HindsightTools( + hindsight_api_url="http://localhost:8888", + # No bank_id — HindsightTools reads it from RunContext.user_id + )], + user_id=user_id, + markdown=True, + ) + +# Each user gets isolated memory +alice_agent = create_agent("alice") +bob_agent = create_agent("bob") + +alice_agent.print_response("I'm allergic to peanuts") +bob_agent.print_response("What am I allergic to?") +# Bob gets "No relevant memories found" — Alice's data is isolated +``` + +### Custom Bank Resolution + +For more control over bank naming, use a `bank_resolver`: + +```python +from agno.run.base import RunContext +from hindsight_agno import HindsightTools + +def resolve_bank(ctx: RunContext) -> str: + """Route to team-specific banks.""" + return f"team-{ctx.user_id}" + +tools = [HindsightTools( + bank_resolver=resolve_bank, + hindsight_api_url="http://localhost:8888", +)] +``` + +### Reflect — Disposition-Aware Reasoning + +The `reflect_on_memory` tool goes beyond simple retrieval. It synthesizes a reasoned answer using the bank's disposition traits (skepticism, literalism, empathy): + +```python +agent.print_response( + "Based on everything you know about me, what kind of vacation " + "would I enjoy most and why?" +) +# The agent calls reflect_on_memory, which synthesizes an answer +# from all stored facts using the bank's configured personality +``` + +## How It Works + +### 1. Create the Toolkit + +`HindsightTools` extends Agno's `Toolkit` base class — the same pattern used by `Mem0Tools`: + +```python +from hindsight_agno import HindsightTools + +toolkit = HindsightTools( + bank_id="my-bank", + hindsight_api_url="http://localhost:8888", + budget="mid", # Recall/reflect thoroughness: low/mid/high + tags=["source:chat"], # Tags applied to stored memories +) +# Registers: retain_memory, recall_memory, reflect_on_memory +``` + +### 2. Pre-Recall with memory_instructions() + +For injecting context into the system prompt at agent construction time: + +```python +from hindsight_agno import memory_instructions + +context = memory_instructions( + bank_id="my-bank", + hindsight_api_url="http://localhost:8888", + query="user preferences and context", + budget="low", # Keep it fast + max_results=5, # Limit injected memories +) +# Returns a string like: +# "Relevant memories:\n\n1. User is vegetarian\n2. Prefers window seats" +``` + +### 3. Select Specific Tools + +Include only the tools you need: + +```python +toolkit = HindsightTools( + bank_id="my-bank", + hindsight_api_url="http://localhost:8888", + enable_retain=True, + enable_recall=True, + enable_reflect=False, # Omit reflect +) +``` + +## Configuration + +### Environment Variables + +| Variable | Description | +|----------|-------------| +| `HINDSIGHT_API_KEY` | API key for Hindsight Cloud or authenticated self-hosted | +| `OPENAI_API_KEY` | OpenAI API key for Agno's LLM | + +### Global Configuration + +Instead of passing connection details to every toolkit: + +```python +from hindsight_agno import configure, HindsightTools + +configure( + hindsight_api_url="http://localhost:8888", + api_key="your-api-key", + budget="mid", + tags=["env:prod"], +) + +# Now create toolkits without repeating connection details +toolkit = HindsightTools(bank_id="my-bank") +``` + +### HindsightTools Parameters + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `bank_id` | `None` | Static memory bank ID | +| `bank_resolver` | `None` | `(RunContext) -> str` for dynamic bank IDs | +| `client` | `None` | Pre-configured Hindsight client | +| `hindsight_api_url` | `None` | Hindsight API URL | +| `api_key` | `None` | API key | +| `budget` | `"mid"` | Recall/reflect budget (low/mid/high) | +| `max_tokens` | `4096` | Max tokens for recall results | +| `tags` | `None` | Tags for stored memories | +| `recall_tags` | `None` | Tags to filter recall | +| `recall_tags_match` | `"any"` | Tag match mode (any/all/any_strict/all_strict) | +| `enable_retain` | `True` | Include retain tool | +| `enable_recall` | `True` | Include recall tool | +| `enable_reflect` | `True` | Include reflect tool | + +## Common Issues + +**"Connection refused"** +- Make sure Hindsight is running on `localhost:8888` + +**"OPENAI_API_KEY not set"** +```bash +export OPENAI_API_KEY=your-key +``` + +**"No Hindsight API URL configured"** +- Pass `hindsight_api_url=` to `HindsightTools`, or call `configure()` first + +**"No bank_id available"** +- Provide `bank_id=`, `bank_resolver=`, or set `user_id=` on the Agent + +--- + +**Built with:** +- [Agno](https://github.com/agno-agi/agno) - Full-stack agent framework +- [hindsight-agno](https://github.com/vectorize-io/hindsight/tree/main/hindsight-integrations/agno) - Hindsight memory toolkit for Agno +- [Hindsight](https://github.com/vectorize-io/hindsight) - Long-term memory for AI agents diff --git a/hindsight-docs/src/pages/cookbook/index.mdx b/hindsight-docs/src/pages/cookbook/index.mdx index 22241ce56..9759b6600 100644 --- a/hindsight-docs/src/pages/cookbook/index.mdx +++ b/hindsight-docs/src/pages/cookbook/index.mdx @@ -101,6 +101,12 @@ import CookbookGrid from '@site/src/components/CookbookGrid'; str` +2. **`bank_id`** — Static bank ID passed to constructor +3. **`run_context.user_id`** — Automatic per-user banks + +```python +# Per-user banks from RunContext +agent = Agent( + model=OpenAIChat(id="gpt-4o-mini"), + tools=[HindsightTools(hindsight_api_url="http://localhost:8888")], + user_id="user-123", # Used as bank_id +) + +# Custom resolver +def resolve_bank(ctx): + return f"team-{ctx.user_id}" + +agent = Agent( + model=OpenAIChat(id="gpt-4o-mini"), + tools=[HindsightTools( + bank_resolver=resolve_bank, + hindsight_api_url="http://localhost:8888", + )], +) +``` + +## Global Configuration + +Instead of passing connection details to every toolkit, configure once: + +```python +from hindsight_agno import configure, HindsightTools + +configure( + hindsight_api_url="http://localhost:8888", + api_key="your-api-key", # Or set HINDSIGHT_API_KEY env var + budget="mid", # Recall budget: low/mid/high + max_tokens=4096, # Max tokens for recall results + tags=["env:prod"], # Tags for stored memories + recall_tags=["scope:global"], # Tags to filter recall + recall_tags_match="any", # Tag match mode: any/all/any_strict/all_strict +) + +# Now create toolkit without passing connection details +tools = [HindsightTools(bank_id="user-123")] +``` + +## Configuration Reference + +### `HindsightTools()` + +| Parameter | Default | Description | +|---|---|---| +| `bank_id` | `None` | Static Hindsight memory bank ID | +| `bank_resolver` | `None` | Callable `(RunContext) -> str` for dynamic bank ID | +| `client` | `None` | Pre-configured Hindsight client | +| `hindsight_api_url` | `None` | API URL (used if no client provided) | +| `api_key` | `None` | API key (used if no client provided) | +| `budget` | `"mid"` | Recall/reflect budget level (low/mid/high) | +| `max_tokens` | `4096` | Maximum tokens for recall results | +| `tags` | `None` | Tags applied when storing memories | +| `recall_tags` | `None` | Tags to filter when searching | +| `recall_tags_match` | `"any"` | Tag matching mode | +| `enable_retain` | `True` | Include the retain (store) tool | +| `enable_recall` | `True` | Include the recall (search) tool | +| `enable_reflect` | `True` | Include the reflect (synthesize) tool | + +### `memory_instructions()` + +| Parameter | Default | Description | +|---|---|---| +| `bank_id` | *required* | Hindsight memory bank ID | +| `client` | `None` | Pre-configured Hindsight client | +| `hindsight_api_url` | `None` | API URL (used if no client provided) | +| `api_key` | `None` | API key (used if no client provided) | +| `query` | `"relevant context about the user"` | Recall query for memory injection | +| `budget` | `"low"` | Recall budget level | +| `max_results` | `5` | Maximum memories to inject | +| `max_tokens` | `4096` | Maximum tokens for recall results | +| `prefix` | `"Relevant memories:\n"` | Text prepended before memory list | +| `tags` | `None` | Tags to filter recall results | +| `tags_match` | `"any"` | Tag matching mode | + +### `configure()` + +| Parameter | Default | Description | +|---|---|---| +| `hindsight_api_url` | Production API | Hindsight API URL | +| `api_key` | `HINDSIGHT_API_KEY` env | API key for authentication | +| `budget` | `"mid"` | Default recall budget level | +| `max_tokens` | `4096` | Default max tokens for recall | +| `tags` | `None` | Default tags for retain operations | +| `recall_tags` | `None` | Default tags to filter recall | +| `recall_tags_match` | `"any"` | Default tag matching mode | +| `verbose` | `False` | Enable verbose logging | + +## Requirements + +- Python >= 3.10 +- agno +- hindsight-client >= 0.4.0 +- A running Hindsight API server + +## License + +MIT diff --git a/hindsight-integrations/agno/hindsight_agno/__init__.py b/hindsight-integrations/agno/hindsight_agno/__init__.py new file mode 100644 index 000000000..bcab7145d --- /dev/null +++ b/hindsight-integrations/agno/hindsight_agno/__init__.py @@ -0,0 +1,46 @@ +"""Hindsight-Agno: Persistent memory tools for AI agents. + +Provides a Hindsight-backed Toolkit for Agno agents, +giving them long-term memory via retain, recall, and reflect tools. + +Basic usage:: + + from agno.agent import Agent + from agno.models.openai import OpenAIChat + from hindsight_agno import HindsightTools, memory_instructions + + agent = Agent( + model=OpenAIChat(id="gpt-4o-mini"), + tools=[HindsightTools( + bank_id="user-123", + hindsight_api_url="http://localhost:8888", + )], + instructions=[memory_instructions( + bank_id="user-123", + hindsight_api_url="http://localhost:8888", + )], + ) + + agent.print_response("What do you remember about my preferences?") +""" + +from .config import ( + HindsightAgnoConfig, + configure, + get_config, + reset_config, +) +from .errors import HindsightError +from .tools import HindsightTools, memory_instructions + +__version__ = "0.1.0" + +__all__ = [ + "configure", + "get_config", + "reset_config", + "HindsightAgnoConfig", + "HindsightError", + "HindsightTools", + "memory_instructions", +] diff --git a/hindsight-integrations/agno/hindsight_agno/config.py b/hindsight-integrations/agno/hindsight_agno/config.py new file mode 100644 index 000000000..28b213b34 --- /dev/null +++ b/hindsight-integrations/agno/hindsight_agno/config.py @@ -0,0 +1,92 @@ +"""Global configuration for Hindsight-Agno integration.""" + +from __future__ import annotations + +import os +from dataclasses import dataclass + +DEFAULT_HINDSIGHT_API_URL = "https://api.hindsight.vectorize.io" +HINDSIGHT_API_KEY_ENV = "HINDSIGHT_API_KEY" + + +@dataclass +class HindsightAgnoConfig: + """Connection and default settings for the Agno integration. + + Attributes: + hindsight_api_url: URL of the Hindsight API server. + api_key: API key for Hindsight authentication. + budget: Default recall budget level (low/mid/high). + max_tokens: Default maximum tokens for recall results. + tags: Default tags applied when storing memories. + recall_tags: Default tags to filter when searching memories. + recall_tags_match: Tag matching mode (any/all/any_strict/all_strict). + verbose: Enable verbose logging. + """ + + hindsight_api_url: str = DEFAULT_HINDSIGHT_API_URL + api_key: str | None = None + budget: str = "mid" + max_tokens: int = 4096 + tags: list[str] | None = None + recall_tags: list[str] | None = None + recall_tags_match: str = "any" + verbose: bool = False + + +_global_config: HindsightAgnoConfig | None = None + + +def configure( + hindsight_api_url: str | None = None, + api_key: str | None = None, + budget: str = "mid", + max_tokens: int = 4096, + tags: list[str] | None = None, + recall_tags: list[str] | None = None, + recall_tags_match: str = "any", + verbose: bool = False, +) -> HindsightAgnoConfig: + """Configure Hindsight connection and default settings. + + Args: + hindsight_api_url: Hindsight API URL (default: production). + api_key: API key. Falls back to HINDSIGHT_API_KEY env var. + budget: Default recall budget (low/mid/high). + max_tokens: Default max tokens for recall. + tags: Default tags for retain operations. + recall_tags: Default tags to filter recall/search. + recall_tags_match: Tag matching mode. + verbose: Enable verbose logging. + + Returns: + The configured HindsightAgnoConfig. + """ + global _global_config + + resolved_url = hindsight_api_url or DEFAULT_HINDSIGHT_API_URL + resolved_key = api_key or os.environ.get(HINDSIGHT_API_KEY_ENV) + + _global_config = HindsightAgnoConfig( + hindsight_api_url=resolved_url, + api_key=resolved_key, + budget=budget, + max_tokens=max_tokens, + tags=tags, + recall_tags=recall_tags, + recall_tags_match=recall_tags_match, + verbose=verbose, + ) + + return _global_config + + +def get_config() -> HindsightAgnoConfig | None: + """Get the current global configuration.""" + return _global_config + + +def reset_config() -> None: + """Reset global configuration to None.""" + global _global_config + _global_config = None diff --git a/hindsight-integrations/agno/hindsight_agno/errors.py b/hindsight-integrations/agno/hindsight_agno/errors.py new file mode 100644 index 000000000..29fd2f739 --- /dev/null +++ b/hindsight-integrations/agno/hindsight_agno/errors.py @@ -0,0 +1,7 @@ +"""Hindsight-Agno error types.""" + + +class HindsightError(Exception): + """Exception raised when a Hindsight memory operation fails.""" + + pass diff --git a/hindsight-integrations/agno/hindsight_agno/tools.py b/hindsight-integrations/agno/hindsight_agno/tools.py new file mode 100644 index 000000000..e10b75a2d --- /dev/null +++ b/hindsight-integrations/agno/hindsight_agno/tools.py @@ -0,0 +1,345 @@ +"""Agno Toolkit for Hindsight memory operations. + +Provides a ``Toolkit`` subclass that registers retain/recall/reflect +as agent-callable tools, following the same pattern as Agno's ``Mem0Tools``. +""" + +from __future__ import annotations + +import logging +from collections.abc import Callable +from typing import Any + +from agno.run.base import RunContext +from agno.tools.toolkit import Toolkit +from hindsight_client import Hindsight + +from .config import get_config +from .errors import HindsightError + +logger = logging.getLogger(__name__) + +_TOOL_INSTRUCTIONS = """\ +You have access to long-term memory via Hindsight tools. + +- Use `retain_memory` to save important facts, user preferences, decisions, \ +or any information that should be remembered across conversations. +- Use `recall_memory` to search for previously stored facts, preferences, or context. +- Use `reflect_on_memory` to synthesize a thoughtful, reasoned answer from \ +what you know, rather than raw memory facts. + +Proactively store information the user shares that may be useful later. \ +When answering questions, check memory first for relevant context.\ +""" + + +def _resolve_client( + client: Hindsight | None, + hindsight_api_url: str | None, + api_key: str | None, +) -> Hindsight: + """Resolve a Hindsight client from explicit args or global config.""" + if client is not None: + return client + + config = get_config() + url = hindsight_api_url or (config.hindsight_api_url if config else None) + key = api_key or (config.api_key if config else None) + + if url is None: + raise HindsightError( + "No Hindsight API URL configured. " + "Pass client= or hindsight_api_url=, or call configure() first." + ) + + kwargs: dict[str, Any] = {"base_url": url, "timeout": 30.0} + if key: + kwargs["api_key"] = key + return Hindsight(**kwargs) + + +class HindsightTools(Toolkit): + """Agno Toolkit providing Hindsight memory tools. + + Registers retain, recall, and reflect as agent-callable tools + following the same pattern as Agno's ``Mem0Tools``. + + Args: + bank_id: Static memory bank ID. + bank_resolver: Callable that resolves bank_id from RunContext. + client: Pre-configured Hindsight client. + hindsight_api_url: API URL (used if no client provided). + api_key: API key (used if no client provided). + budget: Recall/reflect budget level (low/mid/high). + max_tokens: Maximum tokens for recall results. + tags: Tags applied when storing memories via retain. + recall_tags: Tags to filter when searching memories. + recall_tags_match: Tag matching mode (any/all/any_strict/all_strict). + enable_retain: Include the retain (store) tool. + enable_recall: Include the recall (search) tool. + enable_reflect: Include the reflect (synthesize) tool. + **kwargs: Passed through to Toolkit (e.g. include_tools, exclude_tools). + + Example:: + + from agno.agent import Agent + from agno.models.openai import OpenAIChat + from hindsight_agno import HindsightTools + + agent = Agent( + model=OpenAIChat(id="gpt-4o-mini"), + tools=[HindsightTools( + bank_id="user-123", + hindsight_api_url="http://localhost:8888", + )], + ) + agent.print_response("Remember that I prefer dark mode") + """ + + def __init__( + self, + *, + bank_id: str | None = None, + bank_resolver: Callable[[RunContext], str] | None = None, + client: Hindsight | None = None, + hindsight_api_url: str | None = None, + api_key: str | None = None, + budget: str = "mid", + max_tokens: int = 4096, + tags: list[str] | None = None, + recall_tags: list[str] | None = None, + recall_tags_match: str = "any", + enable_retain: bool = True, + enable_recall: bool = True, + enable_reflect: bool = True, + **kwargs: Any, + ): + self._bank_id = bank_id + self._bank_resolver = bank_resolver + self._client = _resolve_client(client, hindsight_api_url, api_key) + self._created_banks: set[str] = set() + + # Resolve defaults from global config + config = get_config() + self._budget = budget or (config.budget if config else "mid") + self._max_tokens = max_tokens or (config.max_tokens if config else 4096) + self._tags = tags if tags is not None else (config.tags if config else None) + self._recall_tags = ( + recall_tags + if recall_tags is not None + else (config.recall_tags if config else None) + ) + self._recall_tags_match = recall_tags_match or ( + config.recall_tags_match if config else "any" + ) + + # Build list of tools to register based on enable flags + tools: list[Callable[..., Any]] = [] + if enable_retain: + tools.append(self.retain_memory) + if enable_recall: + tools.append(self.recall_memory) + if enable_reflect: + tools.append(self.reflect_on_memory) + + super().__init__( + name="hindsight_tools", + tools=tools, + instructions=_TOOL_INSTRUCTIONS, + **kwargs, + ) + + def _resolve_bank_id(self, run_context: RunContext) -> str: + """Resolve the effective bank_id for this operation. + + Resolution order: + 1. bank_resolver(run_context) if set + 2. Static bank_id if set + 3. run_context.user_id if available + 4. Raise HindsightError + """ + if self._bank_resolver is not None: + return self._bank_resolver(run_context) + + if self._bank_id is not None: + return self._bank_id + + user_id = getattr(run_context, "user_id", None) + if user_id: + return user_id + + raise HindsightError( + "No bank_id available. Provide bank_id=, bank_resolver=, " + "or ensure run_context.user_id is set." + ) + + def _ensure_bank(self, bank_id: str) -> None: + """Create bank if not already created in this session.""" + if bank_id in self._created_banks: + return + + try: + self._client.create_bank(bank_id=bank_id, name=bank_id) + self._created_banks.add(bank_id) + except Exception: + # Bank may already exist — that's fine + self._created_banks.add(bank_id) + + def retain_memory(self, run_context: RunContext, content: str) -> str: + """Store information to long-term memory for later retrieval. + + Use this to save important facts, user preferences, decisions, + or any information that should be remembered across conversations. + + Args: + run_context: Agno run context. + content: The information to store in memory. + + Returns: + A success message string. + """ + try: + bank_id = self._resolve_bank_id(run_context) + self._ensure_bank(bank_id) + + retain_kwargs: dict[str, Any] = {"bank_id": bank_id, "content": content} + if self._tags: + retain_kwargs["tags"] = self._tags + self._client.retain(**retain_kwargs) + return "Memory stored successfully." + except HindsightError: + raise + except Exception as e: + logger.error(f"Retain failed: {e}") + raise HindsightError(f"Retain failed: {e}") from e + + def recall_memory(self, run_context: RunContext, query: str) -> str: + """Search long-term memory for relevant information. + + Use this to find previously stored facts, preferences, or context. + Returns a numbered list of matching memories. + + Args: + run_context: Agno run context. + query: The search query to find relevant memories. + + Returns: + A numbered list of matching memories, or a message if none found. + """ + try: + bank_id = self._resolve_bank_id(run_context) + + recall_kwargs: dict[str, Any] = { + "bank_id": bank_id, + "query": query, + "budget": self._budget, + "max_tokens": self._max_tokens, + } + if self._recall_tags: + recall_kwargs["tags"] = self._recall_tags + recall_kwargs["tags_match"] = self._recall_tags_match + response = self._client.recall(**recall_kwargs) + if not response.results: + return "No relevant memories found." + lines = [] + for i, result in enumerate(response.results, 1): + lines.append(f"{i}. {result.text}") + return "\n".join(lines) + except HindsightError: + raise + except Exception as e: + logger.error(f"Recall failed: {e}") + raise HindsightError(f"Recall failed: {e}") from e + + def reflect_on_memory(self, run_context: RunContext, query: str) -> str: + """Synthesize a thoughtful answer from long-term memories. + + Use this when you need a coherent summary or reasoned response + about what you know, rather than raw memory facts. + + Args: + run_context: Agno run context. + query: The question to reflect on using stored memories. + + Returns: + A synthesized response based on stored memories. + """ + try: + bank_id = self._resolve_bank_id(run_context) + + reflect_kwargs: dict[str, Any] = { + "bank_id": bank_id, + "query": query, + "budget": self._budget, + } + response = self._client.reflect(**reflect_kwargs) + return response.text or "No relevant memories found." + except HindsightError: + raise + except Exception as e: + logger.error(f"Reflect failed: {e}") + raise HindsightError(f"Reflect failed: {e}") from e + + +def memory_instructions( + *, + bank_id: str, + client: Hindsight | None = None, + hindsight_api_url: str | None = None, + api_key: str | None = None, + query: str = "relevant context about the user", + budget: str = "low", + max_results: int = 5, + max_tokens: int = 4096, + prefix: str = "Relevant memories:\n", + tags: list[str] | None = None, + tags_match: str = "any", +) -> str: + """Pre-recall memories for injection into Agent instructions. + + Performs a sync recall at construction time and returns a formatted + string of memories. Use with ``Agent(instructions=[...])`` to inject + relevant context into every run. + + Args: + bank_id: The Hindsight memory bank to recall from. + client: Pre-configured Hindsight client (preferred). + hindsight_api_url: API URL (used if no client provided). + api_key: API key (used if no client provided). + query: The recall query to find relevant memories. + budget: Recall budget level (low/mid/high). + max_results: Maximum number of memories to include. + max_tokens: Maximum tokens for recall results. + prefix: Text prepended before the memory list. + tags: Tags to filter recall results. + tags_match: Tag matching mode (any/all/any_strict/all_strict). + + Returns: + A formatted string of memories, or empty string if none found. + + Raises: + HindsightError: If no client or API URL can be resolved. + """ + resolved_client = _resolve_client(client, hindsight_api_url, api_key) + + try: + recall_kwargs: dict[str, Any] = { + "bank_id": bank_id, + "query": query, + "budget": budget, + "max_tokens": max_tokens, + } + if tags: + recall_kwargs["tags"] = tags + recall_kwargs["tags_match"] = tags_match + response = resolved_client.recall(**recall_kwargs) + results = response.results[:max_results] if response.results else [] + if not results: + return "" + lines = [prefix] + for i, result in enumerate(results, 1): + lines.append(f"{i}. {result.text}") + return "\n".join(lines) + except Exception: + # Silently return empty — instructions failures shouldn't block the agent + return "" diff --git a/hindsight-integrations/agno/pyproject.toml b/hindsight-integrations/agno/pyproject.toml new file mode 100644 index 000000000..d10ff6322 --- /dev/null +++ b/hindsight-integrations/agno/pyproject.toml @@ -0,0 +1,52 @@ +[project] +name = "hindsight-agno" +version = "0.1.0" +description = "Agno integration for Hindsight - persistent memory tools for AI agents" +requires-python = ">=3.10" +license = { text = "MIT" } +authors = [ + { name = "Vectorize", email = "support@vectorize.io" } +] +keywords = [ + "ai", + "memory", + "agno", + "agents", + "hindsight", +] +classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering :: Artificial Intelligence", +] + +dependencies = [ + "agno", + "hindsight-client>=0.4.0", +] + +[project.urls] +Homepage = "https://github.com/vectorize-io/hindsight" +Documentation = "https://github.com/vectorize-io/hindsight/tree/main/hindsight-integrations/agno" +Repository = "https://github.com/vectorize-io/hindsight" + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[tool.hatch.build.targets.wheel] +packages = ["hindsight_agno"] + +[tool.pytest.ini_options] +testpaths = ["tests"] + +[dependency-groups] +dev = [ + "pytest>=9.0.2", + "ruff>=0.8.0", +] diff --git a/hindsight-integrations/agno/tests/__init__.py b/hindsight-integrations/agno/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/hindsight-integrations/agno/tests/test_config.py b/hindsight-integrations/agno/tests/test_config.py new file mode 100644 index 000000000..13894ceb3 --- /dev/null +++ b/hindsight-integrations/agno/tests/test_config.py @@ -0,0 +1,169 @@ +"""Unit tests for hindsight_agno configuration.""" + +import os +from unittest.mock import patch + +from hindsight_agno import configure, get_config, reset_config +from hindsight_agno.config import ( + DEFAULT_HINDSIGHT_API_URL, + HINDSIGHT_API_KEY_ENV, + HindsightAgnoConfig, +) + + +class TestDefaults: + def test_default_api_url(self): + assert DEFAULT_HINDSIGHT_API_URL == "https://api.hindsight.vectorize.io" + + def test_env_var_name(self): + assert HINDSIGHT_API_KEY_ENV == "HINDSIGHT_API_KEY" + + +class TestHindsightAgnoConfigDataclass: + def test_default_values(self): + config = HindsightAgnoConfig() + assert config.hindsight_api_url == DEFAULT_HINDSIGHT_API_URL + assert config.api_key is None + assert config.budget == "mid" + assert config.max_tokens == 4096 + assert config.tags is None + assert config.recall_tags is None + assert config.recall_tags_match == "any" + assert config.verbose is False + + def test_custom_values(self): + config = HindsightAgnoConfig( + hindsight_api_url="http://custom:9999", + api_key="key-123", + budget="high", + max_tokens=2048, + tags=["t1"], + recall_tags=["r1"], + recall_tags_match="all", + verbose=True, + ) + assert config.hindsight_api_url == "http://custom:9999" + assert config.api_key == "key-123" + assert config.budget == "high" + assert config.max_tokens == 2048 + assert config.tags == ["t1"] + assert config.recall_tags == ["r1"] + assert config.recall_tags_match == "all" + assert config.verbose is True + + def test_is_mutable_dataclass(self): + config = HindsightAgnoConfig() + config.budget = "low" + assert config.budget == "low" + + +class TestConfigure: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_configure_with_no_arguments(self): + config = configure() + assert config.hindsight_api_url == DEFAULT_HINDSIGHT_API_URL + assert config.api_key is None + assert config.budget == "mid" + assert config.max_tokens == 4096 + assert config.tags is None + assert config.recall_tags is None + assert config.recall_tags_match == "any" + assert config.verbose is False + + def test_configure_reads_api_key_from_env(self): + with patch.dict(os.environ, {HINDSIGHT_API_KEY_ENV: "test-key"}): + config = configure() + assert config.api_key == "test-key" + + def test_configure_explicit_overrides_env(self): + with patch.dict(os.environ, {HINDSIGHT_API_KEY_ENV: "env-key"}): + config = configure(api_key="explicit-key") + assert config.api_key == "explicit-key" + + def test_configure_api_key_none_without_env(self): + with patch.dict(os.environ, {}, clear=True): + config = configure() + assert config.api_key is None + + def test_configure_all_options(self): + config = configure( + hindsight_api_url="http://custom:8888", + api_key="my-key", + budget="high", + max_tokens=2048, + tags=["env:test"], + recall_tags=["scope:global"], + recall_tags_match="all", + verbose=True, + ) + assert config.hindsight_api_url == "http://custom:8888" + assert config.api_key == "my-key" + assert config.budget == "high" + assert config.max_tokens == 2048 + assert config.tags == ["env:test"] + assert config.recall_tags == ["scope:global"] + assert config.recall_tags_match == "all" + assert config.verbose is True + + def test_configure_returns_config_instance(self): + config = configure() + assert isinstance(config, HindsightAgnoConfig) + + def test_configure_replaces_previous_config(self): + configure(budget="low") + config1 = get_config() + assert config1.budget == "low" + + configure(budget="high") + config2 = get_config() + assert config2.budget == "high" + assert config1 is not config2 + + def test_configure_url_defaults_when_none(self): + config = configure(hindsight_api_url=None) + assert config.hindsight_api_url == DEFAULT_HINDSIGHT_API_URL + + +class TestGetConfig: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_returns_none_without_configure(self): + assert get_config() is None + + def test_returns_config_after_configure(self): + configure() + config = get_config() + assert config is not None + assert isinstance(config, HindsightAgnoConfig) + + def test_returns_same_instance(self): + configure() + assert get_config() is get_config() + + +class TestResetConfig: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_reset_config(self): + configure() + assert get_config() is not None + reset_config() + assert get_config() is None + + def test_reset_is_idempotent(self): + reset_config() + reset_config() + assert get_config() is None diff --git a/hindsight-integrations/agno/tests/test_tools.py b/hindsight-integrations/agno/tests/test_tools.py new file mode 100644 index 000000000..6db5613f5 --- /dev/null +++ b/hindsight-integrations/agno/tests/test_tools.py @@ -0,0 +1,1836 @@ +"""Unit tests for Hindsight Agno tools.""" + +import logging +from unittest.mock import MagicMock, patch + +import pytest + +from hindsight_agno import ( + HindsightTools, + configure, + memory_instructions, + reset_config, +) +from hindsight_agno.errors import HindsightError +from hindsight_agno.tools import _TOOL_INSTRUCTIONS, _resolve_client + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def _mock_client(): + """Create a mock Hindsight client.""" + client = MagicMock() + client.retain = MagicMock() + client.recall = MagicMock() + client.reflect = MagicMock() + client.create_bank = MagicMock() + return client + + +def _mock_run_context(user_id=None, session_id=None): + """Create a mock Agno RunContext.""" + ctx = MagicMock() + ctx.user_id = user_id + ctx.session_id = session_id + return ctx + + +def _mock_recall_response(texts: list[str]): + """Create a mock RecallResponse with results.""" + response = MagicMock() + results = [] + for t in texts: + r = MagicMock() + r.text = t + results.append(r) + response.results = results + return response + + +def _mock_reflect_response(text: str): + """Create a mock ReflectResponse.""" + response = MagicMock() + response.text = text + return response + + +# --------------------------------------------------------------------------- +# _resolve_client +# --------------------------------------------------------------------------- + + +class TestResolveClient: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_returns_explicit_client(self): + client = _mock_client() + assert _resolve_client(client, None, None) is client + + def test_explicit_client_ignores_url_and_key(self): + client = _mock_client() + result = _resolve_client(client, "http://ignored", "ignored-key") + assert result is client + + def test_creates_client_from_url(self): + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, "http://localhost:8888", None) + mock_cls.assert_called_once_with( + base_url="http://localhost:8888", timeout=30.0 + ) + + def test_creates_client_with_api_key(self): + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, "http://localhost:8888", "my-key") + mock_cls.assert_called_once_with( + base_url="http://localhost:8888", timeout=30.0, api_key="my-key" + ) + + def test_falls_back_to_global_config_url(self): + configure(hindsight_api_url="http://config:8888") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, None, None) + mock_cls.assert_called_once_with( + base_url="http://config:8888", timeout=30.0 + ) + + def test_falls_back_to_global_config_api_key(self): + configure(hindsight_api_url="http://config:8888", api_key="config-key") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, None, None) + mock_cls.assert_called_once_with( + base_url="http://config:8888", timeout=30.0, api_key="config-key" + ) + + def test_explicit_url_overrides_config(self): + configure(hindsight_api_url="http://config:8888") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, "http://explicit:9999", None) + mock_cls.assert_called_once_with( + base_url="http://explicit:9999", timeout=30.0 + ) + + def test_explicit_api_key_overrides_config(self): + configure(hindsight_api_url="http://config:8888", api_key="config-key") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, None, "explicit-key") + mock_cls.assert_called_once_with( + base_url="http://config:8888", timeout=30.0, api_key="explicit-key" + ) + + def test_raises_without_url_or_config(self): + with pytest.raises(HindsightError, match="No Hindsight API URL"): + _resolve_client(None, None, None) + + def test_raises_with_empty_config_no_url(self): + # Config exists but has no url override and default is set, + # so this should NOT raise since default URL exists in config + configure() + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, None, None) + mock_cls.assert_called_once() + + +# --------------------------------------------------------------------------- +# HindsightTools initialization +# --------------------------------------------------------------------------- + + +class TestHindsightToolsInit: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_creates_three_tools_by_default(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert "retain_memory" in toolkit.functions + assert "recall_memory" in toolkit.functions + assert "reflect_on_memory" in toolkit.functions + assert len(toolkit.functions) == 3 + + def test_enable_retain_only(self): + client = _mock_client() + toolkit = HindsightTools( + bank_id="test", + client=client, + enable_retain=True, + enable_recall=False, + enable_reflect=False, + ) + assert "retain_memory" in toolkit.functions + assert "recall_memory" not in toolkit.functions + assert "reflect_on_memory" not in toolkit.functions + + def test_enable_recall_only(self): + client = _mock_client() + toolkit = HindsightTools( + bank_id="test", + client=client, + enable_retain=False, + enable_recall=True, + enable_reflect=False, + ) + assert "retain_memory" not in toolkit.functions + assert "recall_memory" in toolkit.functions + assert "reflect_on_memory" not in toolkit.functions + + def test_enable_reflect_only(self): + client = _mock_client() + toolkit = HindsightTools( + bank_id="test", + client=client, + enable_retain=False, + enable_recall=False, + enable_reflect=True, + ) + assert "retain_memory" not in toolkit.functions + assert "recall_memory" not in toolkit.functions + assert "reflect_on_memory" in toolkit.functions + + def test_enable_two_tools(self): + client = _mock_client() + toolkit = HindsightTools( + bank_id="test", + client=client, + enable_retain=True, + enable_recall=True, + enable_reflect=False, + ) + assert len(toolkit.functions) == 2 + assert "retain_memory" in toolkit.functions + assert "recall_memory" in toolkit.functions + + def test_no_tools_when_all_disabled(self): + client = _mock_client() + toolkit = HindsightTools( + bank_id="test", + client=client, + enable_retain=False, + enable_recall=False, + enable_reflect=False, + ) + assert len(toolkit.functions) == 0 + + def test_raises_without_client_or_config(self): + with pytest.raises(HindsightError, match="No Hindsight API URL"): + HindsightTools(bank_id="test") + + def test_falls_back_to_global_config(self): + configure(hindsight_api_url="http://localhost:8888") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + toolkit = HindsightTools(bank_id="test") + assert "retain_memory" in toolkit.functions + mock_cls.assert_called_once_with( + base_url="http://localhost:8888", timeout=30.0 + ) + + def test_explicit_url_overrides_config(self): + configure(hindsight_api_url="http://config:8888") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + HindsightTools(bank_id="test", hindsight_api_url="http://explicit:9999") + mock_cls.assert_called_once_with( + base_url="http://explicit:9999", timeout=30.0 + ) + + def test_toolkit_name(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert toolkit.name == "hindsight_tools" + + def test_toolkit_has_instructions(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert toolkit.instructions == _TOOL_INSTRUCTIONS + assert "retain_memory" in toolkit.instructions + assert "recall_memory" in toolkit.instructions + assert "reflect_on_memory" in toolkit.instructions + + def test_constructor_defaults_override_config_for_budget(self): + """Constructor default budget='mid' is truthy, so config budget is not used. + This matches pydantic-ai integration behavior — pass budget explicitly to override.""" + configure(hindsight_api_url="http://localhost:8888", budget="low") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + toolkit = HindsightTools(bank_id="test") + client = mock_cls.return_value + client.recall.return_value = _mock_recall_response(["fact"]) + ctx = _mock_run_context() + toolkit.recall_memory(ctx, "q") + # Constructor default "mid" wins over config "low" due to `or` logic + assert client.recall.call_args[1]["budget"] == "mid" + + def test_explicit_budget_overrides_default(self): + configure(hindsight_api_url="http://localhost:8888") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + toolkit = HindsightTools(bank_id="test", budget="low") + client = mock_cls.return_value + client.recall.return_value = _mock_recall_response(["fact"]) + ctx = _mock_run_context() + toolkit.recall_memory(ctx, "q") + assert client.recall.call_args[1]["budget"] == "low" + + def test_config_defaults_for_tags(self): + """Tags use 'is not None' check, so config tags ARE picked up when not explicitly set.""" + configure( + hindsight_api_url="http://localhost:8888", + tags=["config-tag"], + recall_tags=["config-recall"], + ) + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + toolkit = HindsightTools(bank_id="test") + client = mock_cls.return_value + client.retain.return_value = None + client.recall.return_value = _mock_recall_response(["fact"]) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + assert client.retain.call_args[1]["tags"] == ["config-tag"] + + toolkit.recall_memory(ctx, "q") + assert client.recall.call_args[1]["tags"] == ["config-recall"] + + def test_explicit_tags_override_config(self): + configure( + hindsight_api_url="http://localhost:8888", + tags=["config-tag"], + recall_tags=["config-recall"], + ) + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + toolkit = HindsightTools( + bank_id="test", + tags=["explicit-tag"], + recall_tags=["explicit-recall"], + ) + client = mock_cls.return_value + client.retain.return_value = None + client.recall.return_value = _mock_recall_response(["fact"]) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + assert client.retain.call_args[1]["tags"] == ["explicit-tag"] + + toolkit.recall_memory(ctx, "q") + assert client.recall.call_args[1]["tags"] == ["explicit-recall"] + + def test_api_key_passed_to_client(self): + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + HindsightTools( + bank_id="test", + hindsight_api_url="http://localhost:8888", + api_key="secret", + ) + mock_cls.assert_called_once_with( + base_url="http://localhost:8888", + timeout=30.0, + api_key="secret", + ) + + +# --------------------------------------------------------------------------- +# Bank ID resolution +# --------------------------------------------------------------------------- + + +class TestBankIdResolution: + def test_static_bank_id(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="my-bank", client=client) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + assert client.recall.call_args[1]["bank_id"] == "my-bank" + + def test_bank_id_from_run_context_user_id(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(client=client) + ctx = _mock_run_context(user_id="user-456") + + toolkit.recall_memory(ctx, "query") + + assert client.recall.call_args[1]["bank_id"] == "user-456" + + def test_custom_bank_resolver(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + resolver = MagicMock(return_value="resolved-bank") + toolkit = HindsightTools(bank_resolver=resolver, client=client) + ctx = _mock_run_context(user_id="user-789") + + toolkit.recall_memory(ctx, "query") + + resolver.assert_called_once_with(ctx) + assert client.recall.call_args[1]["bank_id"] == "resolved-bank" + + def test_bank_resolver_takes_priority_over_bank_id(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + resolver = MagicMock(return_value="resolver-wins") + toolkit = HindsightTools( + bank_id="static-bank", + bank_resolver=resolver, + client=client, + ) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + assert client.recall.call_args[1]["bank_id"] == "resolver-wins" + + def test_static_bank_id_takes_priority_over_user_id(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="static-bank", client=client) + ctx = _mock_run_context(user_id="user-id-ignored") + + toolkit.recall_memory(ctx, "query") + + assert client.recall.call_args[1]["bank_id"] == "static-bank" + + def test_missing_bank_id_raises_error(self): + client = _mock_client() + toolkit = HindsightTools(client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="No bank_id available"): + toolkit.recall_memory(ctx, "query") + + def test_missing_bank_id_no_user_id_attr(self): + client = _mock_client() + toolkit = HindsightTools(client=client) + ctx = MagicMock(spec=[]) # No attributes at all + + with pytest.raises(HindsightError, match="No bank_id available"): + toolkit.recall_memory(ctx, "query") + + def test_bank_resolver_error_propagates(self): + client = _mock_client() + + def bad_resolver(ctx): + raise ValueError("resolver broke") + + toolkit = HindsightTools(bank_resolver=bad_resolver, client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="resolver broke"): + toolkit.retain_memory(ctx, "content") + + def test_bank_id_consistent_across_tools(self): + """All tools resolve the same bank_id from the same context.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(client=client) + ctx = _mock_run_context(user_id="shared-user") + + toolkit.retain_memory(ctx, "content") + toolkit.recall_memory(ctx, "query") + toolkit.reflect_on_memory(ctx, "question") + + assert client.retain.call_args[1]["bank_id"] == "shared-user" + assert client.recall.call_args[1]["bank_id"] == "shared-user" + assert client.reflect.call_args[1]["bank_id"] == "shared-user" + + +# --------------------------------------------------------------------------- +# Bank auto-creation (_ensure_bank) +# --------------------------------------------------------------------------- + + +class TestEnsureBank: + def test_creates_bank_on_first_tool_use(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="new-bank", client=client) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + + client.create_bank.assert_called_once_with(bank_id="new-bank", name="new-bank") + + def test_does_not_recreate_bank(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "first") + toolkit.retain_memory(ctx, "second") + + assert client.create_bank.call_count == 1 + + def test_bank_creation_failure_is_swallowed(self): + client = _mock_client() + client.create_bank.side_effect = RuntimeError("bank exists") + toolkit = HindsightTools(bank_id="existing-bank", client=client) + ctx = _mock_run_context() + + # Should not raise — bank creation failure is tolerated + result = toolkit.retain_memory(ctx, "content") + assert result == "Memory stored successfully." + + def test_bank_creation_failure_marks_as_created(self): + """After a bank creation failure, it shouldn't retry.""" + client = _mock_client() + client.create_bank.side_effect = RuntimeError("conflict") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "first") + toolkit.retain_memory(ctx, "second") + + assert client.create_bank.call_count == 1 + + def test_different_bank_ids_created_separately(self): + """When bank_resolver returns different IDs, each is created once.""" + client = _mock_client() + + def resolver(ctx): + return f"bank-{ctx.user_id}" + + toolkit = HindsightTools(bank_resolver=resolver, client=client) + + toolkit.retain_memory(_mock_run_context(user_id="alice"), "content") + toolkit.retain_memory(_mock_run_context(user_id="bob"), "content") + toolkit.retain_memory(_mock_run_context(user_id="alice"), "more") + + assert client.create_bank.call_count == 2 + bank_ids = [c[1]["bank_id"] for c in client.create_bank.call_args_list] + assert "bank-alice" in bank_ids + assert "bank-bob" in bank_ids + + def test_recall_does_not_create_bank(self): + """Recall doesn't call _ensure_bank (only retain does).""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + client.create_bank.assert_not_called() + + def test_reflect_does_not_create_bank(self): + """Reflect doesn't call _ensure_bank (only retain does).""" + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.reflect_on_memory(ctx, "query") + + client.create_bank.assert_not_called() + + +# --------------------------------------------------------------------------- +# Retain tool +# --------------------------------------------------------------------------- + + +class TestRetainTool: + def test_retain_stores_memory(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test-bank", client=client) + ctx = _mock_run_context() + + result = toolkit.retain_memory(ctx, "The user likes Python") + + assert result == "Memory stored successfully." + client.retain.assert_called_once_with( + bank_id="test-bank", content="The user likes Python" + ) + + def test_retain_passes_tags(self): + client = _mock_client() + toolkit = HindsightTools( + bank_id="test-bank", client=client, tags=["source:chat"] + ) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "some content") + + call_kwargs = client.retain.call_args[1] + assert call_kwargs["tags"] == ["source:chat"] + + def test_retain_no_tags_key_when_none(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + + call_kwargs = client.retain.call_args[1] + assert "tags" not in call_kwargs + + def test_retain_with_empty_content(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.retain_memory(ctx, "") + + assert result == "Memory stored successfully." + client.retain.assert_called_once_with(bank_id="test", content="") + + def test_retain_raises_hindsight_error(self): + client = _mock_client() + client.retain.side_effect = RuntimeError("connection refused") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="Retain failed"): + toolkit.retain_memory(ctx, "content") + + def test_retain_preserves_hindsight_error(self): + """HindsightError from bank resolution is not double-wrapped.""" + client = _mock_client() + toolkit = HindsightTools(client=client) + ctx = _mock_run_context() # No user_id, no bank_id + + with pytest.raises(HindsightError, match="No bank_id available"): + toolkit.retain_memory(ctx, "content") + + def test_retain_error_chains_original_exception(self): + client = _mock_client() + original = RuntimeError("original error") + client.retain.side_effect = original + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError) as exc_info: + toolkit.retain_memory(ctx, "content") + + assert exc_info.value.__cause__ is original + + def test_retain_with_bank_resolver(self): + client = _mock_client() + resolver = MagicMock(return_value="resolved") + toolkit = HindsightTools(bank_resolver=resolver, client=client) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + + assert client.retain.call_args[1]["bank_id"] == "resolved" + + +# --------------------------------------------------------------------------- +# Recall tool +# --------------------------------------------------------------------------- + + +class TestRecallTool: + def test_recall_returns_numbered_results(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response( + ["User likes Python", "User is in NYC"] + ) + toolkit = HindsightTools(bank_id="test-bank", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "user preferences") + + assert "1. User likes Python" in result + assert "2. User is in NYC" in result + + def test_recall_single_result(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["only fact"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "query") + + assert result == "1. only fact" + + def test_recall_many_results(self): + client = _mock_client() + facts = [f"fact {i}" for i in range(1, 11)] + client.recall.return_value = _mock_recall_response(facts) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "query") + + for i in range(1, 11): + assert f"{i}. fact {i}" in result + + def test_recall_empty_results(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response([]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "anything") + + assert result == "No relevant memories found." + + def test_recall_none_results(self): + client = _mock_client() + response = MagicMock() + response.results = None + client.recall.return_value = response + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "anything") + + assert result == "No relevant memories found." + + def test_recall_passes_budget_and_max_tokens(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools( + bank_id="test", client=client, budget="high", max_tokens=2048 + ) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + call_kwargs = client.recall.call_args[1] + assert call_kwargs["budget"] == "high" + assert call_kwargs["max_tokens"] == 2048 + + def test_recall_default_budget_and_max_tokens(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + call_kwargs = client.recall.call_args[1] + assert call_kwargs["budget"] == "mid" + assert call_kwargs["max_tokens"] == 4096 + + def test_recall_passes_tags(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools( + bank_id="test", + client=client, + recall_tags=["scope:user"], + recall_tags_match="all", + ) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + call_kwargs = client.recall.call_args[1] + assert call_kwargs["tags"] == ["scope:user"] + assert call_kwargs["tags_match"] == "all" + + def test_recall_no_tags_key_when_none(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + call_kwargs = client.recall.call_args[1] + assert "tags" not in call_kwargs + assert "tags_match" not in call_kwargs + + def test_recall_raises_hindsight_error(self): + client = _mock_client() + client.recall.side_effect = RuntimeError("timeout") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="Recall failed"): + toolkit.recall_memory(ctx, "query") + + def test_recall_preserves_hindsight_error(self): + client = _mock_client() + toolkit = HindsightTools(client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="No bank_id available"): + toolkit.recall_memory(ctx, "query") + + def test_recall_error_chains_original_exception(self): + client = _mock_client() + original = ConnectionError("network down") + client.recall.side_effect = original + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError) as exc_info: + toolkit.recall_memory(ctx, "query") + + assert exc_info.value.__cause__ is original + + def test_recall_passes_query(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "specific query text") + + assert client.recall.call_args[1]["query"] == "specific query text" + + +# --------------------------------------------------------------------------- +# Reflect tool +# --------------------------------------------------------------------------- + + +class TestReflectTool: + def test_reflect_returns_text(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response( + "The user is a Python developer who prefers functional patterns." + ) + toolkit = HindsightTools(bank_id="test-bank", client=client) + ctx = _mock_run_context() + + result = toolkit.reflect_on_memory(ctx, "What do you know about the user?") + + assert ( + result == "The user is a Python developer who prefers functional patterns." + ) + + def test_reflect_empty_returns_fallback(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.reflect_on_memory(ctx, "anything") + + assert result == "No relevant memories found." + + def test_reflect_none_text_returns_fallback(self): + client = _mock_client() + response = MagicMock() + response.text = None + client.reflect.return_value = response + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.reflect_on_memory(ctx, "anything") + + assert result == "No relevant memories found." + + def test_reflect_passes_budget(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(bank_id="test", client=client, budget="high") + ctx = _mock_run_context() + + toolkit.reflect_on_memory(ctx, "query") + + call_kwargs = client.reflect.call_args[1] + assert call_kwargs["budget"] == "high" + + def test_reflect_default_budget(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.reflect_on_memory(ctx, "query") + + assert client.reflect.call_args[1]["budget"] == "mid" + + def test_reflect_passes_query(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.reflect_on_memory(ctx, "What is the user's favorite color?") + + assert ( + client.reflect.call_args[1]["query"] == "What is the user's favorite color?" + ) + + def test_reflect_passes_bank_id(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(bank_id="my-bank", client=client) + ctx = _mock_run_context() + + toolkit.reflect_on_memory(ctx, "query") + + assert client.reflect.call_args[1]["bank_id"] == "my-bank" + + def test_reflect_raises_hindsight_error(self): + client = _mock_client() + client.reflect.side_effect = RuntimeError("timeout") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="Reflect failed"): + toolkit.reflect_on_memory(ctx, "query") + + def test_reflect_preserves_hindsight_error(self): + client = _mock_client() + toolkit = HindsightTools(client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="No bank_id available"): + toolkit.reflect_on_memory(ctx, "query") + + def test_reflect_error_chains_original_exception(self): + client = _mock_client() + original = TimeoutError("timed out") + client.reflect.side_effect = original + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError) as exc_info: + toolkit.reflect_on_memory(ctx, "query") + + assert exc_info.value.__cause__ is original + + +# --------------------------------------------------------------------------- +# memory_instructions +# --------------------------------------------------------------------------- + + +class TestMemoryInstructions: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_returns_formatted_memories(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response( + ["Likes Python", "Lives in NYC", "Prefers dark mode"] + ) + + result = memory_instructions(bank_id="test-bank", client=client) + + assert "Relevant memories:" in result + assert "1. Likes Python" in result + assert "2. Lives in NYC" in result + assert "3. Prefers dark mode" in result + + def test_returns_string_type(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + result = memory_instructions(bank_id="test", client=client) + + assert isinstance(result, str) + + def test_respects_max_results(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response( + ["fact1", "fact2", "fact3", "fact4", "fact5"] + ) + + result = memory_instructions(bank_id="test", client=client, max_results=2) + + assert "1. fact1" in result + assert "2. fact2" in result + assert "3." not in result + + def test_max_results_larger_than_available(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact1", "fact2"]) + + result = memory_instructions(bank_id="test", client=client, max_results=10) + + assert "1. fact1" in result + assert "2. fact2" in result + + def test_custom_prefix(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + result = memory_instructions( + bank_id="test", client=client, prefix="Memory context:\n" + ) + + assert result.startswith("Memory context:") + + def test_empty_results_returns_empty_string(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response([]) + + result = memory_instructions(bank_id="test", client=client) + + assert result == "" + + def test_none_results_returns_empty_string(self): + client = _mock_client() + response = MagicMock() + response.results = None + client.recall.return_value = response + + result = memory_instructions(bank_id="test", client=client) + + assert result == "" + + def test_error_returns_empty_string(self): + client = _mock_client() + client.recall.side_effect = RuntimeError("connection error") + + result = memory_instructions(bank_id="test", client=client) + + assert result == "" + + def test_error_does_not_raise(self): + """Errors should be silently swallowed, never propagated.""" + client = _mock_client() + client.recall.side_effect = ConnectionError("unreachable") + + # Should not raise + result = memory_instructions(bank_id="test", client=client) + assert result == "" + + def test_passes_query_and_budget(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions( + bank_id="test", + client=client, + query="user preferences and context", + budget="high", + ) + + call_kwargs = client.recall.call_args[1] + assert call_kwargs["query"] == "user preferences and context" + assert call_kwargs["budget"] == "high" + + def test_passes_max_tokens(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions(bank_id="test", client=client, max_tokens=2048) + + call_kwargs = client.recall.call_args[1] + assert call_kwargs["max_tokens"] == 2048 + + def test_default_parameters(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions(bank_id="test", client=client) + + call_kwargs = client.recall.call_args[1] + assert call_kwargs["query"] == "relevant context about the user" + assert call_kwargs["budget"] == "low" + assert call_kwargs["max_tokens"] == 4096 + + def test_passes_tags(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions( + bank_id="test", + client=client, + tags=["scope:user"], + tags_match="all", + ) + + call_kwargs = client.recall.call_args[1] + assert call_kwargs["tags"] == ["scope:user"] + assert call_kwargs["tags_match"] == "all" + + def test_no_tags_key_when_none(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions(bank_id="test", client=client) + + call_kwargs = client.recall.call_args[1] + assert "tags" not in call_kwargs + assert "tags_match" not in call_kwargs + + def test_raises_without_client_or_config(self): + with pytest.raises(HindsightError, match="No Hindsight API URL"): + memory_instructions(bank_id="test") + + def test_uses_global_config(self): + configure(hindsight_api_url="http://localhost:8888") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_client = _mock_client() + mock_client.recall.return_value = _mock_recall_response(["fact"]) + mock_cls.return_value = mock_client + + result = memory_instructions(bank_id="test") + + assert "1. fact" in result + mock_cls.assert_called_once_with( + base_url="http://localhost:8888", timeout=30.0 + ) + + def test_uses_sync_recall(self): + """memory_instructions should use sync client.recall, not arecall.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions(bank_id="test", client=client) + + client.recall.assert_called_once() + # Should NOT call async variant + assert not hasattr(client, "arecall") or not client.arecall.called + + +# --------------------------------------------------------------------------- +# Package-level exports +# --------------------------------------------------------------------------- + + +class TestExports: + def test_all_exports_importable(self): + import hindsight_agno + + for name in hindsight_agno.__all__: + assert hasattr(hindsight_agno, name), ( + f"{name} in __all__ but not importable" + ) + + def test_version(self): + import hindsight_agno + + assert hindsight_agno.__version__ == "0.1.0" + + def test_hindsight_error_importable_from_top_level(self): + from hindsight_agno import HindsightError + + assert issubclass(HindsightError, Exception) + + def test_config_class_importable(self): + from hindsight_agno import HindsightAgnoConfig + + config = HindsightAgnoConfig() + assert config.budget == "mid" + + +# --------------------------------------------------------------------------- +# Error class +# --------------------------------------------------------------------------- + + +class TestHindsightError: + def test_is_exception(self): + assert issubclass(HindsightError, Exception) + + def test_can_be_raised_and_caught(self): + with pytest.raises(HindsightError, match="test error"): + raise HindsightError("test error") + + def test_str_representation(self): + err = HindsightError("something went wrong") + assert str(err) == "something went wrong" + + +# --------------------------------------------------------------------------- +# Multiple toolkit instances +# --------------------------------------------------------------------------- + + +class TestMultipleToolkits: + def test_separate_created_banks_sets(self): + """Each toolkit instance tracks its own created banks.""" + client = _mock_client() + toolkit1 = HindsightTools(bank_id="bank-1", client=client) + toolkit2 = HindsightTools(bank_id="bank-2", client=client) + ctx = _mock_run_context() + + toolkit1.retain_memory(ctx, "content") + toolkit2.retain_memory(ctx, "content") + + assert client.create_bank.call_count == 2 + + def test_separate_config_per_toolkit(self): + """Each toolkit can have different settings.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + toolkit_low = HindsightTools(bank_id="test", client=client, budget="low") + toolkit_high = HindsightTools(bank_id="test", client=client, budget="high") + ctx = _mock_run_context() + + toolkit_low.recall_memory(ctx, "query") + low_budget = client.recall.call_args[1]["budget"] + + toolkit_high.recall_memory(ctx, "query") + high_budget = client.recall.call_args[1]["budget"] + + assert low_budget == "low" + assert high_budget == "high" + + +# --------------------------------------------------------------------------- +# Logging +# --------------------------------------------------------------------------- + + +class TestLogging: + def test_retain_logs_error(self, caplog): + client = _mock_client() + client.retain.side_effect = RuntimeError("boom") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with caplog.at_level(logging.ERROR, logger="hindsight_agno.tools"): + with pytest.raises(HindsightError): + toolkit.retain_memory(ctx, "content") + + assert "Retain failed: boom" in caplog.text + + def test_recall_logs_error(self, caplog): + client = _mock_client() + client.recall.side_effect = RuntimeError("timeout") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with caplog.at_level(logging.ERROR, logger="hindsight_agno.tools"): + with pytest.raises(HindsightError): + toolkit.recall_memory(ctx, "query") + + assert "Recall failed: timeout" in caplog.text + + def test_reflect_logs_error(self, caplog): + client = _mock_client() + client.reflect.side_effect = RuntimeError("service down") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with caplog.at_level(logging.ERROR, logger="hindsight_agno.tools"): + with pytest.raises(HindsightError): + toolkit.reflect_on_memory(ctx, "query") + + assert "Reflect failed: service down" in caplog.text + + def test_hindsight_error_not_logged(self, caplog): + """HindsightError (e.g. missing bank_id) should not log — it's re-raised directly.""" + client = _mock_client() + toolkit = HindsightTools(client=client) + ctx = _mock_run_context() # No user_id + + with caplog.at_level(logging.ERROR, logger="hindsight_agno.tools"): + with pytest.raises(HindsightError, match="No bank_id"): + toolkit.retain_memory(ctx, "content") + + assert "Retain failed" not in caplog.text + + +# --------------------------------------------------------------------------- +# Edge cases: falsy and special values +# --------------------------------------------------------------------------- + + +class TestEdgeCases: + def test_empty_string_bank_id_is_falsy(self): + """bank_id='' is falsy, so resolution falls through to user_id.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="", client=client) + ctx = _mock_run_context(user_id="user-from-ctx") + + # "" is not None, so _bank_id check passes, but "" is also the bank_id + # Actually: `if self._bank_id is not None:` — "" is not None, so "" is used + toolkit.recall_memory(ctx, "query") + assert client.recall.call_args[1]["bank_id"] == "" + + def test_empty_string_user_id_is_falsy(self): + """user_id='' is falsy, so resolution raises error.""" + client = _mock_client() + toolkit = HindsightTools(client=client) + ctx = _mock_run_context(user_id="") + + with pytest.raises(HindsightError, match="No bank_id available"): + toolkit.recall_memory(ctx, "query") + + def test_unicode_content_in_retain(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.retain_memory(ctx, "The user likes coffee and books") + + assert result == "Memory stored successfully." + assert ( + client.retain.call_args[1]["content"] == "The user likes coffee and books" + ) + + def test_unicode_in_recall_results(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["Cafe du Monde"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "query") + + assert "Cafe du Monde" in result + + def test_multiline_content_in_retain(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + content = "Line 1\nLine 2\nLine 3" + + result = toolkit.retain_memory(ctx, content) + + assert result == "Memory stored successfully." + assert client.retain.call_args[1]["content"] == content + + def test_newlines_in_recall_results(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response( + ["fact with\nnewline", "normal fact"] + ) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "query") + + assert "1. fact with\nnewline" in result + assert "2. normal fact" in result + + def test_special_chars_in_bank_id(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="org/user-123_v2", client=client) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + assert client.recall.call_args[1]["bank_id"] == "org/user-123_v2" + + def test_empty_tags_list_not_sent(self): + """tags=[] is falsy, so tags should not be sent to retain.""" + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client, tags=[]) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + + assert "tags" not in client.retain.call_args[1] + + def test_empty_recall_tags_list_not_sent(self): + """recall_tags=[] is falsy, so tags should not be sent to recall.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="test", client=client, recall_tags=[]) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + assert "tags" not in client.recall.call_args[1] + + def test_very_long_content(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + content = "x" * 100_000 + + result = toolkit.retain_memory(ctx, content) + + assert result == "Memory stored successfully." + assert len(client.retain.call_args[1]["content"]) == 100_000 + + def test_recall_with_empty_query(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "") + + assert client.recall.call_args[1]["query"] == "" + + def test_reflect_with_empty_query(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + toolkit.reflect_on_memory(ctx, "") + + assert client.reflect.call_args[1]["query"] == "" + + +# --------------------------------------------------------------------------- +# Error type variations +# --------------------------------------------------------------------------- + + +class TestErrorTypes: + """Verify various exception types are properly wrapped.""" + + def test_retain_wraps_type_error(self): + client = _mock_client() + client.retain.side_effect = TypeError("bad type") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="Retain failed.*bad type"): + toolkit.retain_memory(ctx, "content") + + def test_recall_wraps_key_error(self): + client = _mock_client() + client.recall.side_effect = KeyError("missing key") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="Recall failed"): + toolkit.recall_memory(ctx, "query") + + def test_reflect_wraps_os_error(self): + client = _mock_client() + client.reflect.side_effect = OSError("disk full") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="Reflect failed.*disk full"): + toolkit.reflect_on_memory(ctx, "query") + + def test_retain_wraps_value_error(self): + client = _mock_client() + client.retain.side_effect = ValueError("invalid input") + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + with pytest.raises(HindsightError, match="Retain failed.*invalid input"): + toolkit.retain_memory(ctx, "content") + + +# --------------------------------------------------------------------------- +# Tool docstrings (these become LLM tool descriptions) +# --------------------------------------------------------------------------- + + +class TestToolDocstrings: + """Tool docstrings are critical — Agno exposes them to the LLM.""" + + def test_retain_has_docstring(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert toolkit.retain_memory.__doc__ is not None + assert "Store" in toolkit.retain_memory.__doc__ + assert "memory" in toolkit.retain_memory.__doc__.lower() + + def test_recall_has_docstring(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert toolkit.recall_memory.__doc__ is not None + assert "Search" in toolkit.recall_memory.__doc__ + assert "memory" in toolkit.recall_memory.__doc__.lower() + + def test_reflect_has_docstring(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert toolkit.reflect_on_memory.__doc__ is not None + assert "Synthesize" in toolkit.reflect_on_memory.__doc__ + + +# --------------------------------------------------------------------------- +# Toolkit integration with Agno's registration +# --------------------------------------------------------------------------- + + +class TestToolkitIntegration: + def test_get_functions_returns_registered_tools(self): + """Verify tools are accessible via Toolkit.get_functions().""" + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + functions = toolkit.get_functions() + assert "retain_memory" in functions + assert "recall_memory" in functions + assert "reflect_on_memory" in functions + + def test_get_functions_respects_enable_flags(self): + client = _mock_client() + toolkit = HindsightTools( + bank_id="test", + client=client, + enable_retain=False, + enable_reflect=False, + ) + functions = toolkit.get_functions() + assert "retain_memory" not in functions + assert "recall_memory" in functions + assert "reflect_on_memory" not in functions + + def test_instructions_are_set(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert toolkit.instructions is not None + assert len(toolkit.instructions) > 0 + + def test_instructions_mention_all_tools(self): + client = _mock_client() + toolkit = HindsightTools(bank_id="test", client=client) + assert "retain_memory" in toolkit.instructions + assert "recall_memory" in toolkit.instructions + assert "reflect_on_memory" in toolkit.instructions + + +# --------------------------------------------------------------------------- +# Bank creation across tool types +# --------------------------------------------------------------------------- + + +class TestBankCreationCrossTool: + def test_retain_then_recall_creates_bank_once(self): + """Bank created by retain is reused by recall (no re-creation).""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="shared-bank", client=client) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + toolkit.recall_memory(ctx, "query") + + # create_bank only called by retain (once) + client.create_bank.assert_called_once() + + def test_retain_then_reflect_creates_bank_once(self): + client = _mock_client() + client.reflect.return_value = _mock_reflect_response("answer") + toolkit = HindsightTools(bank_id="shared-bank", client=client) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + toolkit.reflect_on_memory(ctx, "query") + + client.create_bank.assert_called_once() + + +# --------------------------------------------------------------------------- +# memory_instructions edge cases +# --------------------------------------------------------------------------- + + +class TestMemoryInstructionsEdgeCases: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_max_results_zero(self): + """max_results=0 → results[:0] is empty → returns ''.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact1", "fact2"]) + + result = memory_instructions(bank_id="test", client=client, max_results=0) + + assert result == "" + + def test_max_results_one(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["only-fact", "extra"]) + + result = memory_instructions(bank_id="test", client=client, max_results=1) + + assert "1. only-fact" in result + assert "extra" not in result + + def test_empty_prefix(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + result = memory_instructions(bank_id="test", client=client, prefix="") + + # Empty prefix still appears as first line (empty string before \n join) + assert result.startswith("\n") or result == "\n1. fact" + + def test_prefix_without_newline(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + result = memory_instructions(bank_id="test", client=client, prefix="Context: ") + + assert result == "Context: \n1. fact" + + def test_bank_id_passed_to_recall(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions(bank_id="specific-bank", client=client) + + assert client.recall.call_args[1]["bank_id"] == "specific-bank" + + def test_empty_tags_list_not_sent(self): + """tags=[] is falsy, so tags should not be included in recall kwargs.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + memory_instructions(bank_id="test", client=client, tags=[]) + + assert "tags" not in client.recall.call_args[1] + + def test_multiple_calls_with_same_client(self): + """memory_instructions can be called multiple times with the same client.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + r1 = memory_instructions(bank_id="bank-1", client=client) + r2 = memory_instructions(bank_id="bank-2", client=client) + + assert client.recall.call_count == 2 + assert r1 == r2 # Same response mock + + def test_client_resolution_error_propagates(self): + """_resolve_client error during memory_instructions IS raised (not swallowed).""" + with pytest.raises(HindsightError, match="No Hindsight API URL"): + memory_instructions(bank_id="test") + + def test_recall_error_swallowed_not_raised(self): + """Once client is resolved, recall errors are swallowed (returns '').""" + client = _mock_client() + client.recall.side_effect = Exception("any error") + + result = memory_instructions(bank_id="test", client=client) + + assert result == "" + + +# --------------------------------------------------------------------------- +# _resolve_client edge cases +# --------------------------------------------------------------------------- + + +class TestResolveClientEdgeCases: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_empty_string_api_key_not_passed(self): + """api_key='' is falsy, so it should not be passed to Hindsight.""" + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, "http://localhost:8888", "") + call_kwargs = mock_cls.call_args[1] + assert "api_key" not in call_kwargs + + def test_none_api_key_not_passed(self): + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, "http://localhost:8888", None) + call_kwargs = mock_cls.call_args[1] + assert "api_key" not in call_kwargs + + def test_whitespace_api_key_is_passed(self): + """Non-empty whitespace string IS truthy, so it gets passed.""" + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, "http://localhost:8888", " ") + call_kwargs = mock_cls.call_args[1] + assert call_kwargs["api_key"] == " " + + def test_config_api_key_used_when_no_explicit(self): + configure(hindsight_api_url="http://config:8888", api_key="config-key") + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, None, None) + assert mock_cls.call_args[1]["api_key"] == "config-key" + + def test_config_none_api_key_not_passed(self): + configure(hindsight_api_url="http://config:8888", api_key=None) + with patch("hindsight_agno.tools.Hindsight") as mock_cls: + mock_cls.return_value = _mock_client() + _resolve_client(None, None, None) + assert "api_key" not in mock_cls.call_args[1] + + +# --------------------------------------------------------------------------- +# Config interaction with toolkit +# --------------------------------------------------------------------------- + + +class TestConfigToolkitInteraction: + def setup_method(self): + reset_config() + + def teardown_method(self): + reset_config() + + def test_config_set_after_toolkit_creation_not_used(self): + """Config is captured at construction time, not at tool call time.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools(bank_id="test", client=client, tags=["original"]) + ctx = _mock_run_context() + + # Change config after construction + configure(hindsight_api_url="http://new:8888", tags=["updated"]) + + toolkit.retain_memory(ctx, "content") + + # Should use the original tags, not updated + assert client.retain.call_args[1]["tags"] == ["original"] + + def test_toolkit_without_config_then_configure(self): + """Creating toolkit with explicit client doesn't require config.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + + # No config set + toolkit = HindsightTools(bank_id="test", client=client) + + # Config set after — doesn't affect existing toolkit + configure(hindsight_api_url="http://new:8888", budget="high") + + toolkit.recall_memory(_mock_run_context(), "query") + assert client.recall.call_args[1]["budget"] == "mid" # Not "high" + + def test_multiple_tags(self): + """Multiple tags are passed as a list.""" + client = _mock_client() + toolkit = HindsightTools( + bank_id="test", + client=client, + tags=["source:chat", "env:prod", "version:2"], + ) + ctx = _mock_run_context() + + toolkit.retain_memory(ctx, "content") + + tags = client.retain.call_args[1]["tags"] + assert tags == ["source:chat", "env:prod", "version:2"] + + def test_multiple_recall_tags(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact"]) + toolkit = HindsightTools( + bank_id="test", + client=client, + recall_tags=["scope:user", "type:preference"], + recall_tags_match="all_strict", + ) + ctx = _mock_run_context() + + toolkit.recall_memory(ctx, "query") + + kwargs = client.recall.call_args[1] + assert kwargs["tags"] == ["scope:user", "type:preference"] + assert kwargs["tags_match"] == "all_strict" + + +# --------------------------------------------------------------------------- +# Recall output formatting +# --------------------------------------------------------------------------- + + +class TestRecallFormatting: + def test_result_numbering_starts_at_one(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["alpha"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "q") + + assert result.startswith("1.") + assert "0." not in result + + def test_results_separated_by_newlines(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["a", "b", "c"]) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "q") + + lines = result.split("\n") + assert len(lines) == 3 + assert lines[0] == "1. a" + assert lines[1] == "2. b" + assert lines[2] == "3. c" + + def test_double_digit_numbering(self): + client = _mock_client() + facts = [f"fact-{i}" for i in range(1, 13)] + client.recall.return_value = _mock_recall_response(facts) + toolkit = HindsightTools(bank_id="test", client=client) + ctx = _mock_run_context() + + result = toolkit.recall_memory(ctx, "q") + + assert "10. fact-10" in result + assert "11. fact-11" in result + assert "12. fact-12" in result + + +# --------------------------------------------------------------------------- +# memory_instructions output formatting +# --------------------------------------------------------------------------- + + +class TestMemoryInstructionsFormatting: + def test_default_prefix_includes_trailing_newline(self): + """Default prefix is 'Relevant memories:\\n', so join adds a blank line.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact1", "fact2"]) + + result = memory_instructions(bank_id="test", client=client) + + # prefix="Relevant memories:\n" joined with "\n" produces: + # "Relevant memories:\n\n1. fact1\n2. fact2" + assert result == "Relevant memories:\n\n1. fact1\n2. fact2" + + def test_single_result_with_default_prefix(self): + client = _mock_client() + client.recall.return_value = _mock_recall_response(["single"]) + + result = memory_instructions(bank_id="test", client=client) + + assert result == "Relevant memories:\n\n1. single" + + def test_clean_prefix_no_double_newline(self): + """Using a prefix without trailing newline avoids the blank line.""" + client = _mock_client() + client.recall.return_value = _mock_recall_response(["fact1", "fact2"]) + + result = memory_instructions( + bank_id="test", client=client, prefix="Relevant memories:" + ) + + assert result == "Relevant memories:\n1. fact1\n2. fact2" + + +# --------------------------------------------------------------------------- +# Keyword-only constructor enforcement +# --------------------------------------------------------------------------- + + +class TestConstructorAPI: + def test_hindsight_tools_requires_keyword_args(self): + """All HindsightTools args are keyword-only (due to *).""" + client = _mock_client() + with pytest.raises(TypeError): + HindsightTools("test", client) # type: ignore[misc] + + def test_memory_instructions_requires_keyword_args(self): + """All memory_instructions args are keyword-only (due to *).""" + client = _mock_client() + with pytest.raises(TypeError): + memory_instructions("test", client) # type: ignore[misc] diff --git a/hindsight-integrations/agno/uv.lock b/hindsight-integrations/agno/uv.lock new file mode 100644 index 000000000..4ecde2e27 --- /dev/null +++ b/hindsight-integrations/agno/uv.lock @@ -0,0 +1,1425 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" + +[[package]] +name = "agno" +version = "2.5.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docstring-parser" }, + { name = "gitpython" }, + { name = "h11" }, + { name = "httpx", extra = ["http2"] }, + { name = "packaging" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "python-dotenv" }, + { name = "python-multipart" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "typer" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4a/ad/accb1cf3063fe1efffe9b41a37cccfa3b81c35486022d5b932668613df68/agno-2.5.9.tar.gz", hash = "sha256:e7a8b713bb49b79fd3b69ae70b3228321f753fd8c28fe0fcf72bcf435db14554", size = 1768973, upload-time = "2026-03-10T15:33:48.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/c2/ce5a1f02b2def0b50b37a5477bc9e979438b1aceef1d1d8ed3a6a2ab12f6/agno-2.5.9-py3-none-any.whl", hash = "sha256:78161e918a8e0a762da1b5d3e4ee82edb148cd454d710bf52442e5e15e8e6233", size = 2108165, upload-time = "2026-03-10T15:33:46.88Z" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "async-timeout", marker = "python_full_version < '3.11'" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/d6/5aec9313ee6ea9c7cde8b891b69f4ff4001416867104580670a31daeba5b/aiohttp-3.13.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d5a372fd5afd301b3a89582817fdcdb6c34124787c70dbcc616f259013e7eef7", size = 738950, upload-time = "2026-01-03T17:29:13.002Z" }, + { url = "https://files.pythonhosted.org/packages/68/03/8fa90a7e6d11ff20a18837a8e2b5dd23db01aabc475aa9271c8ad33299f5/aiohttp-3.13.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:147e422fd1223005c22b4fe080f5d93ced44460f5f9c105406b753612b587821", size = 496099, upload-time = "2026-01-03T17:29:15.268Z" }, + { url = "https://files.pythonhosted.org/packages/d2/23/b81f744d402510a8366b74eb420fc0cc1170d0c43daca12d10814df85f10/aiohttp-3.13.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:859bd3f2156e81dd01432f5849fc73e2243d4a487c4fd26609b1299534ee1845", size = 491072, upload-time = "2026-01-03T17:29:16.922Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e1/56d1d1c0dd334cd203dd97706ce004c1aa24b34a813b0b8daf3383039706/aiohttp-3.13.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dca68018bf48c251ba17c72ed479f4dafe9dbd5a73707ad8d28a38d11f3d42af", size = 1671588, upload-time = "2026-01-03T17:29:18.539Z" }, + { url = "https://files.pythonhosted.org/packages/5f/34/8d7f962604f4bc2b4e39eb1220dac7d4e4cba91fb9ba0474b4ecd67db165/aiohttp-3.13.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fee0c6bc7db1de362252affec009707a17478a00ec69f797d23ca256e36d5940", size = 1640334, upload-time = "2026-01-03T17:29:21.028Z" }, + { url = "https://files.pythonhosted.org/packages/94/1d/fcccf2c668d87337ddeef9881537baee13c58d8f01f12ba8a24215f2b804/aiohttp-3.13.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c048058117fd649334d81b4b526e94bde3ccaddb20463a815ced6ecbb7d11160", size = 1722656, upload-time = "2026-01-03T17:29:22.531Z" }, + { url = "https://files.pythonhosted.org/packages/aa/98/c6f3b081c4c606bc1e5f2ec102e87d6411c73a9ef3616fea6f2d5c98c062/aiohttp-3.13.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:215a685b6fbbfcf71dfe96e3eba7a6f58f10da1dfdf4889c7dd856abe430dca7", size = 1817625, upload-time = "2026-01-03T17:29:24.276Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c0/cfcc3d2e11b477f86e1af2863f3858c8850d751ce8dc39c4058a072c9e54/aiohttp-3.13.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2c184bb1fe2cbd2cefba613e9db29a5ab559323f994b6737e370d3da0ac455", size = 1672604, upload-time = "2026-01-03T17:29:26.099Z" }, + { url = "https://files.pythonhosted.org/packages/1e/77/6b4ffcbcac4c6a5d041343a756f34a6dd26174ae07f977a64fe028dda5b0/aiohttp-3.13.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:75ca857eba4e20ce9f546cd59c7007b33906a4cd48f2ff6ccf1ccfc3b646f279", size = 1554370, upload-time = "2026-01-03T17:29:28.121Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f0/e3ddfa93f17d689dbe014ba048f18e0c9f9b456033b70e94349a2e9048be/aiohttp-3.13.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:81e97251d9298386c2b7dbeb490d3d1badbdc69107fb8c9299dd04eb39bddc0e", size = 1642023, upload-time = "2026-01-03T17:29:30.002Z" }, + { url = "https://files.pythonhosted.org/packages/eb/45/c14019c9ec60a8e243d06d601b33dcc4fd92379424bde3021725859d7f99/aiohttp-3.13.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:c0e2d366af265797506f0283487223146af57815b388623f0357ef7eac9b209d", size = 1649680, upload-time = "2026-01-03T17:29:31.782Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fd/09c9451dae5aa5c5ed756df95ff9ef549d45d4be663bafd1e4954fd836f0/aiohttp-3.13.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:4e239d501f73d6db1522599e14b9b321a7e3b1de66ce33d53a765d975e9f4808", size = 1692407, upload-time = "2026-01-03T17:29:33.392Z" }, + { url = "https://files.pythonhosted.org/packages/a6/81/938bc2ec33c10efd6637ccb3d22f9f3160d08e8f3aa2587a2c2d5ab578eb/aiohttp-3.13.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0db318f7a6f065d84cb1e02662c526294450b314a02bd9e2a8e67f0d8564ce40", size = 1543047, upload-time = "2026-01-03T17:29:34.855Z" }, + { url = "https://files.pythonhosted.org/packages/f7/23/80488ee21c8d567c83045e412e1d9b7077d27171591a4eb7822586e8c06a/aiohttp-3.13.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:bfc1cc2fe31a6026a8a88e4ecfb98d7f6b1fec150cfd708adbfd1d2f42257c29", size = 1715264, upload-time = "2026-01-03T17:29:36.389Z" }, + { url = "https://files.pythonhosted.org/packages/e2/83/259a8da6683182768200b368120ab3deff5370bed93880fb9a3a86299f34/aiohttp-3.13.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af71fff7bac6bb7508956696dce8f6eec2bbb045eceb40343944b1ae62b5ef11", size = 1657275, upload-time = "2026-01-03T17:29:38.162Z" }, + { url = "https://files.pythonhosted.org/packages/3f/4f/2c41f800a0b560785c10fb316216ac058c105f9be50bdc6a285de88db625/aiohttp-3.13.3-cp310-cp310-win32.whl", hash = "sha256:37da61e244d1749798c151421602884db5270faf479cf0ef03af0ff68954c9dd", size = 434053, upload-time = "2026-01-03T17:29:40.074Z" }, + { url = "https://files.pythonhosted.org/packages/80/df/29cd63c7ecfdb65ccc12f7d808cac4fa2a19544660c06c61a4a48462de0c/aiohttp-3.13.3-cp310-cp310-win_amd64.whl", hash = "sha256:7e63f210bc1b57ef699035f2b4b6d9ce096b5914414a49b0997c839b2bd2223c", size = 456687, upload-time = "2026-01-03T17:29:41.819Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4c/a164164834f03924d9a29dc3acd9e7ee58f95857e0b467f6d04298594ebb/aiohttp-3.13.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b", size = 746051, upload-time = "2026-01-03T17:29:43.287Z" }, + { url = "https://files.pythonhosted.org/packages/82/71/d5c31390d18d4f58115037c432b7e0348c60f6f53b727cad33172144a112/aiohttp-3.13.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64", size = 499234, upload-time = "2026-01-03T17:29:44.822Z" }, + { url = "https://files.pythonhosted.org/packages/0e/c9/741f8ac91e14b1d2e7100690425a5b2b919a87a5075406582991fb7de920/aiohttp-3.13.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea", size = 494979, upload-time = "2026-01-03T17:29:46.405Z" }, + { url = "https://files.pythonhosted.org/packages/75/b5/31d4d2e802dfd59f74ed47eba48869c1c21552c586d5e81a9d0d5c2ad640/aiohttp-3.13.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a", size = 1748297, upload-time = "2026-01-03T17:29:48.083Z" }, + { url = "https://files.pythonhosted.org/packages/1a/3e/eefad0ad42959f226bb79664826883f2687d602a9ae2941a18e0484a74d3/aiohttp-3.13.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540", size = 1707172, upload-time = "2026-01-03T17:29:49.648Z" }, + { url = "https://files.pythonhosted.org/packages/c5/3a/54a64299fac2891c346cdcf2aa6803f994a2e4beeaf2e5a09dcc54acc842/aiohttp-3.13.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b", size = 1805405, upload-time = "2026-01-03T17:29:51.244Z" }, + { url = "https://files.pythonhosted.org/packages/6c/70/ddc1b7169cf64075e864f64595a14b147a895a868394a48f6a8031979038/aiohttp-3.13.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3", size = 1899449, upload-time = "2026-01-03T17:29:53.938Z" }, + { url = "https://files.pythonhosted.org/packages/a1/7e/6815aab7d3a56610891c76ef79095677b8b5be6646aaf00f69b221765021/aiohttp-3.13.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1", size = 1748444, upload-time = "2026-01-03T17:29:55.484Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f2/073b145c4100da5511f457dc0f7558e99b2987cf72600d42b559db856fbc/aiohttp-3.13.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3", size = 1606038, upload-time = "2026-01-03T17:29:57.179Z" }, + { url = "https://files.pythonhosted.org/packages/0a/c1/778d011920cae03ae01424ec202c513dc69243cf2db303965615b81deeea/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440", size = 1724156, upload-time = "2026-01-03T17:29:58.914Z" }, + { url = "https://files.pythonhosted.org/packages/0e/cb/3419eabf4ec1e9ec6f242c32b689248365a1cf621891f6f0386632525494/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7", size = 1722340, upload-time = "2026-01-03T17:30:01.962Z" }, + { url = "https://files.pythonhosted.org/packages/7a/e5/76cf77bdbc435bf233c1f114edad39ed4177ccbfab7c329482b179cff4f4/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c", size = 1783041, upload-time = "2026-01-03T17:30:03.609Z" }, + { url = "https://files.pythonhosted.org/packages/9d/d4/dd1ca234c794fd29c057ce8c0566b8ef7fd6a51069de5f06fa84b9a1971c/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51", size = 1596024, upload-time = "2026-01-03T17:30:05.132Z" }, + { url = "https://files.pythonhosted.org/packages/55/58/4345b5f26661a6180afa686c473620c30a66afdf120ed3dd545bbc809e85/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4", size = 1804590, upload-time = "2026-01-03T17:30:07.135Z" }, + { url = "https://files.pythonhosted.org/packages/7b/06/05950619af6c2df7e0a431d889ba2813c9f0129cec76f663e547a5ad56f2/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29", size = 1740355, upload-time = "2026-01-03T17:30:09.083Z" }, + { url = "https://files.pythonhosted.org/packages/3e/80/958f16de79ba0422d7c1e284b2abd0c84bc03394fbe631d0a39ffa10e1eb/aiohttp-3.13.3-cp311-cp311-win32.whl", hash = "sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239", size = 433701, upload-time = "2026-01-03T17:30:10.869Z" }, + { url = "https://files.pythonhosted.org/packages/dc/f2/27cdf04c9851712d6c1b99df6821a6623c3c9e55956d4b1e318c337b5a48/aiohttp-3.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f", size = 457678, upload-time = "2026-01-03T17:30:12.719Z" }, + { url = "https://files.pythonhosted.org/packages/a0/be/4fc11f202955a69e0db803a12a062b8379c970c7c84f4882b6da17337cc1/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c", size = 739732, upload-time = "2026-01-03T17:30:14.23Z" }, + { url = "https://files.pythonhosted.org/packages/97/2c/621d5b851f94fa0bb7430d6089b3aa970a9d9b75196bc93bb624b0db237a/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168", size = 494293, upload-time = "2026-01-03T17:30:15.96Z" }, + { url = "https://files.pythonhosted.org/packages/5d/43/4be01406b78e1be8320bb8316dc9c42dbab553d281c40364e0f862d5661c/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d", size = 493533, upload-time = "2026-01-03T17:30:17.431Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" }, + { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" }, + { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" }, + { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" }, + { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" }, + { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" }, + { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" }, + { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" }, + { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" }, + { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" }, + { url = "https://files.pythonhosted.org/packages/3c/4a/1a3fee7c21350cac78e5c5cef711bac1b94feca07399f3d406972e2d8fcd/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046", size = 428253, upload-time = "2026-01-03T17:30:42.644Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b7/76175c7cb4eb73d91ad63c34e29fc4f77c9386bba4a65b53ba8e05ee3c39/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57", size = 455407, upload-time = "2026-01-03T17:30:44.195Z" }, + { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" }, + { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" }, + { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" }, + { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" }, + { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" }, + { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" }, + { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" }, + { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" }, + { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" }, + { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" }, + { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" }, + { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" }, + { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" }, + { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" }, + { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" }, + { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" }, + { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" }, + { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" }, + { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" }, + { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" }, + { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" }, + { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" }, + { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" }, + { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" }, + { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" }, + { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" }, + { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" }, + { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" }, + { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" }, + { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" }, + { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" }, + { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" }, +] + +[[package]] +name = "aiohttp-retry" +version = "2.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/61/ebda4d8e3d8cfa1fd3db0fb428db2dd7461d5742cea35178277ad180b033/aiohttp_retry-2.9.1.tar.gz", hash = "sha256:8eb75e904ed4ee5c2ec242fefe85bf04240f685391c4879d8f541d6028ff01f1", size = 13608, upload-time = "2024-11-06T10:44:54.574Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/99/84ba7273339d0f3dfa57901b846489d2e5c2cd731470167757f1935fffbd/aiohttp_retry-2.9.1-py3-none-any.whl", hash = "sha256:66d2759d1921838256a05a3f80ad7e724936f083e35be5abb5e16eed6be6dc54", size = 9981, upload-time = "2024-11-06T10:44:52.917Z" }, +] + +[[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]] +name = "annotated-doc" +version = "0.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +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 = "anyio" +version = "4.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" } +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 = "async-timeout" +version = "5.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" }, +] + +[[package]] +name = "attrs" +version = "25.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, +] + +[[package]] +name = "certifi" +version = "2026.2.25" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" }, +] + +[[package]] +name = "click" +version = "8.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +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 = "docstring-parser" +version = "0.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "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/83/4a/557715d5047da48d54e659203b9335be7bfaafda2c3f627b7c47e0b3aaf3/frozenlist-1.8.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011", size = 86230, upload-time = "2025-10-06T05:35:23.699Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fb/c85f9fed3ea8fe8740e5b46a59cc141c23b842eca617da8876cfce5f760e/frozenlist-1.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565", size = 49621, upload-time = "2025-10-06T05:35:25.341Z" }, + { url = "https://files.pythonhosted.org/packages/63/70/26ca3f06aace16f2352796b08704338d74b6d1a24ca38f2771afbb7ed915/frozenlist-1.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad", size = 49889, upload-time = "2025-10-06T05:35:26.797Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ed/c7895fd2fde7f3ee70d248175f9b6cdf792fb741ab92dc59cd9ef3bd241b/frozenlist-1.8.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2", size = 219464, upload-time = "2025-10-06T05:35:28.254Z" }, + { url = "https://files.pythonhosted.org/packages/6b/83/4d587dccbfca74cb8b810472392ad62bfa100bf8108c7223eb4c4fa2f7b3/frozenlist-1.8.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186", size = 221649, upload-time = "2025-10-06T05:35:29.454Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c6/fd3b9cd046ec5fff9dab66831083bc2077006a874a2d3d9247dea93ddf7e/frozenlist-1.8.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e", size = 219188, upload-time = "2025-10-06T05:35:30.951Z" }, + { url = "https://files.pythonhosted.org/packages/ce/80/6693f55eb2e085fc8afb28cf611448fb5b90e98e068fa1d1b8d8e66e5c7d/frozenlist-1.8.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450", size = 231748, upload-time = "2025-10-06T05:35:32.101Z" }, + { url = "https://files.pythonhosted.org/packages/97/d6/e9459f7c5183854abd989ba384fe0cc1a0fb795a83c033f0571ec5933ca4/frozenlist-1.8.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef", size = 236351, upload-time = "2025-10-06T05:35:33.834Z" }, + { url = "https://files.pythonhosted.org/packages/97/92/24e97474b65c0262e9ecd076e826bfd1d3074adcc165a256e42e7b8a7249/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4", size = 218767, upload-time = "2025-10-06T05:35:35.205Z" }, + { url = "https://files.pythonhosted.org/packages/ee/bf/dc394a097508f15abff383c5108cb8ad880d1f64a725ed3b90d5c2fbf0bb/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff", size = 235887, upload-time = "2025-10-06T05:35:36.354Z" }, + { url = "https://files.pythonhosted.org/packages/40/90/25b201b9c015dbc999a5baf475a257010471a1fa8c200c843fd4abbee725/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c", size = 228785, upload-time = "2025-10-06T05:35:37.949Z" }, + { url = "https://files.pythonhosted.org/packages/84/f4/b5bc148df03082f05d2dd30c089e269acdbe251ac9a9cf4e727b2dbb8a3d/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f", size = 230312, upload-time = "2025-10-06T05:35:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/db/4b/87e95b5d15097c302430e647136b7d7ab2398a702390cf4c8601975709e7/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7", size = 217650, upload-time = "2025-10-06T05:35:40.377Z" }, + { url = "https://files.pythonhosted.org/packages/e5/70/78a0315d1fea97120591a83e0acd644da638c872f142fd72a6cebee825f3/frozenlist-1.8.0-cp310-cp310-win32.whl", hash = "sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a", size = 39659, upload-time = "2025-10-06T05:35:41.863Z" }, + { url = "https://files.pythonhosted.org/packages/66/aa/3f04523fb189a00e147e60c5b2205126118f216b0aa908035c45336e27e4/frozenlist-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6", size = 43837, upload-time = "2025-10-06T05:35:43.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/75/1135feecdd7c336938bd55b4dc3b0dfc46d85b9be12ef2628574b28de776/frozenlist-1.8.0-cp310-cp310-win_arm64.whl", hash = "sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e", size = 39989, upload-time = "2025-10-06T05:35:44.596Z" }, + { 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 = "gitdb" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" }, +] + +[[package]] +name = "gitpython" +version = "3.1.46" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/b5/59d16470a1f0dfe8c793f9ef56fd3826093fc52b3bd96d6b9d6c26c7e27b/gitpython-3.1.46.tar.gz", hash = "sha256:400124c7d0ef4ea03f7310ac2fbf7151e09ff97f2a3288d64a440c584a29c37f", size = 215371, upload-time = "2026-01-01T15:37:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/09/e21df6aef1e1ffc0c816f0522ddc3f6dcded766c3261813131c78a704470/gitpython-3.1.46-py3-none-any.whl", hash = "sha256:79812ed143d9d25b6d176a10bb511de0f9c67b1fa641d82097b0ab90398a2058", size = 208620, upload-time = "2026-01-01T15:37:30.574Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +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 = "h2" +version = "4.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "hpack" }, + { name = "hyperframe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026, upload-time = "2025-08-23T18:12:19.778Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/b2/119f6e6dcbd96f9069ce9a2665e0146588dc9f88f29549711853645e736a/h2-4.3.0-py3-none-any.whl", hash = "sha256:c438f029a25f7945c69e0ccf0fb951dc3f73a5f6412981daee861431b70e2bdd", size = 61779, upload-time = "2025-08-23T18:12:17.779Z" }, +] + +[[package]] +name = "hindsight-agno" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "agno" }, + { name = "hindsight-client" }, +] + +[package.dev-dependencies] +dev = [ + { name = "pytest" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "agno" }, + { name = "hindsight-client", specifier = ">=0.4.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "pytest", specifier = ">=9.0.2" }, + { name = "ruff", specifier = ">=0.8.0" }, +] + +[[package]] +name = "hindsight-client" +version = "0.4.18" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "aiohttp-retry" }, + { name = "pydantic" }, + { name = "python-dateutil" }, + { name = "typing-extensions" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/2a/685f287a1929f2271c2f776451530849fe5b0e49d7e940f12b051255fae6/hindsight_client-0.4.18.tar.gz", hash = "sha256:529477338e9cc9f28262925b75a8ef24657910e0dc768cdc10adb5e4bf39bdaf", size = 81007, upload-time = "2026-03-13T14:21:56.557Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/80/83febb932a84ff2c87fe31ffa0cccaefd4b82713de83fc6644b83882b403/hindsight_client-0.4.18-py3-none-any.whl", hash = "sha256:e9be27aa057c134c168cb969b34b140b753ac4cf20dbe23f2c02d0cb5ee32880", size = 200524, upload-time = "2026-03-13T14:21:54.952Z" }, +] + +[[package]] +name = "hpack" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/48/71de9ed269fdae9c8057e5a4c0aa7402e8bb16f2c6e90b3aa53327b113f8/hpack-4.1.0.tar.gz", hash = "sha256:ec5eca154f7056aa06f196a557655c5b009b382873ac8d1e66e79e87535f1dca", size = 51276, upload-time = "2025-01-22T21:44:58.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/c6/80c95b1b2b94682a72cbdbfb85b81ae2daffa4291fbfa1b1464502ede10d/hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496", size = 34357, upload-time = "2025-01-22T21:44:56.92Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +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.optional-dependencies] +http2 = [ + { name = "h2" }, +] + +[[package]] +name = "hyperframe" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566, upload-time = "2025-01-22T21:41:49.302Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007, upload-time = "2025-01-22T21:41:47.295Z" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +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/84/0b/19348d4c98980c4851d2f943f8ebafdece2ae7ef737adcfa5994ce8e5f10/multidict-6.7.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c93c3db7ea657dd4637d57e74ab73de31bccefe144d3d4ce370052035bc85fb5", size = 77176, upload-time = "2026-01-26T02:42:59.784Z" }, + { url = "https://files.pythonhosted.org/packages/ef/04/9de3f8077852e3d438215c81e9b691244532d2e05b4270e89ce67b7d103c/multidict-6.7.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:974e72a2474600827abaeda71af0c53d9ebbc3c2eb7da37b37d7829ae31232d8", size = 44996, upload-time = "2026-01-26T02:43:01.674Z" }, + { url = "https://files.pythonhosted.org/packages/31/5c/08c7f7fe311f32e83f7621cd3f99d805f45519cd06fafb247628b861da7d/multidict-6.7.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cdea2e7b2456cfb6694fb113066fd0ec7ea4d67e3a35e1f4cbeea0b448bf5872", size = 44631, upload-time = "2026-01-26T02:43:03.169Z" }, + { url = "https://files.pythonhosted.org/packages/b7/7f/0e3b1390ae772f27501199996b94b52ceeb64fe6f9120a32c6c3f6b781be/multidict-6.7.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17207077e29342fdc2c9a82e4b306f1127bf1ea91f8b71e02d4798a70bb99991", size = 242561, upload-time = "2026-01-26T02:43:04.733Z" }, + { url = "https://files.pythonhosted.org/packages/dd/f4/8719f4f167586af317b69dd3e90f913416c91ca610cac79a45c53f590312/multidict-6.7.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4f49cb5661344764e4c7c7973e92a47a59b8fc19b6523649ec9dc4960e58a03", size = 242223, upload-time = "2026-01-26T02:43:06.695Z" }, + { url = "https://files.pythonhosted.org/packages/47/ab/7c36164cce64a6ad19c6d9a85377b7178ecf3b89f8fd589c73381a5eedfd/multidict-6.7.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a9fc4caa29e2e6ae408d1c450ac8bf19892c5fca83ee634ecd88a53332c59981", size = 222322, upload-time = "2026-01-26T02:43:08.472Z" }, + { url = "https://files.pythonhosted.org/packages/f5/79/a25add6fb38035b5337bc5734f296d9afc99163403bbcf56d4170f97eb62/multidict-6.7.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c5f0c21549ab432b57dcc82130f388d84ad8179824cc3f223d5e7cfbfd4143f6", size = 254005, upload-time = "2026-01-26T02:43:10.127Z" }, + { url = "https://files.pythonhosted.org/packages/4a/7b/64a87cf98e12f756fc8bd444b001232ffff2be37288f018ad0d3f0aae931/multidict-6.7.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7dfb78d966b2c906ae1d28ccf6e6712a3cd04407ee5088cd276fe8cb42186190", size = 251173, upload-time = "2026-01-26T02:43:11.731Z" }, + { url = "https://files.pythonhosted.org/packages/4b/ac/b605473de2bb404e742f2cc3583d12aedb2352a70e49ae8fce455b50c5aa/multidict-6.7.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b0d9b91d1aa44db9c1f1ecd0d9d2ae610b2f4f856448664e01a3b35899f3f92", size = 243273, upload-time = "2026-01-26T02:43:13.063Z" }, + { url = "https://files.pythonhosted.org/packages/03/65/11492d6a0e259783720f3bc1d9ea55579a76f1407e31ed44045c99542004/multidict-6.7.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dd96c01a9dcd4889dcfcf9eb5544ca0c77603f239e3ffab0524ec17aea9a93ee", size = 238956, upload-time = "2026-01-26T02:43:14.843Z" }, + { url = "https://files.pythonhosted.org/packages/5f/a7/7ee591302af64e7c196fb63fe856c788993c1372df765102bd0448e7e165/multidict-6.7.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:067343c68cd6612d375710f895337b3a98a033c94f14b9a99eff902f205424e2", size = 233477, upload-time = "2026-01-26T02:43:16.025Z" }, + { url = "https://files.pythonhosted.org/packages/9c/99/c109962d58756c35fd9992fed7f2355303846ea2ff054bb5f5e9d6b888de/multidict-6.7.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5884a04f4ff56c6120f6ccf703bdeb8b5079d808ba604d4d53aec0d55dc33568", size = 243615, upload-time = "2026-01-26T02:43:17.84Z" }, + { url = "https://files.pythonhosted.org/packages/d5/5f/1973e7c771c86e93dcfe1c9cc55a5481b610f6614acfc28c0d326fe6bfad/multidict-6.7.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8affcf1c98b82bc901702eb73b6947a1bfa170823c153fe8a47b5f5f02e48e40", size = 249930, upload-time = "2026-01-26T02:43:19.06Z" }, + { url = "https://files.pythonhosted.org/packages/5d/a5/f170fc2268c3243853580203378cd522446b2df632061e0a5409817854c7/multidict-6.7.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:0d17522c37d03e85c8098ec8431636309b2682cf12e58f4dbc76121fb50e4962", size = 243807, upload-time = "2026-01-26T02:43:20.286Z" }, + { url = "https://files.pythonhosted.org/packages/de/01/73856fab6d125e5bc652c3986b90e8699a95e84b48d72f39ade6c0e74a8c/multidict-6.7.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:24c0cf81544ca5e17cfcb6e482e7a82cd475925242b308b890c9452a074d4505", size = 239103, upload-time = "2026-01-26T02:43:21.508Z" }, + { url = "https://files.pythonhosted.org/packages/e7/46/f1220bd9944d8aa40d8ccff100eeeee19b505b857b6f603d6078cb5315b0/multidict-6.7.1-cp310-cp310-win32.whl", hash = "sha256:d82dd730a95e6643802f4454b8fdecdf08667881a9c5670db85bc5a56693f122", size = 41416, upload-time = "2026-01-26T02:43:22.703Z" }, + { url = "https://files.pythonhosted.org/packages/68/00/9b38e272a770303692fc406c36e1a4c740f401522d5787691eb38a8925a8/multidict-6.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:cf37cbe5ced48d417ba045aca1b21bafca67489452debcde94778a576666a1df", size = 46022, upload-time = "2026-01-26T02:43:23.77Z" }, + { url = "https://files.pythonhosted.org/packages/64/65/d8d42490c02ee07b6bbe00f7190d70bb4738b3cce7629aaf9f213ef730dd/multidict-6.7.1-cp310-cp310-win_arm64.whl", hash = "sha256:59bc83d3f66b41dac1e7460aac1d196edc70c9ba3094965c467715a70ecb46db", size = 43238, upload-time = "2026-01-26T02:43:24.882Z" }, + { 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 = "packaging" +version = "26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" } +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 = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "propcache" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/0e/934b541323035566a9af292dba85a195f7b78179114f2c6ebb24551118a9/propcache-0.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c2d1fa3201efaf55d730400d945b5b3ab6e672e100ba0f9a409d950ab25d7db", size = 79534, upload-time = "2025-10-08T19:46:02.083Z" }, + { url = "https://files.pythonhosted.org/packages/a1/6b/db0d03d96726d995dc7171286c6ba9d8d14251f37433890f88368951a44e/propcache-0.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1eb2994229cc8ce7fe9b3db88f5465f5fd8651672840b2e426b88cdb1a30aac8", size = 45526, upload-time = "2025-10-08T19:46:03.884Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c3/82728404aea669e1600f304f2609cde9e665c18df5a11cdd57ed73c1dceb/propcache-0.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:66c1f011f45a3b33d7bcb22daed4b29c0c9e2224758b6be00686731e1b46f925", size = 47263, upload-time = "2025-10-08T19:46:05.405Z" }, + { url = "https://files.pythonhosted.org/packages/df/1b/39313ddad2bf9187a1432654c38249bab4562ef535ef07f5eb6eb04d0b1b/propcache-0.4.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9a52009f2adffe195d0b605c25ec929d26b36ef986ba85244891dee3b294df21", size = 201012, upload-time = "2025-10-08T19:46:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/5b/01/f1d0b57d136f294a142acf97f4ed58c8e5b974c21e543000968357115011/propcache-0.4.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5d4e2366a9c7b837555cf02fb9be2e3167d333aff716332ef1b7c3a142ec40c5", size = 209491, upload-time = "2025-10-08T19:46:08.909Z" }, + { url = "https://files.pythonhosted.org/packages/a1/c8/038d909c61c5bb039070b3fb02ad5cccdb1dde0d714792e251cdb17c9c05/propcache-0.4.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9d2b6caef873b4f09e26ea7e33d65f42b944837563a47a94719cc3544319a0db", size = 215319, upload-time = "2025-10-08T19:46:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/08/57/8c87e93142b2c1fa2408e45695205a7ba05fb5db458c0bf5c06ba0e09ea6/propcache-0.4.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b16ec437a8c8a965ecf95739448dd938b5c7f56e67ea009f4300d8df05f32b7", size = 196856, upload-time = "2025-10-08T19:46:12.003Z" }, + { url = "https://files.pythonhosted.org/packages/42/df/5615fec76aa561987a534759b3686008a288e73107faa49a8ae5795a9f7a/propcache-0.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:296f4c8ed03ca7476813fe666c9ea97869a8d7aec972618671b33a38a5182ef4", size = 193241, upload-time = "2025-10-08T19:46:13.495Z" }, + { url = "https://files.pythonhosted.org/packages/d5/21/62949eb3a7a54afe8327011c90aca7e03547787a88fb8bd9726806482fea/propcache-0.4.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1f0978529a418ebd1f49dad413a2b68af33f85d5c5ca5c6ca2a3bed375a7ac60", size = 190552, upload-time = "2025-10-08T19:46:14.938Z" }, + { url = "https://files.pythonhosted.org/packages/30/ee/ab4d727dd70806e5b4de96a798ae7ac6e4d42516f030ee60522474b6b332/propcache-0.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fd138803047fb4c062b1c1dd95462f5209456bfab55c734458f15d11da288f8f", size = 200113, upload-time = "2025-10-08T19:46:16.695Z" }, + { url = "https://files.pythonhosted.org/packages/8a/0b/38b46208e6711b016aa8966a3ac793eee0d05c7159d8342aa27fc0bc365e/propcache-0.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8c9b3cbe4584636d72ff556d9036e0c9317fa27b3ac1f0f558e7e84d1c9c5900", size = 200778, upload-time = "2025-10-08T19:46:18.023Z" }, + { url = "https://files.pythonhosted.org/packages/cf/81/5abec54355ed344476bee711e9f04815d4b00a311ab0535599204eecc257/propcache-0.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f93243fdc5657247533273ac4f86ae106cc6445a0efacb9a1bfe982fcfefd90c", size = 193047, upload-time = "2025-10-08T19:46:19.449Z" }, + { url = "https://files.pythonhosted.org/packages/ec/b6/1f237c04e32063cb034acd5f6ef34ef3a394f75502e72703545631ab1ef6/propcache-0.4.1-cp310-cp310-win32.whl", hash = "sha256:a0ee98db9c5f80785b266eb805016e36058ac72c51a064040f2bc43b61101cdb", size = 38093, upload-time = "2025-10-08T19:46:20.643Z" }, + { url = "https://files.pythonhosted.org/packages/a6/67/354aac4e0603a15f76439caf0427781bcd6797f370377f75a642133bc954/propcache-0.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:1cdb7988c4e5ac7f6d175a28a9aa0c94cb6f2ebe52756a3c0cda98d2809a9e37", size = 41638, upload-time = "2025-10-08T19:46:21.935Z" }, + { url = "https://files.pythonhosted.org/packages/e0/e1/74e55b9fd1a4c209ff1a9a824bf6c8b3d1fc5a1ac3eabe23462637466785/propcache-0.4.1-cp310-cp310-win_arm64.whl", hash = "sha256:d82ad62b19645419fe79dd63b3f9253e15b30e955c0170e5cebc350c1844e581", size = 38229, upload-time = "2025-10-08T19:46:23.368Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" }, + { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" }, + { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" }, + { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" }, + { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" }, + { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" }, + { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" }, + { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" }, + { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" }, + { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" }, + { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" }, + { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" }, + { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" }, + { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" }, + { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" }, + { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" }, + { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" }, + { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" }, + { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" }, + { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" }, + { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" }, + { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" }, + { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" }, + { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" }, + { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" }, + { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" }, + { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" }, + { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" }, + { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" }, + { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" }, + { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" }, + { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" }, + { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" }, + { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" }, + { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" }, + { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" }, + { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" }, + { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" }, + { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" }, + { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" }, + { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" }, + { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" }, + { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" }, + { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" }, + { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" }, + { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" }, + { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" }, + { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" }, + { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" }, + { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" }, + { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" }, + { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" }, + { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" }, + { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" }, + { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" }, + { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" }, + { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" }, + { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" }, + { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" }, + { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" }, + { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" }, + { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" }, + { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" }, + { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" }, + { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" }, +] + +[[package]] +name = "pydantic" +version = "2.12.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" }, + { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" }, + { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" }, + { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" }, + { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" }, + { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" }, + { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" }, + { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" }, + { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" }, + { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" }, + { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" }, + { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" }, + { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" }, + { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" }, + { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" }, + { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" }, + { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" }, + { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, + { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, + { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" }, + { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" }, + { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" }, + { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" }, + { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" }, + { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" }, + { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" }, + { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, + { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, + { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" }, + { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" }, + { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, + { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, + { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" }, + { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" }, + { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" }, + { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" }, + { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" }, + { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" }, + { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" }, + { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" }, + { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" }, + { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" }, + { 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.13.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +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 = "pytest" +version = "9.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, +] + +[[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.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { 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 = "rich" +version = "14.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" } +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 = "ruff" +version = "0.15.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/df/f8629c19c5318601d3121e230f74cbee7a3732339c52b21daa2b82ef9c7d/ruff-0.15.6.tar.gz", hash = "sha256:8394c7bb153a4e3811a4ecdacd4a8e6a4fa8097028119160dffecdcdf9b56ae4", size = 4597916, upload-time = "2026-03-12T23:05:47.51Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/2f/4e03a7e5ce99b517e98d3b4951f411de2b0fa8348d39cf446671adcce9a2/ruff-0.15.6-py3-none-linux_armv6l.whl", hash = "sha256:7c98c3b16407b2cf3d0f2b80c80187384bc92c6774d85fefa913ecd941256fff", size = 10508953, upload-time = "2026-03-12T23:05:17.246Z" }, + { url = "https://files.pythonhosted.org/packages/70/60/55bcdc3e9f80bcf39edf0cd272da6fa511a3d94d5a0dd9e0adf76ceebdb4/ruff-0.15.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ee7dcfaad8b282a284df4aa6ddc2741b3f4a18b0555d626805555a820ea181c3", size = 10942257, upload-time = "2026-03-12T23:05:23.076Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/005c29bd1726c0f492bfa215e95154cf480574140cb5f867c797c18c790b/ruff-0.15.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3bd9967851a25f038fc8b9ae88a7fbd1b609f30349231dffaa37b6804923c4bb", size = 10322683, upload-time = "2026-03-12T23:05:33.738Z" }, + { url = "https://files.pythonhosted.org/packages/5f/74/2f861f5fd7cbb2146bddb5501450300ce41562da36d21868c69b7a828169/ruff-0.15.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13f4594b04e42cd24a41da653886b04d2ff87adbf57497ed4f728b0e8a4866f8", size = 10660986, upload-time = "2026-03-12T23:05:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/c1/a1/309f2364a424eccb763cdafc49df843c282609f47fe53aa83f38272389e0/ruff-0.15.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e2ed8aea2f3fe57886d3f00ea5b8aae5bf68d5e195f487f037a955ff9fbaac9e", size = 10332177, upload-time = "2026-03-12T23:05:56.145Z" }, + { url = "https://files.pythonhosted.org/packages/30/41/7ebf1d32658b4bab20f8ac80972fb19cd4e2c6b78552be263a680edc55ac/ruff-0.15.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70789d3e7830b848b548aae96766431c0dc01a6c78c13381f423bf7076c66d15", size = 11170783, upload-time = "2026-03-12T23:06:01.742Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/6d488f6adca047df82cd62c304638bcb00821c36bd4881cfca221561fdfc/ruff-0.15.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:542aaf1de3154cea088ced5a819ce872611256ffe2498e750bbae5247a8114e9", size = 12044201, upload-time = "2026-03-12T23:05:28.697Z" }, + { url = "https://files.pythonhosted.org/packages/71/68/e6f125df4af7e6d0b498f8d373274794bc5156b324e8ab4bf5c1b4fc0ec7/ruff-0.15.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c22e6f02c16cfac3888aa636e9eba857254d15bbacc9906c9689fdecb1953ab", size = 11421561, upload-time = "2026-03-12T23:05:31.236Z" }, + { url = "https://files.pythonhosted.org/packages/f1/9f/f85ef5fd01a52e0b472b26dc1b4bd228b8f6f0435975442ffa4741278703/ruff-0.15.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98893c4c0aadc8e448cfa315bd0cc343a5323d740fe5f28ef8a3f9e21b381f7e", size = 11310928, upload-time = "2026-03-12T23:05:45.288Z" }, + { url = "https://files.pythonhosted.org/packages/8c/26/b75f8c421f5654304b89471ed384ae8c7f42b4dff58fa6ce1626d7f2b59a/ruff-0.15.6-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:70d263770d234912374493e8cc1e7385c5d49376e41dfa51c5c3453169dc581c", size = 11235186, upload-time = "2026-03-12T23:05:50.677Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d4/d5a6d065962ff7a68a86c9b4f5500f7d101a0792078de636526c0edd40da/ruff-0.15.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:55a1ad63c5a6e54b1f21b7514dfadc0c7fb40093fa22e95143cf3f64ebdcd512", size = 10635231, upload-time = "2026-03-12T23:05:37.044Z" }, + { url = "https://files.pythonhosted.org/packages/d6/56/7c3acf3d50910375349016cf33de24be021532042afbed87942858992491/ruff-0.15.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8dc473ba093c5ec238bb1e7429ee676dca24643c471e11fbaa8a857925b061c0", size = 10340357, upload-time = "2026-03-12T23:06:04.748Z" }, + { url = "https://files.pythonhosted.org/packages/06/54/6faa39e9c1033ff6a3b6e76b5df536931cd30caf64988e112bbf91ef5ce5/ruff-0.15.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:85b042377c2a5561131767974617006f99f7e13c63c111b998f29fc1e58a4cfb", size = 10860583, upload-time = "2026-03-12T23:05:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/509a201b843b4dfb0b32acdedf68d951d3377988cae43949ba4c4133a96a/ruff-0.15.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:cef49e30bc5a86a6a92098a7fbf6e467a234d90b63305d6f3ec01225a9d092e0", size = 11410976, upload-time = "2026-03-12T23:05:39.955Z" }, + { url = "https://files.pythonhosted.org/packages/6c/25/3fc9114abf979a41673ce877c08016f8e660ad6cf508c3957f537d2e9fa9/ruff-0.15.6-py3-none-win32.whl", hash = "sha256:bbf67d39832404812a2d23020dda68fee7f18ce15654e96fb1d3ad21a5fe436c", size = 10616872, upload-time = "2026-03-12T23:05:42.451Z" }, + { url = "https://files.pythonhosted.org/packages/89/7a/09ece68445ceac348df06e08bf75db72d0e8427765b96c9c0ffabc1be1d9/ruff-0.15.6-py3-none-win_amd64.whl", hash = "sha256:aee25bc84c2f1007ecb5037dff75cef00414fdf17c23f07dc13e577883dca406", size = 11787271, upload-time = "2026-03-12T23:05:20.168Z" }, + { url = "https://files.pythonhosted.org/packages/7f/d0/578c47dd68152ddddddf31cd7fc67dc30b7cdf639a86275fda821b0d9d98/ruff-0.15.6-py3-none-win_arm64.whl", hash = "sha256:c34de3dd0b0ba203be50ae70f5910b17188556630e2178fd7d79fc030eb0d837", size = 11060497, upload-time = "2026-03-12T23:05:25.968Z" }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +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 = "smmap" +version = "5.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/ea/49c993d6dfdd7338c9b1000a0f36817ed7ec84577ae2e52f890d1a4ff909/smmap-5.0.3.tar.gz", hash = "sha256:4d9debb8b99007ae47165abc08670bd74cb74b5227dda7f643eccc4e9eb5642c", size = 22506, upload-time = "2026-03-09T03:43:26.1Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl", hash = "sha256:c106e05d5a61449cf6ba9a1e650227ecfb141590d2a98412103ff35d89fc7b2f", size = 24390, upload-time = "2026-03-09T03:43:24.361Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" }, + { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" }, + { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" }, + { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" }, + { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" }, + { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" }, + { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" }, + { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" }, + { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" }, + { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" }, + { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" }, + { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" }, + { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" }, + { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" }, + { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" }, + { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" }, + { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" }, + { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" }, + { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" }, + { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" }, + { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" }, + { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" }, + { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" }, + { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" }, + { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" }, + { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" }, + { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" }, + { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" }, + { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" }, + { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" }, + { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" }, + { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" }, + { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" }, + { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" }, + { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" }, + { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" }, + { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" }, + { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" }, + { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" }, + { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" }, +] + +[[package]] +name = "typer" +version = "0.24.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +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 = "urllib3" +version = "2.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, +] + +[[package]] +name = "yarl" +version = "1.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" }, + { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" }, + { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" }, + { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" }, + { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" }, + { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" }, + { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" }, + { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" }, + { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" }, + { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" }, + { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" }, + { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" }, + { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" }, + { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" }, + { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" }, + { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" }, + { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" }, + { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" }, + { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" }, + { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" }, + { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" }, + { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" }, + { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" }, + { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" }, + { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" }, + { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" }, + { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" }, + { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" }, + { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" }, + { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" }, + { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" }, + { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" }, + { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" }, + { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" }, + { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" }, + { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" }, + { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" }, + { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" }, + { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" }, + { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" }, + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" }, + { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" }, + { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" }, + { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" }, + { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" }, + { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" }, + { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" }, + { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" }, + { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" }, + { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" }, + { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" }, + { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" }, + { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" }, + { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" }, + { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" }, + { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" }, + { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" }, + { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" }, + { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" }, + { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" }, + { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" }, + { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" }, + { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" }, + { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" }, + { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" }, + { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" }, + { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" }, + { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" }, + { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" }, + { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" }, + { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" }, + { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" }, + { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" }, + { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" }, + { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" }, + { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" }, + { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" }, + { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" }, + { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" }, + { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" }, + { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" }, + { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" }, + { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" }, + { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" }, + { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" }, + { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" }, + { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" }, + { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" }, + { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" }, + { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" }, + { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" }, + { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" }, + { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" }, + { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" }, + { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" }, + { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" }, + { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" }, + { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" }, + { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" }, + { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" }, + { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" }, + { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" }, + { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" }, + { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" }, + { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" }, + { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" }, + { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" }, + { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" }, + { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" }, +] From 4a0662a31e4f9f0a5e61c6f80b3fa18ad51805b1 Mon Sep 17 00:00:00 2001 From: Ben Date: Tue, 17 Mar 2026 11:50:32 -0400 Subject: [PATCH 2/3] chore: remove n8n blog post, add Agno icon, bind to release process - Remove n8n blog post from the agno integration branch - Add Agno logo icon and map hindsight-agno SDK tag in CookbookGrid - Add hindsight-agno to release.sh PYTHON_PACKAGES array - Add build, publish, artifact upload, and release asset steps in release.yml Co-Authored-By: Claude Opus 4.6 --- .github/workflows/release.yml | 12 + .../blog/2026-03-16-n8n-memory-workflows.md | 280 ------------------ .../src/components/CookbookGrid.tsx | 3 + .../static/img/blog/n8n-memory-workflows.png | Bin 184350 -> 0 bytes hindsight-docs/static/img/icons/agno.png | Bin 0 -> 8404 bytes scripts/release.sh | 4 +- 6 files changed, 17 insertions(+), 282 deletions(-) delete mode 100644 hindsight-docs/blog/2026-03-16-n8n-memory-workflows.md delete mode 100644 hindsight-docs/static/img/blog/n8n-memory-workflows.png create mode 100644 hindsight-docs/static/img/icons/agno.png diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index dfceb22ac..bed3dea36 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -66,6 +66,10 @@ jobs: working-directory: ./hindsight-integrations/hermes run: uv build --out-dir dist + - name: Build hindsight-agno + working-directory: ./hindsight-integrations/agno + run: uv build --out-dir dist + # Publish in order (client and api-slim first, then api/all wrappers which depend on them) - name: Publish hindsight-client to PyPI uses: pypa/gh-action-pypi-publish@release/v1 @@ -127,6 +131,12 @@ jobs: packages-dir: ./hindsight-integrations/hermes/dist skip-existing: true + - name: Publish hindsight-agno to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + packages-dir: ./hindsight-integrations/agno/dist + skip-existing: true + # Upload artifacts for GitHub release - name: Upload artifacts uses: actions/upload-artifact@v7 @@ -143,6 +153,7 @@ jobs: hindsight-integrations/crewai/dist/* hindsight-integrations/pydantic-ai/dist/* hindsight-integrations/hermes/dist/* + hindsight-integrations/agno/dist/* retention-days: 1 release-typescript-client: @@ -681,6 +692,7 @@ jobs: cp artifacts/python-packages/hindsight-integrations/litellm/dist/* release-assets/ || true cp artifacts/python-packages/hindsight-integrations/pydantic-ai/dist/* release-assets/ || true cp artifacts/python-packages/hindsight-integrations/hermes/dist/* release-assets/ || true + cp artifacts/python-packages/hindsight-integrations/agno/dist/* release-assets/ || true cp artifacts/python-packages/hindsight-embed/dist/* release-assets/ || true # TypeScript client cp artifacts/typescript-client/*.tgz release-assets/ || true diff --git a/hindsight-docs/blog/2026-03-16-n8n-memory-workflows.md b/hindsight-docs/blog/2026-03-16-n8n-memory-workflows.md deleted file mode 100644 index 01a6cd83c..000000000 --- a/hindsight-docs/blog/2026-03-16-n8n-memory-workflows.md +++ /dev/null @@ -1,280 +0,0 @@ ---- -title: "3 Nodes. Zero Code. Persistent Memory for n8n Workflows" -authors: [benfrank241] -date: 2026-03-16 -tags: [n8n, tutorial, workflow, memory, no-code] -image: /img/blog/n8n-memory-workflows.png ---- - -![How to Add Persistent Memory to n8n Workflows](/img/blog/n8n-memory-workflows.png) - -n8n workflows are stateless — every execution starts from zero. [Hindsight](https://ui.hindsight.vectorize.io/signup) adds persistent n8n memory via three HTTP Request nodes. No custom nodes, no vector database, no code. - - - -**TL;DR:** -- n8n workflows are stateless — every execution starts from zero -- Hindsight adds persistent memory via three HTTP Request nodes -- No custom nodes, no vector database, no code -- Works with Hindsight Cloud (zero setup) or self-hosted -- Retain customer interactions, recall relevant context, reflect for synthesis -- Works with any [n8n](https://n8n.io/) workflow: support bots, lead enrichment, onboarding sequences - -## The problem: n8n workflows without memory - -You build an n8n workflow that handles customer support tickets. It triages, responds, escalates. It works. - -But every execution is isolated. - -Ticket comes in from Alice. Your workflow doesn't know Alice called last week about the same issue. Doesn't know she's on the Enterprise plan. Doesn't know she prefers email. - -You could store this in a database. But then you need: - -- A schema for every fact type -- Queries for every retrieval pattern -- Logic to decide what's relevant - -That's not a workflow anymore. That's a backend project. - -What you actually need: store facts as they happen, retrieve what's relevant, and synthesize when asked. Without leaving n8n. - -## Architecture: three nodes for n8n persistent memory - -``` -Trigger (webhook, schedule, etc.) - ↓ -Retain — POST to Hindsight, store the interaction - ↓ -Your workflow logic - ↓ -Recall — POST to Hindsight, get relevant past context - ↓ -AI node / response — use memory to personalize -``` - -Three [HTTP Request nodes](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/). Same workflow structure you already use. - -Under the hood, Hindsight automatically extracts entities and relationships from your content, builds a [knowledge graph with semantic search](/blog/2026/03/12/spreading-activation-memory-graphs), and returns relevant facts when you query. You don't manage any of that — it's handled by the three API calls below. - -## Setting up Hindsight and n8n - -### Start Hindsight - -You have two options: Hindsight Cloud (no setup) or self-hosted (run it yourself). - -**Option A: Hindsight Cloud** - -1. [Sign up at Hindsight Cloud](https://ui.hindsight.vectorize.io/signup) -2. Create a memory bank in the dashboard and copy your API key -3. Your base URL is `https://api.hindsight.vectorize.io` and all requests need an `Authorization: Bearer hsk_your-key-here` header. - -This is the easiest path if you're using n8n Cloud, since n8n Cloud can't reach localhost. Hindsight Cloud gives you a public API endpoint with no infrastructure to manage. - -**Option B: Self-hosted** - -Install and start the memory server: - -```bash -pip install hindsight-all -export HINDSIGHT_API_LLM_API_KEY=YOUR_OPENAI_KEY - -hindsight-api -``` - -It runs at `http://localhost:8888`. Embedded Postgres, fact extraction, semantic search, knowledge graph — all included. - -### Create a memory bank - -If you're using Hindsight Cloud, create a bank in the dashboard. For self-hosted, create one via the API: - -```bash -curl -X PUT http://localhost:8888/v1/default/banks/n8n-workflow \ - -H "Content-Type: application/json" \ - -d '{ - "name": "n8n Workflow Memory", - "mission": "Remember customer interactions and workflow context." - }' -``` - -This is idempotent — safe to run multiple times. - -### Start n8n - -```bash -npx n8n -``` - -Open `http://localhost:5678` and create a new workflow. - -## The three n8n memory operations: retain, recall, reflect - -### Retain — store interactions as they happen - -Add an [HTTP Request node](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/) after your trigger: - -- **Method**: POST -- **URL**: - - Cloud: `https://api.hindsight.vectorize.io/v1/default/banks/n8n-workflow/memories` - - Self-hosted: `http://YOUR_IP:8888/v1/default/banks/n8n-workflow/memories` -- **Send Body**: on -- **Body Content Type**: JSON -- **Specify Body**: Using JSON -- **JSON**: - -```json -{"items": [{"content": "Customer Bob prefers email communication and is on the Enterprise plan."}]} -``` - -If you're using Hindsight Cloud, add an Authorization header: `Bearer hsk_your-key-here`. In the HTTP Request node, go to **Options → Headers** and add it. - -> **Self-hosted gotcha**: Use your machine's IP address (e.g., `192.168.x.x`), not `localhost`. n8n resolves `localhost` to its own process. Find your IP with `ipconfig getifaddr en0` (macOS) or `hostname -I` (Linux). This doesn't apply if you're using Hindsight Cloud or n8n Cloud. - -Click **Execute step**. You should get a success response: - -```json -{ - "success": true, - "bank_id": "n8n-workflow", - "items_count": 1, - "async": false -} -``` - -Hindsight extracts facts from the content automatically — entities, relationships, timestamps. You don't manage any of that. - -### Recall — retrieve relevant context - -Add another HTTP Request node: - -- **Method**: POST -- **URL**: - - Cloud: `https://api.hindsight.vectorize.io/v1/default/banks/n8n-workflow/memories/recall` - - Self-hosted: `http://YOUR_IP:8888/v1/default/banks/n8n-workflow/memories/recall` -- **JSON**: - -```json -{"query": "What do we know about Bob?", "budget": "low"} -``` - -Click **Execute step**. You'll see extracted facts come back: - -```json -{ - "results": [ - { - "text": "Bob prefers email communication and is subscribed to the Enterprise plan.", - "type": "world", - "entities": ["Bob"] - } - ] -} -``` - -This is what you inject into your AI node's system prompt to personalize responses. - -### Reflect — synthesize across all memories - -For synthesis questions — "summarize this customer" or "what patterns do we see" — use reflect: - -- **Method**: POST -- **URL**: - - Cloud: `https://api.hindsight.vectorize.io/v1/default/banks/n8n-workflow/reflect` - - Self-hosted: `http://YOUR_IP:8888/v1/default/banks/n8n-workflow/reflect` -- **JSON**: - -```json -{"query": "Summarize what we know about our customers"} -``` - -Reflect traverses the knowledge graph and reasons across all stored memories. It's slower than recall but produces synthesized analysis, not just raw facts. - -## Making n8n memory dynamic - -The examples above use hardcoded JSON. In a real workflow, you'd use [n8n expressions](https://docs.n8n.io/code/expressions/) to inject dynamic data. - -For **retain**, wire in data from your trigger: - -```json -{"items": [{"content": "{{ $json.customer_name }} submitted a {{ $json.ticket_type }} ticket: {{ $json.message }}"}]} -``` - -For **recall**, query based on the current customer: - -```json -{"query": "What do we know about {{ $json.customer_name }}?", "budget": "low"} -``` - -For **reflect**, ask for a synthesis: - -```json -{"query": "Summarize all interactions with {{ $json.customer_name }}"} -``` - -n8n expressions make the memory layer dynamic without writing code. - -## Example: support bot with n8n memory - -Here's a practical workflow: - -1. **Webhook trigger** — receives incoming support message -2. **Recall node** — retrieves relevant past context for this customer -3. **AI node** (OpenAI, Anthropic, etc.) — generates response with memory in the system prompt -4. **Retain node** — stores the interaction for future reference -5. **Respond to Webhook** — sends the reply - -The AI node gets a system prompt like: - -``` -You are a support agent. Here is what you know about this customer: -{{ $('Recall').item.json.results[0].text }} -``` - -Now your support bot remembers past conversations, knows customer preferences, and doesn't ask the same questions twice. You can further customize how the agent reasons about that context using [disposition traits](/blog/2026/03/13/disposition-aware-agents) — for example, making it more empathetic for support or more skeptical for fraud detection. - -## Pitfalls and edge cases - -1. **Use your machine IP, not localhost** (self-hosted only). n8n can't reach `localhost:8888` because it resolves to itself. Use `ipconfig getifaddr en0` (macOS) or `hostname -I` (Linux) to find your LAN IP. If you're using Hindsight Cloud, this isn't an issue — just use `https://api.hindsight.vectorize.io`. - -2. **Retain is asynchronous.** Fact extraction happens in the background after the API returns. If you recall immediately after retaining, the new facts may not be available yet. Add a short delay or design your workflow so recall happens on subsequent executions. - -3. **The retain endpoint is `/memories`, not `/memories/retain`.** The URL path is `POST /v1/default/banks/{bank_id}/memories` with an `items` array in the body. The Python client method is called `retain()` but the HTTP endpoint is different. - -4. **Bank creation uses PUT, not POST.** `PUT /v1/default/banks/{bank_id}` — the bank ID is in the URL path, not the request body. - -5. **Set Content-Type explicitly.** n8n's HTTP Request node handles this when you select JSON body content type, but if you switch modes or use expressions, make sure the header is set. - -## Tradeoffs: n8n memory with Hindsight vs. a database - -| | **Hindsight + n8n** | **Database + custom queries** | -|---|---|---| -| **Setup** | Three HTTP nodes | Schema design, migration, query logic | -| **What it stores** | Natural language facts | Structured records | -| **Retrieval** | Semantic search | Exact match / SQL | -| **Synthesis** | Built-in (reflect) | Build it yourself | -| **Maintenance** | Zero | Schema evolution, query tuning | - -**Use Hindsight when**: you want natural language memory without building a backend — customer context, conversation history, learned preferences. - -**Use a database when**: you need structured records with exact lookups — order IDs, account balances, inventory counts. - -They complement each other. Use Hindsight for the fuzzy, contextual knowledge. Use your database for the structured data. - -## Recap - -- Three HTTP Request nodes give your n8n workflows persistent memory -- **Retain** (`POST /memories`) — store interactions as they happen -- **Recall** (`POST /memories/recall`) — retrieve relevant context before responding -- **Reflect** (`POST /reflect`) — synthesize across all stored memories -- Works with both [Hindsight Cloud](https://ui.hindsight.vectorize.io/signup) and self-hosted -- Use n8n expressions to make it dynamic - -## Next steps - -- **Add per-customer banks** — use a different `bank_id` per customer for full isolation -- **Use tags for scoped memory** — add `"tags": ["support"]` on retain, filter with `"tags": ["support"]` on recall -- **Wire recall into AI nodes** — inject memory context into system prompts for personalized responses -- **Try the hosted version** — [use Hindsight Cloud](https://ui.hindsight.vectorize.io/signup) instead of self-hosting -- **Explore the MCP server** — Hindsight also exposes an MCP endpoint at `/mcp/{bank_id}/` for tools that support it -- **Read the docs** — see the [full Hindsight API reference](https://docs.hindsight.vectorize.io/recall) for advanced features - -Your workflows just got a long-term memory. No code required. diff --git a/hindsight-docs/src/components/CookbookGrid.tsx b/hindsight-docs/src/components/CookbookGrid.tsx index 102b64598..31728abcd 100644 --- a/hindsight-docs/src/components/CookbookGrid.tsx +++ b/hindsight-docs/src/components/CookbookGrid.tsx @@ -27,6 +27,9 @@ function sdkIcon(sdk: string): string | null { if (sdk.includes('hermes')) { return '/img/icons/hermes.png'; } + if (sdk.includes('agno')) { + return '/img/icons/agno.png'; + } if (sdk.includes('hindsight-client') || sdk.includes('hindsight-api') || sdk.includes('litellm') || sdk.includes('pydantic') || sdk.includes('crewai')) { return '/img/icons/python.svg'; } diff --git a/hindsight-docs/static/img/blog/n8n-memory-workflows.png b/hindsight-docs/static/img/blog/n8n-memory-workflows.png deleted file mode 100644 index 86b429139f83fe2e0db612ad828a93dc27cc67b0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 184350 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 diff --git a/hindsight-docs/static/img/icons/agno.png b/hindsight-docs/static/img/icons/agno.png new file mode 100644 index 0000000000000000000000000000000000000000..c0580db284be1571ab001caa8361d8b3df768dcb GIT binary patch literal 8404 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 OYd~E^OSwYPJn(<2+r3Z# literal 0 HcmV?d00001 diff --git a/scripts/release.sh b/scripts/release.sh index 2e036951c..3c8fd448c 100755 --- a/scripts/release.sh +++ b/scripts/release.sh @@ -65,7 +65,7 @@ fi print_info "Updating version in all components..." # Update Python packages -PYTHON_PACKAGES=("hindsight-api" "hindsight-api-slim" "hindsight-all-slim" "hindsight-dev" "hindsight-all" "hindsight-integrations/litellm" "hindsight-integrations/crewai" "hindsight-integrations/pydantic-ai" "hindsight-integrations/hermes" "hindsight-embed") +PYTHON_PACKAGES=("hindsight-api" "hindsight-api-slim" "hindsight-all-slim" "hindsight-dev" "hindsight-all" "hindsight-integrations/litellm" "hindsight-integrations/crewai" "hindsight-integrations/pydantic-ai" "hindsight-integrations/hermes" "hindsight-integrations/agno" "hindsight-embed") for package in "${PYTHON_PACKAGES[@]}"; do PYPROJECT_FILE="$package/pyproject.toml" if [ -f "$PYPROJECT_FILE" ]; then @@ -216,7 +216,7 @@ COMMIT_MSG="Release v$VERSION - Update version to $VERSION in all components - Regenerate OpenAPI spec and client SDKs -- Python packages: hindsight-api, hindsight-dev, hindsight-all, hindsight-litellm, hindsight-crewai, hindsight-pydantic-ai, hindsight-hermes, hindsight-embed +- Python packages: hindsight-api, hindsight-dev, hindsight-all, hindsight-litellm, hindsight-crewai, hindsight-pydantic-ai, hindsight-hermes, hindsight-agno, hindsight-embed - Python client: hindsight-clients/python - TypeScript client: hindsight-clients/typescript - Rust CLI: hindsight-cli From 1405fea61a6e885eeae388202ea2bee4a2974267 Mon Sep 17 00:00:00 2001 From: Ben Date: Tue, 17 Mar 2026 13:14:10 -0400 Subject: [PATCH 3/3] chore: remove cookbook page (moved to hindsight-cookbook repo) The Agno cookbook application now lives in vectorize-io/hindsight-cookbook/applications/agno-memory. Co-Authored-By: Claude Opus 4.6 --- .../cookbook/applications/agno-memory.md | 322 ------------------ hindsight-docs/src/pages/cookbook/index.mdx | 6 - 2 files changed, 328 deletions(-) delete mode 100644 hindsight-docs/src/pages/cookbook/applications/agno-memory.md diff --git a/hindsight-docs/src/pages/cookbook/applications/agno-memory.md b/hindsight-docs/src/pages/cookbook/applications/agno-memory.md deleted file mode 100644 index c114b20fc..000000000 --- a/hindsight-docs/src/pages/cookbook/applications/agno-memory.md +++ /dev/null @@ -1,322 +0,0 @@ ---- -sidebar_position: 16 ---- - -# Agno + Hindsight Memory - -:::info Complete Application -This is a complete, runnable application demonstrating Hindsight integration. -[**View source on GitHub →**](https://github.com/vectorize-io/hindsight/tree/main/hindsight-integrations/agno) -::: - -Give your Agno agents persistent long-term memory. Build agents that remember users across conversations, learn preferences over time, and synthesize insights from past interactions. - -## What This Demonstrates - -- **Native Toolkit pattern** — retain, recall, and reflect registered as Agno tools via `HindsightTools` -- **Auto-injected context** — pre-recalled memories in the system prompt via `memory_instructions()` -- **Per-user memory banks** — automatic bank isolation using `RunContext.user_id` -- **Progressive learning** — the agent gets smarter with each interaction - -## Architecture - -``` -Run 1 (user: alice): - Alice: "I'm a vegetarian and I prefer window seats on flights" - │ - ├─ memory_instructions() ──► recalls prior context (empty on first run) - ├─ Agent calls retain_memory ──► stores preferences - └─ Agent responds with acknowledgement - -Run 2 (user: alice): - Alice: "Help me plan a trip to Tokyo" - │ - ├─ memory_instructions() ──► injects "User is vegetarian, prefers window seats..." - ├─ Agent calls recall_memory ──► finds dietary + travel preferences - └─ Agent recommends vegetarian restaurants, books window seats - -Run 3 (user: bob): - Bob: "What do you know about me?" - │ - ├─ memory_instructions() ──► recalls Bob's context (empty — separate bank) - └─ Agent responds that it doesn't have any info about Bob yet -``` - -Each user gets their own memory bank, so Alice's preferences never leak into Bob's conversations. - -## Prerequisites - -1. **Hindsight running** - - ```bash - export OPENAI_API_KEY=your-key - - docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \ - -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \ - -e HINDSIGHT_API_LLM_MODEL=o3-mini \ - -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \ - ghcr.io/vectorize-io/hindsight:latest - ``` - -2. **OpenAI API key** (for Agno's LLM) - - ```bash - export OPENAI_API_KEY=your-key - ``` - -3. **Install dependencies** - - ```bash - pip install hindsight-agno agno openai - ``` - -## Quick Start - -### Minimal Example - -```python -from agno.agent import Agent -from agno.models.openai import OpenAIChat -from hindsight_agno import HindsightTools - -agent = Agent( - model=OpenAIChat(id="gpt-4o-mini"), - tools=[HindsightTools( - bank_id="my-assistant", - hindsight_api_url="http://localhost:8888", - )], - markdown=True, -) - -# Store something -agent.print_response("Remember that I prefer dark mode and use vim") - -# Recall it -agent.print_response("What are my preferences?") -``` - -Run it twice — the agent still remembers on the second run. - -### Travel Planner with Per-User Memory - -A more realistic example: a travel planning agent that learns each user's preferences. - -```python -from agno.agent import Agent -from agno.models.openai import OpenAIChat -from hindsight_agno import HindsightTools, memory_instructions - -HINDSIGHT_URL = "http://localhost:8888" -USER_ID = "alice" - -# Pre-recall relevant memories for the system prompt -memories = memory_instructions( - bank_id=USER_ID, - hindsight_api_url=HINDSIGHT_URL, - query="travel preferences, dietary restrictions, and past trips", - max_results=10, -) - -agent = Agent( - model=OpenAIChat(id="gpt-4o-mini"), - tools=[HindsightTools( - bank_id=USER_ID, - hindsight_api_url=HINDSIGHT_URL, - )], - instructions=[ - "You are a travel planning assistant with long-term memory.", - "Remember user preferences (diet, seating, budget, interests) for future trips.", - "When planning trips, check memory first for relevant preferences.", - memories, - ], - markdown=True, -) - -# First run: share preferences -agent.print_response( - "I'm vegetarian, I prefer window seats, and my budget is mid-range. " - "I love museums and street food." -) - -# Second run: the agent uses stored preferences -agent.print_response("Plan a 3-day trip to Tokyo for me") -``` - -### Dynamic Per-User Banks - -When building a multi-user application, use `user_id` on the Agent to automatically isolate memory per user: - -```python -from agno.agent import Agent -from agno.models.openai import OpenAIChat -from hindsight_agno import HindsightTools - -def create_agent(user_id: str) -> Agent: - """Create an agent with per-user memory.""" - return Agent( - model=OpenAIChat(id="gpt-4o-mini"), - tools=[HindsightTools( - hindsight_api_url="http://localhost:8888", - # No bank_id — HindsightTools reads it from RunContext.user_id - )], - user_id=user_id, - markdown=True, - ) - -# Each user gets isolated memory -alice_agent = create_agent("alice") -bob_agent = create_agent("bob") - -alice_agent.print_response("I'm allergic to peanuts") -bob_agent.print_response("What am I allergic to?") -# Bob gets "No relevant memories found" — Alice's data is isolated -``` - -### Custom Bank Resolution - -For more control over bank naming, use a `bank_resolver`: - -```python -from agno.run.base import RunContext -from hindsight_agno import HindsightTools - -def resolve_bank(ctx: RunContext) -> str: - """Route to team-specific banks.""" - return f"team-{ctx.user_id}" - -tools = [HindsightTools( - bank_resolver=resolve_bank, - hindsight_api_url="http://localhost:8888", -)] -``` - -### Reflect — Disposition-Aware Reasoning - -The `reflect_on_memory` tool goes beyond simple retrieval. It synthesizes a reasoned answer using the bank's disposition traits (skepticism, literalism, empathy): - -```python -agent.print_response( - "Based on everything you know about me, what kind of vacation " - "would I enjoy most and why?" -) -# The agent calls reflect_on_memory, which synthesizes an answer -# from all stored facts using the bank's configured personality -``` - -## How It Works - -### 1. Create the Toolkit - -`HindsightTools` extends Agno's `Toolkit` base class — the same pattern used by `Mem0Tools`: - -```python -from hindsight_agno import HindsightTools - -toolkit = HindsightTools( - bank_id="my-bank", - hindsight_api_url="http://localhost:8888", - budget="mid", # Recall/reflect thoroughness: low/mid/high - tags=["source:chat"], # Tags applied to stored memories -) -# Registers: retain_memory, recall_memory, reflect_on_memory -``` - -### 2. Pre-Recall with memory_instructions() - -For injecting context into the system prompt at agent construction time: - -```python -from hindsight_agno import memory_instructions - -context = memory_instructions( - bank_id="my-bank", - hindsight_api_url="http://localhost:8888", - query="user preferences and context", - budget="low", # Keep it fast - max_results=5, # Limit injected memories -) -# Returns a string like: -# "Relevant memories:\n\n1. User is vegetarian\n2. Prefers window seats" -``` - -### 3. Select Specific Tools - -Include only the tools you need: - -```python -toolkit = HindsightTools( - bank_id="my-bank", - hindsight_api_url="http://localhost:8888", - enable_retain=True, - enable_recall=True, - enable_reflect=False, # Omit reflect -) -``` - -## Configuration - -### Environment Variables - -| Variable | Description | -|----------|-------------| -| `HINDSIGHT_API_KEY` | API key for Hindsight Cloud or authenticated self-hosted | -| `OPENAI_API_KEY` | OpenAI API key for Agno's LLM | - -### Global Configuration - -Instead of passing connection details to every toolkit: - -```python -from hindsight_agno import configure, HindsightTools - -configure( - hindsight_api_url="http://localhost:8888", - api_key="your-api-key", - budget="mid", - tags=["env:prod"], -) - -# Now create toolkits without repeating connection details -toolkit = HindsightTools(bank_id="my-bank") -``` - -### HindsightTools Parameters - -| Parameter | Default | Description | -|-----------|---------|-------------| -| `bank_id` | `None` | Static memory bank ID | -| `bank_resolver` | `None` | `(RunContext) -> str` for dynamic bank IDs | -| `client` | `None` | Pre-configured Hindsight client | -| `hindsight_api_url` | `None` | Hindsight API URL | -| `api_key` | `None` | API key | -| `budget` | `"mid"` | Recall/reflect budget (low/mid/high) | -| `max_tokens` | `4096` | Max tokens for recall results | -| `tags` | `None` | Tags for stored memories | -| `recall_tags` | `None` | Tags to filter recall | -| `recall_tags_match` | `"any"` | Tag match mode (any/all/any_strict/all_strict) | -| `enable_retain` | `True` | Include retain tool | -| `enable_recall` | `True` | Include recall tool | -| `enable_reflect` | `True` | Include reflect tool | - -## Common Issues - -**"Connection refused"** -- Make sure Hindsight is running on `localhost:8888` - -**"OPENAI_API_KEY not set"** -```bash -export OPENAI_API_KEY=your-key -``` - -**"No Hindsight API URL configured"** -- Pass `hindsight_api_url=` to `HindsightTools`, or call `configure()` first - -**"No bank_id available"** -- Provide `bank_id=`, `bank_resolver=`, or set `user_id=` on the Agent - ---- - -**Built with:** -- [Agno](https://github.com/agno-agi/agno) - Full-stack agent framework -- [hindsight-agno](https://github.com/vectorize-io/hindsight/tree/main/hindsight-integrations/agno) - Hindsight memory toolkit for Agno -- [Hindsight](https://github.com/vectorize-io/hindsight) - Long-term memory for AI agents diff --git a/hindsight-docs/src/pages/cookbook/index.mdx b/hindsight-docs/src/pages/cookbook/index.mdx index 9759b6600..22241ce56 100644 --- a/hindsight-docs/src/pages/cookbook/index.mdx +++ b/hindsight-docs/src/pages/cookbook/index.mdx @@ -101,12 +101,6 @@ import CookbookGrid from '@site/src/components/CookbookGrid';