From 1eaae1a76ba696906a449ade176a6e01792f7066 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Monnom?= Date: Wed, 29 Apr 2026 15:47:31 -0700 Subject: [PATCH 1/7] add preconnect audio buffer API to LocalAudioTrack Adds start_preconnect_buffer/stop_preconnect_buffer/send_preconnect_buffer to LocalAudioTrack, backed by a zero-allocation circular bytearray ring buffer. Sends buffered audio via byte stream data channels using the existing lk.agent.pre-connect-audio-buffer protocol. --- livekit-rtc/livekit/rtc/__init__.py | 2 + livekit-rtc/livekit/rtc/audio_ring_buffer.py | 81 ++++++++++++++++++++ livekit-rtc/livekit/rtc/audio_source.py | 11 +++ livekit-rtc/livekit/rtc/participant.py | 53 ++++++++++++- livekit-rtc/livekit/rtc/room.py | 1 + livekit-rtc/livekit/rtc/track.py | 72 +++++++++++++++-- 6 files changed, 212 insertions(+), 8 deletions(-) create mode 100644 livekit-rtc/livekit/rtc/audio_ring_buffer.py diff --git a/livekit-rtc/livekit/rtc/__init__.py b/livekit-rtc/livekit/rtc/__init__.py index cc9c1b1e..35aa5241 100644 --- a/livekit-rtc/livekit/rtc/__init__.py +++ b/livekit-rtc/livekit/rtc/__init__.py @@ -39,6 +39,7 @@ ) from ._proto.video_frame_pb2 import VideoBufferType, VideoCodec, VideoRotation from .audio_frame import AudioFrame +from .audio_ring_buffer import AudioRingBuffer from .audio_source import AudioSource from .audio_stream import AudioFrameEvent, AudioStream, NoiseCancellationOptions from .audio_filter import AudioFilter @@ -137,6 +138,7 @@ "VideoRotation", "stats", "AudioFrame", + "AudioRingBuffer", "AudioSource", "AudioStream", "NoiseCancellationOptions", diff --git a/livekit-rtc/livekit/rtc/audio_ring_buffer.py b/livekit-rtc/livekit/rtc/audio_ring_buffer.py new file mode 100644 index 00000000..a2532208 --- /dev/null +++ b/livekit-rtc/livekit/rtc/audio_ring_buffer.py @@ -0,0 +1,81 @@ +from __future__ import annotations + +import threading + +from .audio_frame import AudioFrame + + +class AudioRingBuffer: + """Pre-allocated circular buffer for raw PCM audio data. + + Stores int16 PCM samples in a fixed-size bytearray. Push is zero-allocation. + """ + + def __init__(self, max_duration: float, sample_rate: int, num_channels: int) -> None: + self._sample_rate = sample_rate + self._num_channels = num_channels + self._bytes_per_second = sample_rate * num_channels * 2 # int16 + self._max_bytes = int(max_duration * self._bytes_per_second) + if self._max_bytes <= 0: + raise ValueError("max_duration must be positive") + + self._buf = bytearray(self._max_bytes) + self._write_pos = 0 + self._size = 0 + self._lock = threading.Lock() + + @property + def duration(self) -> float: + with self._lock: + return self._size / self._bytes_per_second + + @property + def max_duration(self) -> float: + return self._max_bytes / self._bytes_per_second + + def push(self, frame: AudioFrame) -> None: + data = frame.data.cast("b") + n = len(data) + if n == 0: + return + + with self._lock: + if n >= self._max_bytes: + # frame larger than buffer — keep only the tail + self._buf[:] = data[n - self._max_bytes :] + self._write_pos = 0 + self._size = self._max_bytes + return + + end = self._write_pos + n + if end <= self._max_bytes: + self._buf[self._write_pos : end] = data + else: + first = self._max_bytes - self._write_pos + self._buf[self._write_pos : self._max_bytes] = data[:first] + self._buf[: n - first] = data[first:] + + self._write_pos = end % self._max_bytes + self._size = min(self._size + n, self._max_bytes) + + def capture(self) -> bytes: + """Snapshot the buffer contents and reset. Returns raw PCM bytes.""" + with self._lock: + if self._size == 0: + return b"" + + read_pos = (self._write_pos - self._size) % self._max_bytes + if read_pos + self._size <= self._max_bytes: + data = bytes(self._buf[read_pos : read_pos + self._size]) + else: + first = self._max_bytes - read_pos + data = bytes(self._buf[read_pos:]) + bytes(self._buf[: self._size - first]) + + self._write_pos = 0 + self._size = 0 + return data + + def clear(self) -> None: + with self._lock: + self._write_pos = 0 + self._size = 0 diff --git a/livekit-rtc/livekit/rtc/audio_source.py b/livekit-rtc/livekit/rtc/audio_source.py index 63cc1a5d..c592ed77 100644 --- a/livekit-rtc/livekit/rtc/audio_source.py +++ b/livekit-rtc/livekit/rtc/audio_source.py @@ -16,12 +16,16 @@ import time import asyncio +from typing import TYPE_CHECKING from ._ffi_client import FfiHandle, FfiClient from ._proto import audio_frame_pb2 as proto_audio_frame from ._proto import ffi_pb2 as proto_ffi from .audio_frame import AudioFrame +if TYPE_CHECKING: + from .audio_ring_buffer import AudioRingBuffer + class AudioSource: """ @@ -69,6 +73,7 @@ def __init__( self._q_size = 0.0 self._join_handle: asyncio.TimerHandle | None = None self._join_fut: asyncio.Future[None] | None = None + self._preconnect_buffer: AudioRingBuffer | None = None @property def sample_rate(self) -> int: @@ -119,6 +124,9 @@ async def capture_frame(self, frame: AudioFrame) -> None: if frame.samples_per_channel == 0 or self._ffi_handle.disposed: return + if self._preconnect_buffer is not None: + self._preconnect_buffer.push(frame) + now = time.monotonic() elapsed = 0.0 if self._last_capture == 0.0 else now - self._last_capture self._q_size += frame.samples_per_channel / self.sample_rate - elapsed @@ -162,6 +170,9 @@ async def wait_for_playout(self) -> None: await asyncio.shield(self._join_fut) + def _set_preconnect_buffer(self, buf: AudioRingBuffer | None) -> None: + self._preconnect_buffer = buf + def _release_waiter(self) -> None: if self._join_fut is None: return # could be None when clear_queue is called diff --git a/livekit-rtc/livekit/rtc/participant.py b/livekit-rtc/livekit/rtc/participant.py index 150477d5..54d7163c 100644 --- a/livekit-rtc/livekit/rtc/participant.py +++ b/livekit-rtc/livekit/rtc/participant.py @@ -20,7 +20,7 @@ import os import mimetypes import aiofiles -from typing import List, Union, Callable, Dict, Awaitable, Optional, Mapping, cast, TypeVar +from typing import TYPE_CHECKING, List, Union, Callable, Dict, Awaitable, Optional, Mapping, cast, TypeVar from abc import abstractmethod, ABC from ._ffi_client import FfiClient, FfiHandle @@ -36,7 +36,7 @@ ParticipantTrackPermission, ) from ._utils import BroadcastQueue -from .track import LocalTrack +from .track import LocalAudioTrack, LocalTrack from .track_publication import ( LocalTrackPublication, RemoteTrackPublication, @@ -57,6 +57,9 @@ from .data_track import LocalDataTrack from ._proto import data_track_pb2 as proto_data_track +if TYPE_CHECKING: + from .room import Room + class PublishTrackError(Exception): def __init__(self, message: str) -> None: @@ -189,6 +192,7 @@ def __init__( self._room_queue = room_queue self._track_publications: dict[str, LocalTrackPublication] = {} # type: ignore self._rpc_handlers: Dict[str, RpcHandler] = {} + self._room: Room | None = None @property def track_publications(self) -> Mapping[str, LocalTrackPublication]: @@ -728,7 +732,11 @@ async def publish_data_track( return LocalDataTrack(cb.publish_data_track.track) async def publish_track( - self, track: LocalTrack, options: TrackPublishOptions = TrackPublishOptions() + self, + track: LocalTrack, + options: TrackPublishOptions = TrackPublishOptions(), + *, + preconnect_buffer_auto_send_to: str | None = None, ) -> LocalTrackPublication: """ Publish a local track to the room. @@ -736,6 +744,8 @@ async def publish_track( Args: track (LocalTrack): The track to publish. options (TrackPublishOptions, optional): Options for publishing the track. + preconnect_buffer_auto_send_to (str, optional): If set, automatically sends the + preconnect buffer when a participant with this identity becomes active. Returns: LocalTrackPublication: The publication of the published track. @@ -763,11 +773,48 @@ async def publish_track( track._info.sid = track_publication.sid self._track_publications[track_publication.sid] = track_publication + if isinstance(track, LocalAudioTrack): + track._participant = self + track._publication_sid = track_publication.sid + + if preconnect_buffer_auto_send_to: + if track.has_preconnect_buffer: + self._setup_preconnect_auto_send( + track, preconnect_buffer_auto_send_to + ) + else: + logger.warning( + "preconnect_buffer_auto_send_to set but no preconnect buffer " + "is active — call track.start_preconnect_buffer() first" + ) + queue.task_done() return track_publication finally: self._room_queue.unsubscribe(queue) + def _setup_preconnect_auto_send( + self, track: LocalAudioTrack, target_identity: str + ) -> None: + room = self._room + if room is None: + return + + async def _on_participant_active(participant: RemoteParticipant) -> None: + if participant.identity != target_identity: + return + if not track.has_preconnect_buffer: + return + room.off("participant_active", _on_participant_active) + try: + await track.send_preconnect_buffer( + destination_identity=participant.identity + ) + except Exception: + logger.exception("failed to auto-send preconnect buffer") + + room.on("participant_active", _on_participant_active) + async def unpublish_track(self, track_sid: str) -> None: """ Unpublish a track from the room. diff --git a/livekit-rtc/livekit/rtc/room.py b/livekit-rtc/livekit/rtc/room.py index 7fd778ae..f1ff3ae8 100644 --- a/livekit-rtc/livekit/rtc/room.py +++ b/livekit-rtc/livekit/rtc/room.py @@ -525,6 +525,7 @@ def on_participant_connected(participant): self._local_participant = LocalParticipant( self._room_queue, cb.connect.result.local_participant ) + self._local_participant._room = self for pt in cb.connect.result.participants: rp = self._create_remote_participant(pt.participant) diff --git a/livekit-rtc/livekit/rtc/track.py b/livekit-rtc/livekit/rtc/track.py index 8a6fe692..11b76f26 100644 --- a/livekit-rtc/livekit/rtc/track.py +++ b/livekit-rtc/livekit/rtc/track.py @@ -12,16 +12,24 @@ # See the License for the specific language governing permissions and # limitations under the License. +from __future__ import annotations + +import asyncio from typing import TYPE_CHECKING, List, Union + from ._ffi_client import FfiHandle, FfiClient from ._proto import ffi_pb2 as proto_ffi from ._proto import track_pb2 as proto_track from ._proto import stats_pb2 as proto_stats if TYPE_CHECKING: + from .audio_ring_buffer import AudioRingBuffer from .audio_source import AudioSource + from .participant import LocalParticipant from .video_source import VideoSource +PRE_CONNECT_AUDIO_BUFFER_TOPIC = "lk.agent.pre-connect-audio-buffer" + class Track: def __init__(self, owned_info: proto_track.OwnedTrack): @@ -68,26 +76,80 @@ async def get_stats(self) -> List[proto_stats.RtcStats]: class LocalAudioTrack(Track): - def __init__(self, info: proto_track.OwnedTrack): + def __init__(self, info: proto_track.OwnedTrack, source: AudioSource | None = None): super().__init__(info) + self._source = source + self._preconnect_buffer: AudioRingBuffer | None = None + self._participant: LocalParticipant | None = None + self._publication_sid: str | None = None + self._send_lock = asyncio.Lock() @staticmethod - def create_audio_track(name: str, source: "AudioSource") -> "LocalAudioTrack": + def create_audio_track(name: str, source: AudioSource) -> LocalAudioTrack: req = proto_ffi.FfiRequest() req.create_audio_track.name = name req.create_audio_track.source_handle = source._ffi_handle.handle resp = FfiClient.instance.request(req) - return LocalAudioTrack(resp.create_audio_track.track) + return LocalAudioTrack(resp.create_audio_track.track, source=source) - def mute(self): + @property + def has_preconnect_buffer(self) -> bool: + return self._preconnect_buffer is not None + + def start_preconnect_buffer(self, *, max_duration: float = 10.0) -> None: + if self._source is None: + raise RuntimeError("track has no audio source") + + from .audio_ring_buffer import AudioRingBuffer + + self._preconnect_buffer = AudioRingBuffer( + max_duration=max_duration, + sample_rate=self._source.sample_rate, + num_channels=self._source.num_channels, + ) + self._source._set_preconnect_buffer(self._preconnect_buffer) + + def stop_preconnect_buffer(self) -> None: + if self._source is not None: + self._source._set_preconnect_buffer(None) + self._preconnect_buffer = None + + async def send_preconnect_buffer(self, *, destination_identity: str) -> None: + if self._participant is None: + raise RuntimeError("track is not published") + if self._preconnect_buffer is None: + raise RuntimeError("preconnect buffer is not active") + + async with self._send_lock: + data = self._preconnect_buffer.capture() + if not data: + return + + assert self._source is not None + writer = await self._participant.stream_bytes( + "preconnect-buffer", + topic=PRE_CONNECT_AUDIO_BUFFER_TOPIC, + mime_type="application/octet-stream", + destination_identities=[destination_identity], + attributes={ + "trackId": self._publication_sid or self.sid, + "sampleRate": str(self._source.sample_rate), + "channels": str(self._source.num_channels), + }, + ) + + await writer.write(data) + await writer.aclose() + + def mute(self) -> None: req = proto_ffi.FfiRequest() req.local_track_mute.track_handle = self._ffi_handle.handle req.local_track_mute.mute = True FfiClient.instance.request(req) self._info.muted = True - def unmute(self): + def unmute(self) -> None: req = proto_ffi.FfiRequest() req.local_track_mute.track_handle = self._ffi_handle.handle req.local_track_mute.mute = False From d479195939de0ab0a8de3fd64135220fd02e9b1e Mon Sep 17 00:00:00 2001 From: David Chen Date: Fri, 1 May 2026 13:13:57 -0700 Subject: [PATCH 2/7] add working examples --- examples/wakeword_agent_dispatch/.env.example | 28 + examples/wakeword_agent_dispatch/README.md | 87 + examples/wakeword_agent_dispatch/agent.py | 101 + examples/wakeword_agent_dispatch/client.py | 577 +++++ .../models/hey_livekit.onnx | Bin 0 -> 953357 bytes .../wakeword_agent_dispatch/pyproject.toml | 19 + examples/wakeword_agent_dispatch/uv.lock | 2132 +++++++++++++++++ livekit-rtc/livekit/rtc/media_devices.py | 19 +- livekit-rtc/livekit/rtc/participant.py | 33 +- 9 files changed, 2986 insertions(+), 10 deletions(-) create mode 100644 examples/wakeword_agent_dispatch/.env.example create mode 100644 examples/wakeword_agent_dispatch/README.md create mode 100644 examples/wakeword_agent_dispatch/agent.py create mode 100644 examples/wakeword_agent_dispatch/client.py create mode 100644 examples/wakeword_agent_dispatch/models/hey_livekit.onnx create mode 100644 examples/wakeword_agent_dispatch/pyproject.toml create mode 100644 examples/wakeword_agent_dispatch/uv.lock diff --git a/examples/wakeword_agent_dispatch/.env.example b/examples/wakeword_agent_dispatch/.env.example new file mode 100644 index 00000000..59327b43 --- /dev/null +++ b/examples/wakeword_agent_dispatch/.env.example @@ -0,0 +1,28 @@ +# LiveKit connection settings +LIVEKIT_URL=wss://your-project.livekit.cloud +LIVEKIT_API_KEY= +LIVEKIT_API_SECRET= + +# Example room and named agent dispatch settings +LIVEKIT_ROOM=wakeword-preconnect +LIVEKIT_AGENT_NAME=test-agent +LIVEKIT_AGENT_METADATA= + +# Wake word model settings +LIVEKIT_WAKEWORD_MODEL=./models/hey_livekit.onnx +LIVEKIT_WAKEWORD_NAME=hey_livekit +LIVEKIT_WAKEWORD_THRESHOLD=0.5 +LIVEKIT_WAKEWORD_PREROLL_SECONDS=2.0 +LIVEKIT_PRECONNECT_BUFFER_SECONDS=10.0 +LIVEKIT_AGENT_WAIT_TIMEOUT=30.0 +LIVEKIT_AGENT_JOIN_DELAY_SECONDS=2.0 + +# Voice pipeline model settings for agent.py +LIVEKIT_AGENT_STT_MODEL=deepgram/nova-3 +LIVEKIT_AGENT_LLM_MODEL=openai/gpt-4o-mini +LIVEKIT_AGENT_TTS_MODEL=cartesia/sonic-2 + +# Provider API keys used by the default voice pipeline models +DEEPGRAM_API_KEY= +OPENAI_API_KEY= +CARTESIA_API_KEY= diff --git a/examples/wakeword_agent_dispatch/README.md b/examples/wakeword_agent_dispatch/README.md new file mode 100644 index 00000000..1b7de2fb --- /dev/null +++ b/examples/wakeword_agent_dispatch/README.md @@ -0,0 +1,87 @@ +# Wake Word Agent Dispatch Example + +This example keeps a local microphone track published from launch, listens for a wake word on +that same microphone stream, dispatches a named LiveKit agent, and sends the pre-connect audio +buffer to the first active agent participant. A companion `agent.py` provides a minimal voice +assistant that ends its session when the user says `bye bye`. + +The example also keeps a short local preroll buffer so the pre-connect payload includes the wake +word audio spoken before `LocalAudioTrack.start_preconnect_buffer()` could be called. + +## Requirements + +- Python 3.11 or newer +- A microphone +- A LiveKit project with an agent registered using `agent_name` +- A wake word ONNX model, such as `hey_livekit.onnx` + +Install the example dependencies from this directory: + +```bash +cd examples/wakeword_agent_dispatch +uv sync --python 3.11 +``` + +On macOS, `sounddevice` may require PortAudio: + +```bash +brew install portaudio +``` + +On Ubuntu or Debian: + +```bash +sudo apt install portaudio19-dev +``` + +## Configuration + +Set your LiveKit credentials and point the example at your wake word model: + +```bash +export LIVEKIT_URL="wss://your-project.livekit.cloud" +export LIVEKIT_API_KEY="..." +export LIVEKIT_API_SECRET="..." +export LIVEKIT_ROOM="wakeword-preconnect" +export LIVEKIT_AGENT_NAME="test-agent" +export LIVEKIT_WAKEWORD_MODEL="./models/hey_livekit.onnx" +``` + +Optional settings: + +```bash +export LIVEKIT_WAKEWORD_NAME="hey_livekit" +export LIVEKIT_WAKEWORD_THRESHOLD="0.5" +export LIVEKIT_WAKEWORD_PREROLL_SECONDS="2.0" +export LIVEKIT_PRECONNECT_BUFFER_SECONDS="10.0" +export LIVEKIT_AGENT_METADATA="" +export LIVEKIT_AGENT_WAIT_TIMEOUT="30.0" +export LIVEKIT_AGENT_JOIN_DELAY_SECONDS="2.0" +export LIVEKIT_AGENT_STT_MODEL="deepgram/nova-3" +export LIVEKIT_AGENT_LLM_MODEL="openai/gpt-4o-mini" +export LIVEKIT_AGENT_TTS_MODEL="cartesia/sonic-2" +``` + +## Run + +Start the named agent in one process: + +```bash +uv run python agent.py dev +``` + +Then start the wake word client in another process: + +```bash +uv run python wakeword_agent_dispatch.py +``` + +The script connects to LiveKit, publishes the microphone track immediately, and waits for the +wake word. After detection, it dispatches `LIVEKIT_AGENT_NAME`, waits for an active agent +participant, sends the buffered wake word audio to that participant, and disables wake word +detection while the agent is active. When the agent ends its session, for example after the user +says `bye bye`, the client clears the pre-connect buffer and local audio state before returning +to idle wake word detection. + +For testing the pre-connect buffer, `agent.py` waits `LIVEKIT_AGENT_JOIN_DELAY_SECONDS` seconds +before starting the room session. Set it to `0` to remove the artificial delay. diff --git a/examples/wakeword_agent_dispatch/agent.py b/examples/wakeword_agent_dispatch/agent.py new file mode 100644 index 00000000..0383f5e0 --- /dev/null +++ b/examples/wakeword_agent_dispatch/agent.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import asyncio +import logging +import os + +from dotenv import find_dotenv, load_dotenv +from livekit.agents import ( + Agent, + AgentSession, + JobContext, + RunContext, + WorkerOptions, + cli, + function_tool, + room_io, +) + +logger = logging.getLogger("wakeword-agent") + + +class BasicAssistant(Agent): + def __init__(self) -> None: + super().__init__( + instructions=( + "You are a brief, friendly voice assistant. Answer in one or two " + "sentences unless the user asks for more detail. When the user says " + "'bye livekit' or otherwise clearly asks to end the conversation, call " + "the end_session tool immediately." + ), + stt=os.getenv("LIVEKIT_AGENT_STT_MODEL", "deepgram/nova-3"), + llm=os.getenv("LIVEKIT_AGENT_LLM_MODEL", "openai/gpt-4o-mini"), + tts=os.getenv("LIVEKIT_AGENT_TTS_MODEL", "cartesia/sonic-2"), + ) + + @function_tool(name="end_session") + async def end_session(self, ctx: RunContext) -> None: + """ + End the current voice session when the user says "bye livekit". + + This is the final action for the conversation. Use it only when the user + clearly says "bye livekit" or otherwise asks to end the session. + """ + logger.info("ending agent session after user goodbye") + ctx.session.say("Bye, see you next time.", allow_interruptions=False) + ctx.session.shutdown() + + +async def entrypoint(ctx: JobContext) -> None: + session = AgentSession() + closed = asyncio.get_running_loop().create_future() + join_delay = float(os.getenv("LIVEKIT_AGENT_JOIN_DELAY_SECONDS", "2.0")) + pre_connect_audio_timeout = float( + os.getenv("LIVEKIT_AGENT_PRECONNECT_AUDIO_TIMEOUT_SECONDS", "10.0") + ) + + @session.on("close") + def _on_close(_) -> None: + if not closed.done(): + closed.set_result(None) + + @session.on("user_input_transcribed") + def _on_user_input_transcribed(ev) -> None: + logger.info( + "user transcript%s: %s", + " final" if ev.is_final else "", + ev.transcript or "", + ) + + @session.on("conversation_item_added") + def _on_conversation_item_added(ev) -> None: + logger.info("conversation item added: %s", ev.item) + + if join_delay > 0: + logger.info("delaying agent room join by %.1f seconds", join_delay) + await asyncio.sleep(join_delay) + + await session.start( + agent=BasicAssistant(), + room=ctx.room, + room_options=room_io.RoomOptions( + audio_input=room_io.AudioInputOptions( + pre_connect_audio=True, + pre_connect_audio_timeout=pre_connect_audio_timeout, + ), + ), + ) + await closed + ctx.shutdown("agent session ended") + + +if __name__ == "__main__": + logging.basicConfig(level=logging.INFO) + load_dotenv(find_dotenv()) + + cli.run_app( + WorkerOptions( + entrypoint_fnc=entrypoint, + agent_name=os.getenv("LIVEKIT_AGENT_NAME", "test-agent"), + ) + ) diff --git a/examples/wakeword_agent_dispatch/client.py b/examples/wakeword_agent_dispatch/client.py new file mode 100644 index 00000000..a6a0b3ff --- /dev/null +++ b/examples/wakeword_agent_dispatch/client.py @@ -0,0 +1,577 @@ +from __future__ import annotations + +import asyncio +import contextlib +import logging +import os +from collections import deque +from dataclasses import dataclass +from enum import Enum +from pathlib import Path +from typing import Any, Deque, Iterable, Optional + +import numpy as np +from dotenv import find_dotenv, load_dotenv +from livekit import api, rtc + +SAMPLE_RATE = 48_000 +NUM_CHANNELS = 1 +WAKEWORD_SAMPLE_RATE = 16_000 +WAKEWORD_WINDOW_SAMPLES = 2 * WAKEWORD_SAMPLE_RATE +OUTPUT_SAMPLE_RATE = 48_000 +OUTPUT_FRAME_SAMPLES = 480 # 10 ms at 48 kHz + +logger = logging.getLogger("wakeword-agent-dispatch") + + +@dataclass(frozen=True) +class Config: + url: str + api_key: str + api_secret: str + room_name: str + agent_name: str + wakeword_model: Path + wakeword_name: Optional[str] + wakeword_threshold: float + wakeword_preroll_seconds: float + preconnect_buffer_seconds: float + agent_metadata: str + agent_wait_timeout: float + + @staticmethod + def from_env() -> "Config": + url = os.getenv("LIVEKIT_URL") + api_key = os.getenv("LIVEKIT_API_KEY") + api_secret = os.getenv("LIVEKIT_API_SECRET") + if not url or not api_key or not api_secret: + raise RuntimeError( + "LIVEKIT_URL, LIVEKIT_API_KEY, and LIVEKIT_API_SECRET must be set" + ) + + return Config( + url=url, + api_key=api_key, + api_secret=api_secret, + room_name=os.getenv("LIVEKIT_ROOM", "wakeword-preconnect"), + agent_name=os.getenv("LIVEKIT_AGENT_NAME", "test-agent"), + wakeword_model=Path( + os.getenv("LIVEKIT_WAKEWORD_MODEL", "./models/hey_livekit.onnx") + ), + wakeword_name=os.getenv("LIVEKIT_WAKEWORD_NAME"), + wakeword_threshold=float(os.getenv("LIVEKIT_WAKEWORD_THRESHOLD", "0.5")), + wakeword_preroll_seconds=float( + os.getenv("LIVEKIT_WAKEWORD_PREROLL_SECONDS", "2.0") + ), + preconnect_buffer_seconds=float( + os.getenv("LIVEKIT_PRECONNECT_BUFFER_SECONDS", "10.0") + ), + agent_metadata=os.getenv("LIVEKIT_AGENT_METADATA", ""), + agent_wait_timeout=float(os.getenv("LIVEKIT_AGENT_WAIT_TIMEOUT", "30.0")), + ) + + +@dataclass(frozen=True) +class MicChunk: + data: bytes + samples_per_channel: int + + +class PrerollBuffer: + def __init__(self, max_duration: float) -> None: + self._max_samples = max(1, int(max_duration * SAMPLE_RATE)) + self._chunks: Deque[MicChunk] = deque() + self._samples = 0 + + def append(self, chunk: MicChunk) -> None: + self._chunks.append(chunk) + self._samples += chunk.samples_per_channel + + while self._samples > self._max_samples and len(self._chunks) > 1: + dropped = self._chunks.popleft() + self._samples -= dropped.samples_per_channel + + def snapshot(self) -> list[MicChunk]: + return list(self._chunks) + + def clear(self) -> None: + self._chunks.clear() + self._samples = 0 + + +class WakeWordAudioWindow: + def __init__(self, max_samples: int) -> None: + self._max_samples = max_samples + self._chunks: Deque[np.ndarray] = deque() + self._samples = 0 + + def append(self, samples: np.ndarray) -> None: + if samples.size == 0: + return + + samples = samples.reshape(-1) + self._chunks.append(samples) + self._samples += samples.size + + while self._samples > self._max_samples: + excess = self._samples - self._max_samples + oldest = self._chunks[0] + if oldest.size <= excess: + self._chunks.popleft() + self._samples -= oldest.size + else: + self._chunks[0] = oldest[excess:] + self._samples -= excess + + @property + def is_full(self) -> bool: + return self._samples == self._max_samples + + def samples(self) -> np.ndarray: + if len(self._chunks) == 1: + return self._chunks[0].copy() + + return np.concatenate(self._chunks) + + def clear(self) -> None: + self._chunks.clear() + self._samples = 0 + + +class ClientMode(Enum): + IDLE = "idle" + DISPATCHING = "dispatching" + IN_SESSION = "in_session" + + +@dataclass +class ClientState: + mode: ClientMode = ClientMode.IDLE + agent_identity: str | None = None + dispatch_task: asyncio.Task[str] | None = None + + +def _chunk_to_audio_frame(chunk: MicChunk) -> rtc.AudioFrame: + return rtc.AudioFrame( + data=chunk.data, + sample_rate=SAMPLE_RATE, + num_channels=NUM_CHANNELS, + samples_per_channel=chunk.samples_per_channel, + ) + + +def _put_chunk(queue: asyncio.Queue[MicChunk], chunk: MicChunk) -> None: + if queue.full(): + try: + queue.get_nowait() + except asyncio.QueueEmpty: + pass + + try: + queue.put_nowait(chunk) + except asyncio.QueueFull: + pass + + +def _is_active_agent(participant: rtc.RemoteParticipant) -> bool: + return ( + participant.kind == rtc.ParticipantKind.PARTICIPANT_KIND_AGENT + and participant.state == rtc.ParticipantState.PARTICIPANT_STATE_ACTIVE + ) + + +async def _wait_for_active_agent(room: rtc.Room, timeout: float) -> rtc.RemoteParticipant: + for participant in room.remote_participants.values(): + if _is_active_agent(participant): + return participant + + loop = asyncio.get_running_loop() + future: asyncio.Future[rtc.RemoteParticipant] = loop.create_future() + + def _on_participant_active(participant: rtc.RemoteParticipant) -> None: + if _is_active_agent(participant) and not future.done(): + future.set_result(participant) + + room.on("participant_active", _on_participant_active) + try: + return await asyncio.wait_for(future, timeout=timeout) + finally: + room.off("participant_active", _on_participant_active) + + +def _push_preroll_to_preconnect_buffer( + track: rtc.LocalAudioTrack, + chunks: Iterable[MicChunk], +) -> None: + preconnect_buffer = getattr(track, "_preconnect_buffer", None) + if preconnect_buffer is None: + raise RuntimeError("pre-connect buffer was not started") + + for chunk in chunks: + preconnect_buffer.push(_chunk_to_audio_frame(chunk)) + + +async def _dispatch_agent_and_send_buffer( + lkapi: api.LiveKitAPI, + room: rtc.Room, + track: rtc.LocalAudioTrack, + config: Config, +) -> str: + try: + dispatch = await lkapi.agent_dispatch.create_dispatch( + api.CreateAgentDispatchRequest( + agent_name=config.agent_name, + room=config.room_name, + metadata=config.agent_metadata, + ) + ) + logger.info("created dispatch %s for agent %s", dispatch.id, config.agent_name) + + agent = await _wait_for_active_agent(room, timeout=config.agent_wait_timeout) + logger.info("agent participant %s is active; sending buffered audio", agent.identity) + await track.send_preconnect_buffer(destination_identity=agent.identity) + logger.info("sent pre-connect buffer to %s", agent.identity) + return agent.identity + finally: + track.stop_preconnect_buffer() + + +def _drain_audio_queue(audio_queue: asyncio.Queue[MicChunk]) -> int: + drained = 0 + while True: + try: + audio_queue.get_nowait() + drained += 1 + except asyncio.QueueEmpty: + return drained + + +def _reset_wakeword_model(model: Any) -> None: + reset = getattr(model, "reset", None) + if callable(reset): + reset() + + +async def _monitor_mic_track( + track: rtc.LocalAudioTrack, + audio_queue: asyncio.Queue[MicChunk], +) -> None: + audio_stream = rtc.AudioStream( + track=track, + sample_rate=SAMPLE_RATE, + num_channels=NUM_CHANNELS, + frame_size_ms=10, + ) + try: + async for event in audio_stream: + frame = event.frame + _put_chunk( + audio_queue, + MicChunk( + data=frame.data.tobytes(), + samples_per_channel=frame.samples_per_channel, + ), + ) + finally: + await audio_stream.aclose() + + +async def _run_audio_loop( + audio_queue: asyncio.Queue[MicChunk], + model: Any, + source: rtc.AudioSource, + track: rtc.LocalAudioTrack, + room: rtc.Room, + lkapi: api.LiveKitAPI, + config: Config, +) -> None: + preroll = PrerollBuffer(config.wakeword_preroll_seconds) + wakeword_window = WakeWordAudioWindow(WAKEWORD_WINDOW_SAMPLES) + wakeword_resampler = rtc.AudioResampler(SAMPLE_RATE, WAKEWORD_SAMPLE_RATE) + state = ClientState() + + def _reset_to_idle(reason: str, *, cancel_dispatch: bool = True) -> None: + nonlocal wakeword_resampler + + if cancel_dispatch and state.dispatch_task and not state.dispatch_task.done(): + state.dispatch_task.cancel() + + state.dispatch_task = None + state.agent_identity = None + state.mode = ClientMode.IDLE + track.stop_preconnect_buffer() + source.clear_queue() + preroll.clear() + wakeword_window.clear() + wakeword_resampler = rtc.AudioResampler(SAMPLE_RATE, WAKEWORD_SAMPLE_RATE) + drained = _drain_audio_queue(audio_queue) + _reset_wakeword_model(model) + logger.info( + "reset to idle mode after %s; dropped %d queued audio chunks", + reason, + drained, + ) + + def _on_participant_active(participant: rtc.RemoteParticipant) -> None: + if not _is_active_agent(participant): + return + + if state.mode == ClientMode.IDLE: + state.mode = ClientMode.IN_SESSION + state.agent_identity = participant.identity + logger.info( + "agent participant %s is active; wake word detection disabled", + participant.identity, + ) + + def _on_participant_disconnected(participant: rtc.RemoteParticipant) -> None: + if participant.kind != rtc.ParticipantKind.PARTICIPANT_KIND_AGENT: + return + + if ( + state.mode == ClientMode.IN_SESSION + and state.agent_identity == participant.identity + ): + logger.info("agent participant %s disconnected", participant.identity) + _reset_to_idle("agent session ended") + + def _on_dispatch_done(task: asyncio.Task[str]) -> None: + if state.dispatch_task is task: + state.dispatch_task = None + + if task.cancelled(): + return + + try: + agent_identity = task.result() + except Exception: + logger.exception("agent dispatch or pre-connect buffer send failed") + _reset_to_idle("dispatch failed", cancel_dispatch=False) + return + + agent = room.remote_participants.get(agent_identity) + if agent is None: + _reset_to_idle("agent left before session could start", cancel_dispatch=False) + return + + state.mode = ClientMode.IN_SESSION + state.agent_identity = agent_identity + logger.info( + "agent session is active for %s; wake word detection remains disabled", + agent_identity, + ) + + logger.info("listening for wake word using %s", config.wakeword_model) + + room.on("participant_active", _on_participant_active) + room.on("participant_disconnected", _on_participant_disconnected) + for participant in room.remote_participants.values(): + _on_participant_active(participant) + + try: + while True: + chunk = await audio_queue.get() + + if state.mode == ClientMode.IDLE: + preroll.append(chunk) + + for wakeword_frame in wakeword_resampler.push(_chunk_to_audio_frame(chunk)): + samples = np.frombuffer(wakeword_frame.data, dtype=np.int16) + wakeword_window.append(samples) + if not wakeword_window.is_full: + continue + + scores = model.predict(wakeword_window.samples()) + if not scores: + continue + + wakeword_name = config.wakeword_name or next(iter(scores)) + confidence = float(scores.get(wakeword_name, 0.0)) + + if confidence >= config.wakeword_threshold: + state.mode = ClientMode.DISPATCHING + logger.info( + "detected %s with confidence %.2f; wake word detection disabled", + wakeword_name, + confidence, + ) + + track.start_preconnect_buffer( + max_duration=config.preconnect_buffer_seconds + ) + + # The SDK buffer only captures after it starts. Because this loop + # observes the already-published mic track, include the full preroll. + preroll_chunks = preroll.snapshot() + _push_preroll_to_preconnect_buffer(track, preroll_chunks) + + state.dispatch_task = asyncio.create_task( + _dispatch_agent_and_send_buffer(lkapi, room, track, config) + ) + state.dispatch_task.add_done_callback(_on_dispatch_done) + finally: + room.off("participant_active", _on_participant_active) + room.off("participant_disconnected", _on_participant_disconnected) + _reset_to_idle("audio loop stopped") + + +async def main() -> None: + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s.%(msecs)03d %(levelname)s %(name)s %(message)s", + datefmt="%H:%M:%S", + ) + load_dotenv(find_dotenv()) + + config = Config.from_env() + if not config.wakeword_model.exists(): + raise RuntimeError(f"wake word model not found: {config.wakeword_model}") + + from livekit.wakeword import WakeWordModel + + model = WakeWordModel(models=[str(config.wakeword_model)]) + room = rtc.Room() + lkapi = api.LiveKitAPI(config.url, config.api_key, config.api_secret) + audio_queue: asyncio.Queue[MicChunk] = asyncio.Queue(maxsize=100) + devices = rtc.MediaDevices( + input_sample_rate=SAMPLE_RATE, + output_sample_rate=OUTPUT_SAMPLE_RATE, + num_channels=NUM_CHANNELS, + blocksize=OUTPUT_FRAME_SAMPLES, + ) + mic = devices.open_input(enable_aec=True) + player = devices.open_output() + background_tasks: set[asyncio.Task[None]] = set() + + def _create_background_task(coro) -> None: + task = asyncio.create_task(coro) + background_tasks.add(task) + task.add_done_callback(background_tasks.discard) + + async def _log_transcription_stream( + reader: rtc.TextStreamReader, + participant_identity: str, + ) -> None: + chunks: list[str] = [] + try: + async for chunk in reader: + chunks.append(chunk) + logger.info( + "transcription chunk from %s: %s", + participant_identity, + chunk, + ) + + transcript = "".join(chunks).strip() + logger.info( + "transcription stream from %s complete: %s attributes=%s", + participant_identity, + transcript or "", + reader.info.attributes, + ) + except asyncio.CancelledError: + raise + except Exception: + logger.exception( + "failed to read transcription stream from %s", + participant_identity, + ) + + def _on_transcription_stream( + reader: rtc.TextStreamReader, + participant_identity: str, + ) -> None: + _create_background_task( + _log_transcription_stream(reader, participant_identity) + ) + + def _maybe_play_agent_track( + track: rtc.Track, + participant: rtc.RemoteParticipant, + ) -> None: + if ( + track.kind != rtc.TrackKind.KIND_AUDIO + or participant.kind != rtc.ParticipantKind.PARTICIPANT_KIND_AGENT + ): + return + + _create_background_task(player.add_track(track)) + logger.info( + "playing agent audio track %s from %s", + track.sid, + participant.identity, + ) + + def _on_track_subscribed( + track: rtc.Track, + publication: rtc.RemoteTrackPublication, + participant: rtc.RemoteParticipant, + ) -> None: + _maybe_play_agent_track(track, participant) + + def _on_track_unsubscribed( + track: rtc.Track, + publication: rtc.RemoteTrackPublication, + participant: rtc.RemoteParticipant, + ) -> None: + _create_background_task(player.remove_track(track)) + logger.info( + "stopped playing audio track %s from %s", + track.sid, + participant.identity, + ) + + room.on("track_subscribed", _on_track_subscribed) + room.on("track_unsubscribed", _on_track_unsubscribed) + room.register_text_stream_handler("lk.transcription", _on_transcription_stream) + + token = ( + api.AccessToken(config.api_key, config.api_secret) + .with_identity("wakeword-client") + .with_name("Wake Word Client") + .with_grants(api.VideoGrants(room_join=True, room=config.room_name)) + .to_jwt() + ) + + try: + await room.connect(config.url, token) + logger.info("connected to room %s", room.name) + + track = rtc.LocalAudioTrack.create_audio_track("wakeword-mic", mic.source) + + options = rtc.TrackPublishOptions() + options.source = rtc.TrackSource.SOURCE_MICROPHONE + options.preconnect_buffer = True + publication = await room.local_participant.publish_track(track, options) + logger.info("published microphone track %s", publication.sid) + + await player.start() + _create_background_task(_monitor_mic_track(track, audio_queue)) + + await _run_audio_loop( + audio_queue, + model, + mic.source, + track, + room, + lkapi, + config, + ) + finally: + for task in list(background_tasks): + task.cancel() + for task in list(background_tasks): + with contextlib.suppress(asyncio.CancelledError): + await task + await mic.aclose() + await player.aclose() + room.unregister_text_stream_handler("lk.transcription") + await lkapi.aclose() + await room.disconnect() + + +if __name__ == "__main__": + try: + asyncio.run(main()) + except KeyboardInterrupt: + pass diff --git a/examples/wakeword_agent_dispatch/models/hey_livekit.onnx b/examples/wakeword_agent_dispatch/models/hey_livekit.onnx new file mode 100644 index 0000000000000000000000000000000000000000..22b156250cd1c89aca58eb6a72f8798feab22795 GIT binary patch literal 953357 zcmeEP1z1#D*QR3-1jNDu6bWJIn%T=16$86<9AM~@8A`8;-C`>yc3=kzXD_?EySrPl z{m%r$PV7{&@?MB;d1u*f_~Ac~2XqzYnV1u=0UiP0hfduec# zAT%K^Mi3*C2t$Mtp&&diE{bRMr!RF8r^X1x5&cDih**ihjb|m4h+?_-?+Zdip`wHYQHY@M^md2D0YDgTsXd5%uJC?TeyMnkQJEK2GJtSE$w zvo(3_L`V`vMM${G!YEO4TtWz!MMzP!m>VAvFOp6YZddk1SN22`DRf1Ive4xsLowOQ z(m!8t4Yx^LY*Hf$i;hx=QTZC>BP*~|c`O6ZwVFRg&vBYP?SA3;r9fKR$A13UN*FHm zxGXk}DIJI7Y?T)mhG4fp3&G0IOZ%oU2D>>~xfg|DD29`&FkGvrowOANZIvD=@4z-? znpUyTtK#fCO*zoIgvZ5*ToQv=d`)x_N2Lnb0TdMyk>Dau2zF8QuuJ~Ha*+=#7v;cG z!C@a64u{4iu%;x0W5xbS5J?gfVy(oY=uo-Qlnpog6bJU~e{l1HCaahM-{QAVVGUdg zSJ@@@vOebQF2^aDcbqCJUlz;`ajq*jSric#F5y%vekLeFC^pxVUgj2JX(XGm@&g+k z>GY7&m#~Dm#CSQGF=pqjFhtx?Q#NZID{>5kiIO-0`<{(n+rUm8n{~?6)OIxC=!+!@ z5g{V>LUwXHnsN+7BBF)TStfrcV1kw^4f_7iPWK|6!n2aIjM!KyB-B4jZq zf!k5U+E5lRgwZNsBR$Xda>*Y|lEI8yh>N^i6_6r7;IgJ&m>4Yy`0#T~IrmRt%Ae{D z*+i8RXKvwc%Wu6BoC-Ibozh23N2d*%w(`q=5t|C%O9h;i^T)}`HeOKh`wOI>5V#8D z)1{P?(i!7q)zhuF?4P0l7gP+OQ~|DONdQ-Hf7w7PjDU)mgQwu zq~Hx3^VZUnZP|0e=!pI@JK$)>;jm*?94?Tg#*5^}#f+mbiWf&j$Hi7$z0b}kQ&ZE? zf}L&#ec$PA>+u(%w||7+2Ye zE(KkyuqFj>C@sopt)H^gd;dO*Qc8~~txNHaVBzv~=@w?IrftDTe$mPld_jKat5_Pj z36fe0cNWInyji1Bg2i$Bk;QQn$mVAeJtMT32~f2&Eq>9?xJi4mph0ZsZTqpU$xz#x zVvCGl1orHe}BuR zfO`pGE@XwwB$@5wb`Z7h>>}*~1$;|i=3_^|r=KqcF8up|yGZMmfUVke7HvkA4%IQX z(rbSaqg8LCg3bk_)u||t@B2f1W#w@hBUegKg^x<*@$S;=qz}Wk^~jHrb+sBgHK|Wuf5m{#@yh$>;Cv`XZWjDu9f-D-Il_5|9jFi*t96Qn|Z_oVy#yNs7SD z(pW|R5xD)W3Q&3>4nO3#;P4(Lz`nF^3oAfMmz=!YmB3$yHK0SK!~WWQ4M^bji`ZYd zn^n+XI;l#e;~qbv;~p|PUb+Aj@ zjY`2!pfoIMDM;>RVPW%p>4t_;m4bfR*c9)66@!z{vwkKAdH%@$c$O#!h5yj%1pK1a z@swJff+oo`6`{6HZK{f_GcuM(hL zWi6WTL?+3Ho@N|5xEyP zB|fE^5})D{k$Z88$XzWF<;R@;Akx&Q1T#{2an`ydi74N!6i{2`+CnW6{dI}xSItfF z?pIlMC?q2HpGibMKe9hQ|Bn)pPZ5boYI)QWQCVHO6h@(f)yuC+MD7ZS$X!(;V%HrV zSYagKca(^HOMrHj^^r@9s0RMR0Ofz|7?zvY9Fg$bpenI-2a~>B44FM zB*j^^L{wIBRs|9YK=wbBh~^k5BqDcnBV~e&z}?bR=Eqfe=ZA@$FA61c-uj=(>=NeZ zdHxt++pyVK5#b_Xh%ztKMWy8mT}JtiEFbjd&jU8`eWjRT4aCv6W32k*6q%!Cx3H7X3~6lq%*>l}C9MPrPT-z7tZ}M~)In|7C0cB#PMoW$zYF$9Hw$ zY~*lM7?hX1NQW;&kmdAWqWwL}7vg6y*m>!SUA5 zNz?X!8EGoqLUyuWE*;%=u)$`s-uXpjD||1NHE98~v6;bz{Z`6(#+FmLee* zzpkYG!w$uOOf~<|^RMtPd1KfP`}AXUyrM=&89@Hi=;+6q%u-;TO@w!1Nst`l*@Ju# zXQ9%c8zWs?38afFLBSZyPfq9T<;Zc;k7KQpQmwp@HR19>D@!-mlaCpNDkwj&(QXtH zqJ~jf=c!b3Q^RQK_2bkq`tL82^sgnEe-Dg~W7p}@%9L(yirRpRLl4FOp62q?UJ4%C zBrY~sC=vMC=*eF>8YxO{$jVhdC`3vx{RX5oDMFO2prq25Nhx&IzC{9?#aP(=m&d70}-$AzK{h4iJ3eg~0QTE16WrjD&S8<*T)ln^JY zNED!kKNTXWhQE@F5Ub%&r6QSoapg?4AX&l6?oU;1`%$^hg0E7!y_yWNiyeV-P5s7@ zBZE5y_<5TfCdP{8MW7Ycd6maDhMn_I1-vT6`tJM&tWViY1@%)NEBW8upYy+6|1$np ztdT4mnov3k6x%94@QXxH`T6`_Rbhitlq|v1()ovc&*!i3J>}iiq_1p~zVRGR0nVw$ zvUnGZW${*ZR##9ICD&%l8%rJ5I?}@Azq7-dO-CxhVO<9N&eKXq!Tu_KXYXIcL8TL> zh~HU>P%IESSveOgj{di}oxRm?ShnHtuA!m*R~3X^EKCFYb1(-B?>pO{J=)9xlj@=O8DI!9rD)ZW1XxY zWZ}x!ehziH|2C*owvGjXAC{1ncgn87m3IjJm|ByWD1z_}mp>XknX{vM=rE9$lF^g}l1 z{g>FB;s;e@UD?LE$0}GSk67_jf?a+cBE=|oFJoYrpZco?JLy)kaklxx;O_yuVk+H# zAMB)QXX@DJe??}<-xH?7u3d}l;45Fky1Sa|u~E|kZ!g6XR(@ck&8Ck0hMoy|>v&cq zC@~^h;w+6ZSM2|6#h$7kaPQ|!*WLe~rE4jzWU(NvboWH4t-O;8W1UB-l?>S3trLXo z#$wXodzDpd(P%u+qKxjpxOSC4uo~jZHlO>-M&ijwf&$vy z@?-(YzuyX08W^EmzpBQP1^oUY$umm_x`DEY|QJm z`M-#N@*h}@e`Op0zOneH$jgxZ@2*J5a91Q`xO*ug@)QXfZlz>or~yzc{(XXy)c`1A zw_g^p&f;K^xjMi1f1~=r-?PU3$O52TsZkI>FO~qxxQ}9OD?ccO{K@uxR%4$U`-0gN z9YMY<(DN^4WXMOKn*2qFato3t)Oi>x=_78Qe-HKzktXHJuue4`*{4`IvX5#wa(P8K zvL+jfto6HxBC{o}%VsF@pDeBCQ&{l(k4x*xN24rmrIF53SO z2lQ2Qz_N{jDjd+g2nX~~RRKN9AP4kNpr0yrQFB1nH}3I^u&3IQ#W|pChb3uYs{cn0 z=%L2HvWDM$*~T73U+9MDgV zfn^&5XDI4CyUGcmhp+s9wqB_`E=Ca#&9~r7MCHDE)Y|4OQ_$N5x zuWlHp+LJ1hVF5?<{bxC%bPG9kqHq~b6fTU2enmKix_tQ6 zQl_dsSt26({j-Ruu5Mb!!)o&KL#w6fB<#LN-X4mLjXFyA^bmOY*yze$IhNz-vRkbt zNUF&4h-YeX45b?uisPl3M`N^jR?!hjqNoT7H(3}ZN{&ki;l{A>7tvyFd_=rRx|I#L zD|@0Vd!k9SP%MrJjSwZc6ok>2{`rDyxNK@)QltER$V>bhu5!P-zr0Pkn9Yn}cTEk6 zlSuc;3rP%?6zsC65EFlNi8Aak@8?Ap&i;FfEXV?i{!F`BX0@+$@o|-=?T^0X7bVFb zeP#adp#r*6ESBzAEDw#8?(Zpk$Gd3lhVUO&;|lmo)wq5zsMK7vZ0nUD6+6v&=Vvl2 zJUHG8501BYJ`zVq1d9aTt}GHuUj?YKw+KAv&-DN`_OhjFiprd7>@9B4)!3`XUOC%U zc+VB?B6meq9dDn)*z2ao-cqQs8hh2eSGtxfSb5nwS=s%FnX9o^jlHVa>zyCLYYx!h{fe&QJv@_HkE`U=K?(Y4Hd_rvzcFI6h9yI^RmHEXUTBYsePX)K`1tiUv%m zL0GK{t5snac?gtRnXm#Yf9Vb?KLFu;Wx`t#lC<4-ayoxFlex>9{sFew| zGEuP7%3lnq-F0erT|$T&iT^wjKg&aqqIp&YgtU%k1kP@eYnhmw3fx^!; zRm-N`&@8>|*}tW1nxfr`3TcWXCEVWrc`>vd|FU9eMViRU4{J)Vdp1SWR&o6=mN+YN zH-fX^W?p}#zM10j*iKNF)h)wib#EDROvI@%0&zrt zksu;gB2c6k`+At`N%x2I^HccG)fiW{%hr50#`MQ;ymZgS0u~-n!*2xpH^;uKR>A#2O$tr-Wq7e%PYS;^o60p14u%+*> zX!}P*i>z#1!sB8@E{Q>jv64g=aa5{+t$`mE5|Q8{P6&2U)W$Cslc^MW3S>BUb{j?M z!a<&#&S7^auu2d~5))#r#G>d>Zh>@XpW?ut{SR(l@Kx#nrP2bFJ{WTHbv_0DNz+lK z-kSUfeEC5sc~CN6xf=S^(8q2A5G}|T1A4OCXoQI*peWB0FJ|laiDJ2`7^`M{A!_K8 zjSrXDSZT&oVzfx?B4o9sB%!SAT7kiE^Za`@58RYrpUQ_*N5xbq>zi@e=z3{k^+>Kf zzMfkk|y29xA@Z#qi$v36>{k$vr{i9f2%MbIHg#ovIt|xB)ml4gvEo70=jam&h8KsFDMw*1sSc<%o5qySLBxbi3_E}zo4zGn_g~Q{ z^E*PlPA}W*^f8KvdN((Yu5`WbDyOaa%XL5ZBFlB}GPPXyEt@Lk;?gm6w5D99^!-Hy zErqn^!x5`fx_PtcSlBuE|D##@sO8r>RSd^?`kA0 zx=ofE3Dq*DlU1yU4Ix$}jDx>0S}gh#Dl0ch6r03~yg@GUsgm%xSP!n7n~OL?B64PT zM~xDOu}k-Vb}cXUUCVLLyj;O%>~5}#I;W~{sRl5XR|GI>vH^@*((uKXg+g|2{{|sD zs!dmrL*-jsHj*je=FivI_%B;y7iu6&k|vi<50h<`7Yp26e~}|9ze3ufMHkt=EE#mN zaxJ=CzC6TQ=scr5ChizfBk&(O>2(aWvy_*q=fiE|8?gi{zdJGmgF}UK|k}7h7@lK06<& zuc72b=l|g#WqGHSu+P1;FO{w5Dm%nQwWIPK3d-(OIu&mG98LarqE||3szL;4AX)s)9!f$dD>yY~WrAo&)*sTDoUJalRyn!hg(~ zeSj7bHhW!Udw3cuA^2m?9F( zysWGj)*wnGiVum1k-rfzzYt5B^v|*+X0>RCJlUa@whIDRoXWtu$$nxSc#C0B1zzO6!lA#CUXm;Rd?8scWDV9R5<%v%OX%%wN4g@;+{{0 zWQY0YI^fgK5#z!?g&6X%vDjFyA}okoQjbVYc(Dr$^*{kfD%5m#^6n@df|e*lF5G_+ zhZN5cA_^6<`+=ySk#w#UWka&COxIGVkm6)XJSgOcz~x^Oa21()(%vcZ7S~nAixlIA z?Wf~9#crdz&ZQz6N}LW2rMxC#aGDo)ZOV%d7HEb_`{hP~|Y zZ_@7->mZhr$wrO*ft=*aWVw?;aUdJSoR0+#OLuc!R(D9quPz{t2#bk} z2w}@|$zKG_Cp9tRF*hrW%S%N=^Aqpjc&c6u_~E7wcIn*7J@OdCrfcZV zz|~~a<&li#(pnf*X92n2XevzImqq6FngISsI-~C0TO=kk7(Tj1(g__bAk+Ud3ASp6 zhT&oS7nA1VR^vN(*7rT_R-+#tmBeGS8V%u_h7(A{k#INR1zGa62TmTN1N?F!WPipo z?0U@;-DYh-n^ochwhJILr+Bc8Tpo>FrV8`&$+oL`+8#Ji-{z5cpcDe z(1yGf*yDj3-DtR8EGb`gDKYq=Z%Na7R}G(9?nJ@FlIAddUFR14rs}r zVA>7t9}j_5%Vt65syF1E$Q<{awIas`b|GJGT;z8e+>%+l!4vgX?jut*KJjo&PZ&C) z4Yc@UEA`NDCrMU27`w^iVDAM(*j+`;KKoe6(M$$Ct&PO6RwrJT-Zgr-XLp=6Z6i%* z`y_JEvfR@iE5LI4WS&XNOLAg%ZCp1}48gOCw-{@lsfu=J&-Ko*!nbAvf%E$%A zHfaXihAn{Od3C|eApjW-qg#W{nZ_)--56Id+s6!E zS^;fsI?$xRj<9IP24KE6rprSk{LZDlB;PvjAdv|MSZ;4B)~Jy}KFl8DTYu>&=(dax zEynhOOnnoOoJxm=ItR$gxZ_lR!*Xi4F_ZQ%7)vM4o5Z*~?V!sHjZPA5G&L0Zq(6u5 z@1N%KAsYJK;E^SN5Xh>VLxXBn#LA}Spbd2g8Z(wRd((LA(mjW1*=H$jG_L{PY0?H? ztgJ^T_{?SQPcz1&%@-4|xmD=9MXkyC$qfkVbb%9Z+Tx~a<=|1vV{}XX@w~mRTz>Uv z8$5n-4~d9h2b(L-hdnpOQq8SgoVzFzpRb*bMDP*E84ko{16|;(4Hv9e8R7zuPFH1Aw>m>q16sh#^%+oq3cZ($bg(PTb4yPv^q zCwK7Xxzh*TxsWx>j9zND6S6;L!+~Yt%o2+f(7yYcF8*vq(+tvaom)1!*`OzeRNsO< zW}PSE>09YOw*=g|Z3fO+)d39dRKv4XY_ZD(ds;WQK6d`l1mF9jm(ZKbi7SIEE=gCX$%Z&Gi zDAZc9jL!E-;13&5Nx!L6V0r@)ZBTtNizBeY z!tzyG2a`UiejV;esPs^j$>H@3>5_1zcpNr+Jdl3m-`17UuLub2FH*Ab{9*)q?u_ zC-HU74l(CyTB1Au3I^5+!ob?iuxofK-Rd%&4%}WIGg7NkU0BWRzUTncj0A*R@eMS~ zm$^KY-)pP)ArCCzQgH~h4*rA3!NY@ zn=t)Wix{Imlktn*a$4J86Akm~;p)0xkZd~x+ZoRgK9S zotD6DmP{XyA4%VB@58is^NmDuO>pJn9A-?fO-$xqU(|SfpZJK5GoMdckQ-<1k+yAz zpJ>x$rV=2zh5{ zfS0DUg=g=&gRTB`JQEp&joq4%%ywJImSrn(&6HefvEBfEEYh*z7H86M6(4-{hhmbw zHvX|>C@hh9V$$?zYIKi-n+Ln1Wcx(AL!%L$eao2m#RK%39Y!nyYhrV9hG{s|g1r0O z4T5%lWKz@5lX(0@FTb0``*igUIsYXRl3q=OyJoM5-P9mb-m4rA8l8+9t;a#zC|`8y z;)4!hnKW(i5ZpfV2n}023Yohnj~Tev zZv{q2$Kb)ZF!bYA0;jDb@Z!dJTs5&9jXkq~R&ZzwBPv_sy;<4xverS$iEjxhL6^vi zUT107_Fr3$b&N(v#b~Xv3cdGW{PZHiI zO}eHNqm-5qcYGjbJ(-L+=M2@DbBTU!n~lSLt?6aMY4oabbDGY4WnMV4T=VN2BEDOf zq|lwzy?G6$Wrrtp`sIf>S!@e_++-N$H5*!IJrqFDjF4$ZcO3c$X;F72F(AUVHzUj1=+4TM_2_Bq*^9;L_+MV{(MH`%m!QhGf zwn6svUJj2L*WU+3#{P8Q>I2Mp&GmG&q$%ISVopADx9i`r<%^eq=y<9T-O|vt48ztU(cl- z-hLw-9S45G<#sSBdK&o_V+POT8euH^e%E%I$n)Wng)J}W{lRwo6IAg z(=sozW|I*}^o+qHWjnZEH0OEV=>U3jw$c>|);PQAeX=Lv9*K$GOs=m<#NfGh%+V2( zK(F~NX0Km1W7xeGibaR$^Ibbh?W2v+O5lc?ucKl4>tH6NO>dlA-JH35t6?Ux^(?W=>JAGjL zmM&URgKFFCqgT)OVw~>-ls_4VOuzZ)ws#rrRk;dspR+jbScTr5Q$xcrM zBYKe|zTT$>QtUU>E-n-d z0p0!ANYbziU^rnUR4`~jw^la9Nlp2nVbX#wwp~y7k}Wjb%n~PG>O)=}w1%af`Hb*>1N z%gxQ*65)_L>C||voiZE7Z`J{mk7M{>AFbi-_dCewcihL*tBN#iN_iN=YYQm`%`rga z2F{msQ174@PP*I(ZpLpTV|V1{Mh_T41W!hwcL!(w@k0Y~v`JNJuj33n{&gx^YKo8a zSCX)icCbd!9<$ARg43KzfIK2)I4C#fgy(YmX+5}QH57M`fZD940 z7xZJ3*EG<^60;s1B=vK)(D9@yyshH}&5j=Iz!oI|94pbH!pbR?TUNN8ZpAbQ`q2I)6)C~5vq6IXQG45ydX z!NV1dk#}r3?YY~MX7v~bRrdvAg^ukp*dqnUT;9UZe5-?JTz&A|qI;y8=^=6^_9T4@ z4`_>#O<a1EA(|-o> znZ29(jOz))XZz{Qj#ZdNfrFv;qJ1PXFNSIa55ro1&xnJSFE*ZFMTR$eLK2#6AesBV zkT=t+!_&FT$@{x+$@E?iX@?K<$&EZ`xU|ibR9Mb~^x+?vX2Yx*Y;d2MI3j_bK68w| zxe-HpzG+PzA4F20BN4Q@)^6f>ybBEZ;~+KE)dJgH<3KdhjcNF{KWxTMxOQ9$?yxt3 z_F*;Xg*xLfsLd+eyG57Z6_8F4GO?q>hGF^yY3?dd~GL`PkPB+HfZFPpq!Z>+3CKBFI@% zZ^|{k&Z7iKYBU}`^?yL!K29P{miC77y=IW%M>dic30vs&eVfRR1({?@ra}oYX_a#-4EQ?sQJ0GRFi80u7WB2tB3SaSbH9Q z=-L*aJgY>U)=q}`^k(vPl5(dHoV|R39)2XmJuxn@ zrM(de${T^R9}h$GfX}&^W|=hVh%^iTJLb$cSn zWN|i0)k{RzEfKV_@j3qYsk89j+6MTgPb93|ww%%#PV}1nJCeNI3Jzw+lS+ZlbDNmN zV6%q9ap?3Qyi@KPiH}3NZubV3!5Dleu^{^oHiZ)%`%uxT z2Kan@Pn6_+A*)P#0$ROuu=5T%{SKIs$WSFI=iIoqqpX19q;@CWiw;@LZ>tG;6*d zu1k5soZtC`^wl*0N$?{Y5IhFIgd8WAJ|8BbnhwajTodVzro1QN(@2L$-)J7>k_z!h zP$D?Yw20nCx~*+W-_{w18CB2Ze*NOaziV@!I`0#p*FlC{T0f0c*s~A&#mvXU9c@UB z2PW9yEt2^&&eIjSCNM|$3}o!yMqa(vAlrHeL*StIyl-_b(hc)-=$9MX*uXv$JH6px zgSh^9r{i`ytW&TAwQ(D`{WvCfX2ub^J+%$`F0OzR ztgP`#W?k58caY4U`-oh9YE1ckJYn@qC*l&aiTXc3l$$~-6Q=JsblKGj`}X3{%}*q> z^-~Y@f!6%NvpwkgqZTBlR&(Dr1M0!sbqDE&bUxPE97b9jYeL#E3p{2w0Y1jBA$xn} zfRSf9b`ENdr#FrFOTCbb0ggc!KgSKL*8T$L3(K zOM7WKQ#*`vIprH=b&O<=SV1)dnuE3ZM&fpU9i2DH0BR-or0dMbk~_}h>Gx}KxrX!V z@E15l=GII71IDMA)o*h(67u5u!nK(;bV~Q?xav+tx@p=1zJIUI*usA_HMi5E+XYXU z1`!9y7pp8%rRD=#`+5qbuL{JOdqnielRAXC)B%mcTF|OjmcYQzj=Z$krBI`F7EKxC zhI=g1a9}+f6mQ%^vYSQ_!-{6`)oUU0>yBqMCRQQOTaC);_2>hsec769|MZY#y>NgN z)t8bn*SnGUW^s5cx;>sS=#1Yd#$e1g1Kv&jnb0q*9F+{~49*`?<5^HF9U<@(2Q4=rt4I(xTI+K%u&a@%X#zFHc zk%&X1!M$ZJ%=8_|wAvAXEe@OGcP(catcQRnx37 z+>!?yvM$rA!9y@4Y6;HX;)gYMT;-ogHGl=5yus9gL$BAjLen8W5Obv!?%!~Y#?bBf z*v>9@q3tXZ!P>8lX`WE+Xb{u|eK6|9!+v|y>HY;H@jJBwk6Epu?gV5uPHBSCf1Kj4 z>SvAZj58phB?XJxA7MzyRdN`XLs<8kWVSWnWA~MKbcQBgx@w6FmQBOwK3dc%s}(qo zG{7Z&Lt##jisW`1EokU>7%sRpX9P_bF`t(QQ_VY`WUbyGxl8QRssFyw#HZdnvRUE@ zIpxwZ;NW_CTNDV3a2ZMScIVIfxP=(zo~J&wr_vF(v_XHo267#mLNxnqPc$A7VdQA= z_jyAXRccK(_GEvb`bWvVV6FP1N^NPS_r4^vLQrl}!(4KEh!|@vYXgQe=ac3AHJI^H z(Gd2U181`}@N1Wr(DM5^Xq~#1FPzmCV&1GEE-n=@dGZ>X;oyiz&Lu+X-WsG&KnC1v zuMcx7CBW9sn$Y~}TmIVK9R9u5qp^L3$2{SVEUftXF;3R+hlk%CBF-FR+&%pQ|6+C@ z2;SiX$6X!aWzA`{-Fs88^_&1r_lD5))h4jF+$i$B-yX_zo=e(fUPX=u{)6Wj~3_ zzD<^w`y)4ymq$-M4uR(;7iq)^ZG2syhdhhnIBfb@b zX%dX@KZ-V+t%JAEh2o2zQ%Seei)qlcNBolutl)B012FEC&d;NowCZDh$eULlo^fm8 zkichT#{4O;!lWU8;fMFUg^jeXQJx(7OCZ=@3sYN73fYIw5zH29EVN81n7qyf)*Qtn7EjCGW9ud~FRw%I6k8$1UpNvGqt=tiyz*hB{D37S?dle4+90zi2hz= zuV-hf_dbI>?sk%K2(JOPA(x4Cnof>B8cQax;E=cu_Gs0v1FL0UrCrM{rp;E5BV<_@ zsIhz~K3u+zCf02WpSwt)-_W{r`{`43?zBU6<(LYZqcLv?bf-!jr9cr<^#>jBEo^MZ{*4e&(yx%lZQ<<(rh5C%RNz|MCbuF?y|un`-` z?Yb>M961)vY^%YDQxoXH*JsH7RqHW(OJi_K(1E_4=JC(z41?SbEx>k$4Se!whjp33 zcyUP#We!>69?3m&{n#+-lzEVzt1}H>Wga9wTaG5$28P!52)yZ>Kx#skjB+rmtsu`ky5aLR0y3vm2p($O<&~%)&J9 zPjpe$uDM&=-X%SE4T1I#wV>16Ph{lf5zsQ;0$1i*gY{txnA5_AKh>6|fXdHk_sGw9Hft;ws3&EQZg9v#wKNc`rraSG3-5G&&` z(Dq^*%;Vo-+rKy0i^S7AxwApzdN%Rs(4RQQrZKm-dhy?;d?b19@2HvP41B*Wix{T$ z0K~l=X0E!w|ml-cemKd;Sr@7gyVZ z(0@K`ep!J$i}_A%cO*f7<1UOiEgTIWufPq}(xCE`kHqN0QL+bYFtYvzvUz3;ayQDK zM#Xf*UFo&39}|h^5AG-B?fv+DG6S*3q26GzECXhSX;bH&Bfxq5Ir7caYiq{)y|6Rn zF~6$+d1BCDE&rp{5#sz>56-WQChaGVq0KwI<_{jQiS%4Ehg7Jsm<+3$N&C}mV%&Z< z-L`EZWo%6#>s?R!@x^pBE5D!K$eKo@yH@AtT-Zs^JQnd&PX*EL&0g}Z$83OlMhoa* zV@fYfbHue;4Tv3lCC}dE&;e7Ti1rmOrbndF46R^1W<8krKfg$gUfbj20|Bt)nE*Gt zr{K~Z4RQVb*W}TvJR%v@hn`7V0ER0Zfp>HQ>36U;8Jcbi-n%TYyDLF5*o*Xg(FD8s zN0a&0((s+gk5pW5#ow^V2EzLKqPfr&HXN=9wjKBLTR*qMwz*r#UHeD;5%;z-!toZk z#l9)7J=+JWwRuU7T-itT8_Z?SCZ3}8JG>=-^uNTfpgjP_H60Ce9>%~Sz9v3f+7z=Z z`ZBLh_5!_ik$AOL1!{WyCVAbz0vU9*I_!*$;tQ?P_ydD2A=|JIe`L=JaM-pt%vv!H zj^BMuY?+V);WPcy=o?AR`_ZEz4s*L>wdSyX!%luX?mz$~9QfrxOTGqjKwq zwBWt8;E;=PI`n!Dt9w^7#GqwuNJ{gXq+H%I+I{6QTK|1lYvK+{>^-C{>>ttc}*_i`lj z`t=oZzHeKY9<7h%4bD=#?fTfmk$|;s0$J_3gdEB3MW;4eL$0itNY|X=kY-ig(URy= zlNGI~b;Eb0^QUg)YwTy*?%Wdo$MuvBj;V-#<>=I?KN$bI!!TT{BYLhI#_zYcCHQp-q-UE?q$?XwBssxZ{&>Cq~O zv)r6F^8Q%Tb7)(5lYEpe>D!G=5Y5GYCVio&)iTmxp9Zwr$l{WF49;YHv0k_jKVe5# z8t4Cx!hwxguk$rpW&R)-s$qzZU$Xi2;I?B#b5 zU!{2+dO~;e`Q+*p7igjLoy47Yf+rV^;Ppd&48695w}0~ptnF&RYv1w#=|0S4reg#cC9*8-^ z4^ZokeX+Yv2KKeE1+U>^KG%E~ys_K{`7bC;lYJ@m^6NOuHnKc zI`#ppN%4AM^u^|QXKHg|lbC~h-Y|aePejt2%LdWGjD+OcMd0O&{wT;5;;G}#m}V=5oK-d`s}>p!IjNA$+$SE6xhS_IY1 zt%&1})P^g&Z;=`>hhCd~n$!`lVEhk_qGr7-pm^O}eq-JHydkU)Z)Ny#aw6yx?X}IK zzW2+Skj$?!6yz@?BYM&lQZR$nB)2Vy-&TX7PxVr|u+%yUG_FKV`2Cn#J zLsjbVoD2Pyzs!BzEDUdFy=3lBj-`?P4>I!(jNk`2J|VlWUZSU_pW%O5FabwZOrjHw zZJ?Eo4R}2`NOwfm2Ce(OVaeX>^!hzd+%Pkbo?OC^7TO|k5ZvPh9a_YMe_TM*mfFFB z_nSd{!XJ7>IOCh+PLS@{7^ZGaru%Q@!svyU$=lm*WZHEemY-G;cRh~6N8j!7_Kg8> zf2|&7TpmY18BM2~=i3nP_ETxZZg%Y%Jrq_SuLXKtvoXOe6MKhLMGc)zWa?f4?%Ft< z*p9nM5B4&Hj7$^O&(I8XTLA4|xiWOhC`Scu2DoKaJvwjQLej$DfsC}!W&LyQ`Fnio z;j2xibpPCeI9JOOZgMA)K0$h5w!)o%qsnHe+IKwM51j?iy6j@2noK2CoId$YdbN~% zO^*QsyW#MBcNNlc$Tb@Ibu37BB!I5u0ja+~o9sNDO9ICqCWpt+x0GNboFzjO}bUGDDyzW@Tt~OJtWz2e#_a+4|{85h#%pHY$S**Hcw1ZT( z-9$S~SVvk<`_Ai2wqYvw40aD@eHG;ZnW2+Ot?7I5&=(I(9;nIBJK_KiyT0+0j{8?7h9wchPv(4%eq zIhp<}KKH_{Pp*+$yaVZ(hm+9keg^GUaUh&ZtqHL!0wK;O4xdIXC&Le{Cyj^Bgm>DX z7~Va7YCrcWahTf)e5O1k9?h5F*o~GnR1+}7Whj2QJBnIwo=lVZqrl5xCOa3qK)@q& zvTpVy(sNw(Q*+-*;$8KCHb$KYfqDeRI~4#444b_xx5@xE92edoAmsJ_cUbNN3!>fF>}1;1nhY5J6%BMV`q*N-MAwS z$Mn(1kLUV>Unc|T<=~C}b6)XZMVP|PCEIDkcD->ttF;cU8V_T=egI869{ zgslGG@&%d}hgr3nh!ol;VLk+l$x}z&K#Ig7u!vHMW!EYi}8<#&_@SaG4Id@W`!Q63GJ3KAI~>OZw{Yck{HAJ zmkF3PWjoCr?8w(1w3rO<-3vROX-f0@x5bB*XFy;RV>&9_h6LZf%qJrwa@#KI3_jWG z=$?*Z7-DDx7e2e<@Su70efPJdh4nk~IcXJE8MP8FMy@CO_bnk;I#0)FkuDCMcai76 z+>)N%bp-8v93l1G1)j@+j`-zzZRj?3I#Q=OnDMd^nQpk9dLDU97FIS#p-&WSyZVd_ zNjylFZx`VE54ADrct;#s_b@K#LeNxi6XAuog(0(#k*wwq$RMjgFpnAoueLP;zi$(; zMzlAq=xcGwreNJ?uJp_WF&_SIiM9=|k~iy27|(Id$gK3C;FK|y zCUcDIpZahe8@b0Y;*{%{LTO?_iILiP930^=T#(i_I%1coqCB@Tg{Lz zv*yvu>nMF0ZwqboCgJM&-Ld-2PK<|d27FtwinMrW3#PaaN7+<@`rnW8uUD|ABV8)+ zhEyvLjVHH-pLuhocEc; zyZ%~!_YpOrvEMx2QQv*!_`w%s(2EBo@|GvPrklqM9#szqe(nSH4?lt2N9l07@me_7 zFb#5VjHHKb0Mi$4$Gug;P-N5wTb`~C9x=yZa^C>lQGSwdvut}DwBrNaSkI7|dwURU z=d7W=D>O)6t%FScZR}@yxZy`Td;C9&&chMQ_Y31>l@%$95~V04lJP$0APp)Z8j?y% zQlThqJBnXkAZwq*Z=U$q*L<7eTxhZaWxd@g=dxDd007k|qV)>+W`jw?l57)n; z#ee$X^3GRjchY`Y?jjrh)IkX?*6zZ-8>?8B`IVZzb7e1-_kqL90rIl}wlpH}ICwaA zK)VZ(*qCfgFF)1L_5A;8U(9|%`A>CF?rn=c4G~y8e1h!KjSAuRIhI{EQRms(%lOIu z61bLHLfhO2QHhB;oqfGs99n%5mbcW>gGnyfIA$oe6cj;PPCROtcB6#9)A9YGIXFur z4K^=RW7Xkbh1ZsO=yFws*B@B`L+8h1x67r}(X@+9@#aHtI=+DxDVe~H%uk}`z&tVy zi{wu4r_=PMrnD-xl{(u1kJ@2NGauX_t)Z2e9P}S&$a6%KS}mD*K47(`J1@C(OmsJx z&dV#J@IMuO`ma|t3@DAH*r-@e;6D6K_c?zH-N#4Ub793qeN;QIDC-rXfLrncxL3kz z{QvAp6cOWZ58d@u!mfK9I8E^{T5bf8e-^!g;;pxA#7RXfiIc> zE7rHdtfyPWnhvgbQuj98Z7vY5NVD_je#)#Jb`lcwdkWzhlkrL28EAQRM1+}PcwU|h zr7tbP(exQz8{`9L_40Up7XujlKoL7Xdqv}Ctc9ZU;{=mE(?M;EKR$Bv#P0i%7sf6_ zjq(EQT(pBUSN(zl2OW;EA1nS?c8WfBk>R7eMK~mDJ|8t!;?(2^Y@?u!_xrEGu8;fU zkj5V{;NBYQ@<0tU|27DNeDc_L_&(}p4&1W3BTqWy3n7)$aM7`F+^Xq~*RJ}2Lb(z8 z-HU;YU4x;Z`VU1|%D7?Cc37($E3A2OR;Drf2`sS>gu*X5^iOxG5MMo*YKE#{YfA^# zjK2d<^g6KdOoSCDM~eUcD&p&1tDtc6L+JmhMDRK-qc7QNSg@lT_uIV?$61{xv!%&! z>0JuCdYGZR!$7u3?I`>mJ%_bT`(f@q1)ORzlN$2vcvpP|rVLz1FU+5S+Vev~&gw_7 zwYmZql)3U+y(%{AV}pOYjOBiIN68}DidF1v_;{NKM~&PiKAL)x7C6Z8Ld0}B;=}M* zuP@B-??snVlXz8xzWBb?g-48+n3z$0`FQV6LemCGuRd{C{8sNJb|OVw9^4bg9=yg4 z$%;ZJyMb(cMT;kxEa1P&irBAowdfG>4Gd!&;pCWJeALu{ds=vN#iKHMJJbZtfh%d zmEcNYi7=zYfs5h~gZI}VIPvpHm=xU~=9uk=&V99c?NS*PMy!$hUN^wXvxlj2yTI)) zvuTM(0QRk)!m7V}$yMjgL9O-r+vFsdtF|?9we99n9 z!GT}r?&0J0M_`E2HL~Sn+4Z?SzPxgcZr?TGT{T@fvPPYim2Q#a zd*FXEBeu2ZTz6wjA%`#83TdTswAp$RT5V_GmSu(5(^UsOcl!(PJ16qV#)X`ep~gC= zZ`1T!7WnqQo;=bAsX?FK9a+}Jb{LR1`CYMg;{ZHSNBaf5oV)(g5FM1;W zN5;LBS^jddBHo1Y?uH&w2iU$aRtrN8;|w}i_u6v2M?#aeeHE`9H^$pT!Xa#6g_xze2<`UTGgLekGh&KqxxFi^n~xFP z?k!}y+c)vRzyv&;eLk)yex4Rj zve5=qe`p9Qz8HwMu`(QQnI(5{7zZ0aj}?kSx4`j_e_-*w#loQDi7+#G64#X5;-V2& z*r?q|3mr9J(z6u)6&nHXI*muuxK&uP;~j*yZiQ2pt7-1cA{4y^oO~%)^qTJh8onBA zW$H@D&p6W>-#$|PwoAy-eQ=wDS4BE717aY&%#;u`V9HakKR{Ka1 z_XaM+`OlsB)z5e*%``dYe3enB%K|_8smY@&R&smzF~LT8Djn&qUY9q;fkSRSp|S~m zz*hSpWgWW@F(V&QjOshlJ7Wg2VTmij!>s70a#JcBG*sTp~JmqLCB9C(8ppD#wiX!3i4x$KXR*+&HThHcU8z zDrQQkQf|aSCl5hhyrh?V^bt=wdhmUndo(Y3Fb|K@e4cx2iR92nCqT5sM(J$yab z*e(t{S6Pd98a7atnmu11Q7C?~o63cbvxUyR!zCTHFt|B z<;w|iT9h{)U*3W8^;|gEyd&Suy~7RD6ZxIl2z+`go3>>XW0z}s;xp9(VP~HZEH0MV z@U^k5G{+8tK6(ow*JAkOv0_s0y$owZUyDJF(R}GiE*Cqjqea_mcoRQT#Yy4Xp^t7oz9h;lv-8A)uoN zX6}ASZEwT*&#Rj-F;S7nbx)FJ27R&kxH?YTJrSHTa=_X1C1-9-;47Bjog16?%DqRV z(n6y`&^z**c3iv8_m^tW?t!U1Y`YulZOGv7IyQLZzXBc@CWD59t|afW2hIm(z!&Ru z^fb>R_ct#{w?-W&&o27EA6HCRJV*R8T?eL%`>1`;S>cwZ3b{@mfr_a^cyQQo3~9az zX?qgbcU6$Ic8EXJ4aKq)EpX|%krpZ_!Ix73nAuB{gdQ{%Ir+*_H=mb`;TGI7e-&6ZyX#zXjQECu&=C zmgPFnWK*<{^X1Bw>~fz34bI&hgen$wm_GHb?1aG( zEQ>V3$gEm=)_Dakt*EC9WplV`OdM?M*azRtxkt@)H56GqjuyX-pnyex;rjSOZ2GTM z^6~~!U3w_Np9UVazZll)t8>Y#!?6E@)RcYRCR83Rg!UV9nqoMgeTsWyRf+@bOnL>a zf0uHH>2g?-c#tXs6uIzPZ}!Zdh`JV0n3T0xrnNDYFKDjeMN6j9e-n&(_w;7^^6)o> zWm5RFl|8 zbw54&iCld95`SA-!r%2HY2d{;w(yF^TIrlIuJ4QMb}QkkEyZB6G6c7FZlvRGU*NBS zKX0iUhVLtr=-7*B^t!naXK4Mjayizao8`oR2T{=F@-G z99~9+6dVPiXShj|f6RXguhXtGE^ye>u zK{%B5(t|JE@#2jd{#mGxJ{GF{yK$>f7N10^MJu==>kBwf|4H|sFUAMUHwu~i%~{Ob zMwGXe)xPZj-@-5OX%Laij}CnFgD+|J=*_Ra#$#ix#917b80@|qsYlxYo-Ofpx6gEd z@I|_8vhyp+FKJQdsh05lh7x}q^pP@@+hlnKccFEp0#5W2;kd3NF3NlXD>|NrH%EN% zi0fwZAC!O@=FxQb!yd5Nw^x2}j=%WyS63S46(!Ce90O~*)M3RoQ`YnwOuf!OhHF=I zQMO_SG^kvMD^I@RoT{A=vwSyAZP|(E&1Q00i!`@i*G;?&e%M3BPyRU9g8v@hAWK?& zjYO-RTzcdWt^3-IGIC8wzTBKkzqZ1aXC{1Q{wQwyX3suvz6m${qWM*6HI2}87w?|D zCYTOdk57&#qDF&*(DgtWyWh)|srF68vvF53(YOlt{jy^Hw*qD)OvLd&htsX(g>0Me zg@Y5mQ+o9WSkV6(RY~4M9iJrla94>vT9)v}ojWLdtS@;_spPDA?}YY4~W# z5IoTFCnQY|$9E-4^xAh7O;oO^^-y^s>|FL2>I7 zZuRuux?J8}+yM8Z4wIr@1iS8hB5A;#z0yFni?m%I@6nT z4_Q91H~LBZ!znF$HsJ3xGh7{9+?Cj<><&ElX@CP)x?%haMXGvQN$Q6el847A@=ms8 z-M2XuakPal)<*dp;YwmU^$mX`bbLRBGk&^DGwC3H{74h1=Vt75 zvln$3uZ;%xPC!fd;jBAc0k_Xn5T>l%4Kt3;;|l>>S+B8B9QoP{rxd%>$=%za#N7hV zsFm=2<5iq2Y-FYCWHxSF&xV5&dCuHY7!&#cjyd0lSuKOv#9iv|tnzrkonf%gGZM~- z?~YH|E`nM1WYUTph&$UQj#wCk`n%M*mp)Nk(i}K?IF?qlufcEq-_yyn7O+BXI`!Ez z0^fZ`OlC)R57y!z>l@*6{xfo35YFaq@hnSx0=p$%FkqNDDpho?J#>E|ygXhGuH9Nh zgQr14K<`;>SpR~WvRCq(K7ssx`3Ro=dMKF17^07NKMbqsL{($1V`at;LQgk7{COmQ zzL7$|m+ay#C7ZcQ<00w4Jt$^BNe0~*76S5<$+~tOs4p_+{w|a8^ohB2d{`$4Yq~?B z?Y>-kt(GpSg>s;k8m{FIcsk3B$8?t%iAlZc9)vf5jrCi|e>@Lc{*Hv;gwCwkK8%Aa z{|dH)p1`E%F&N|{m!-s|V}k{v)xclkzU3+uTT;)zuL2&e%z|5*^Xc6E6LdOutT?v1 zUf5`Fhdm3`pjUl&{Q4__xZ?+G*=Z)1SFVA;JU8HO zB^+4$o;q09-c@Rb|nZ5^7CkJDZ#?d*JyE^CnjLx)>~%ZN~1^qi9~iI?SkwB#)@| zLh|=}=(^MkRGyAUgH84H*w~2fZ@mg_`3mgN*PfHtc#?wq7Vv-8Kv8qMp=( z{Mj-e(qhs%p+|os<9e`Q~oJp z&!%;v$~zl!bn)Pz{i(SrB<6uBv%ou-1mM~g+&xC+&dEG#{xhE?@S*!0C3KfU#Z821*OHNg^pcHIS| zpZ1W{rD(h>^&wW(7ireW0x?HZ0guetK^qDjsC-=r8;|aW!?jez8=Eijfc5iG^pa|2 z_(|IiEag={mU4dYL_YJ;82>Fv!}Th&Sv74mPhH@Qx=S1+?d=9MY zQ#PI>=Q-E5vHse0cev^WV6#Dd;+%)Cmt7Tg7CfTA z;ai}+P#6E%+4JR7L$L3Gb;A9m-e|nLkek|mlc+chydHOfKKnXS{eO;pTlqK_F6%&{ z_WA5NSOvZOBXHyJH}p8XGiwR%{Cu!CYi`zjA7O2EEbmSm7geWrF)T<=yUWA=^m^QrsF%?ljvNGd(BZrce!Gpv;((pU%U~^FerOh$>63ms6AJ z2Rdo{l`_ZI!I<62;@rx9czgDGvYC5U(DwXDhc69br^{Urp!{~fLc9ifUDmxR{oYY4{Mq8kS1G*oxg@~!pFf}@V6T$HC5Bq-3qvOQ34i^ zK1Wfrm-FI|A3=S^d*Q{Ne%RsSYWlb1CvD2uLV;?YcsMVeuZNqni@h1TuF+#O-z0wB z)DNd*e}LF$)6hs&0ScETi|(JIadY2coF@4muFYIZeLpPYI|066(<21t_ZZC@ZX{f;*6`h;`c9ZShTo^e*D*&Yo_c5^Eo*CL=cZDpTR`LMeBs+1=NCWb{ zJRDZs4x~Llz5>5Yhw0zbg)PAYarAyCTDRIvy!pNxe~9Qz1L{snGiM#Na%cw24c%}? z&S37Aupd@C&OysB<-FixZ=Pa(AD+~HkeBu)2$A+<<}Gu!_6Wu!8!wW~#Y1!)X#jZm z8%!&+pv=XCggK90g=SZEzM)XTkM>;_qgxLNxQ=OC5 z>ak+aKo&fJe|en}|4Zo2Tf3?9)%)sD|KU2Nts2Jh<7Y@*aTH(dkb*M|dvTWC8Za54 zMh{Ns;wa1AxXgAr$UpT*9U&FJdJRRJs&1e<&xbmX$mcr)Iv|z3q5d=Mv8FWw*Y&8O z7x{~Ls_4ZR_7-sJrN6K(;~>;e3*qn+l(tHm$MCXic+be`E>hsJ;;uy2_HHairs=E6;~&aWbFJ|nI?u#h)B z{7kPlUl6?f3Nh*Z4qEnj2OO$yhKs>vw5b0(SlqouoZ0Xloc_uoEnSz7Jay)3#qYu# zK18GUtGnFqXyOvTYyeJLt%|?@=Av;*26(;D<(WYXx#(pW8SFHq<|T8*4^0zEMbgK% ztBR=qLORbMKBbzj3E2IVtt6e73kQ#N2m71Lv2$HB*mUsYI|q$qwG#yD6R{Fbm1&DB z^=jx@K$Ng+>Lni1D}(eCbIIwy&HUHAH~-1jz!O^=Av-mdZinBx8NRZ+3`P(JgVdCc>T{NSk$Kd`6+zriD@$LzbT z;A~7sUhGF*LAtXw(^!x=r(t8(prDXS+dQJ-vuzDc%8tY}QoXjPzXlH7w;uN9#ItqL zO3pxEUSDdC9`^!xNX#Y}qPm;M)py4BMj3h=^}}rIXde1vFuab?XZK@KsC6Y1KS)0P z<9Ceko@XcYE$_pdZR_~@X*)b;xfP3kl=0S>`@E{(BI2SQ;=7<23SR4m%Rhc0%by2? zp7%8c57(u*=k945f4ds|vV+Ca8WA@2R-|je>Ue*hltr~m2lj;CfP&NK!1Uk=eq){p zduGhSSHTxa_gDl+1sl=3%igS_P=JS}eQ5Jqi$7>&Qt3S<{FfQShNa4UvA8#nd$X4F zXGY?b-hbr-Bz~j1gE1=}8%}=Zqft9&HG0}4;>G@3n65I6TDuMAPF;pklV^Z|O{OsO zZk8a-(&qF@JE5q&C!`FVfFa+fVi)7n!saG#(vsK**URg8+28pba&)ES#W*Q6I7H$^ zBMp=r-WGaBs`26PirDK;Iv?*ei#c)w1-kU&@v+0X#(s+M=khW77rTjDPJbpnbtCB> z3Bo>V<`^H9Cs-=jV?RwZ=ny%GpA{Lx%b#Yv`;{UujCey$uCGWxX%MR0Md7zc3t-|3 zT^h0UzuGSoUQ&%mXWG)Z1#W6}V69S#Kechebt}$Ou+;19k)6icZKq&)+*^FDyb}&B z4(IB3$l9f4sP{RQH*4fl>X7w(tlWuXOf>l0TQ8BE0~zDuVUp4**78oI@7>n&AzzvB zci((a&{~Vdv4vpTrh@LpH(+;0GEst$_#|sTcns(UZs{qUw#*!N++Kxm3}%wT&PiN; z(E%P-hOw+}HJ=h~c%+{jUrAp@6Q&%a^o%2Y^z+Y<_Y(0NU#Ec)`94 zoZtUExZh9Xhwr=v%_S;4_KghqiR7P%Hs_;9?4+E6$>QZYOMZEBGmMxg={YXvD6`E; z+^%(tpR7;8RQn?IPacJ{wa37(pHg<+ppLw3R|FPWnR6$N^{jtHm0R97liKLP{70jZ zTCpF__&yBRo^BN9MgOFm?P`2|#eBGF(k`wyW>~lI7+fuJ#PJI8@V84RJS%J!2F)By zo^z~uh0y~DF1yRB_r*%ChPM$(9r9;EdgAp}fG8+QO|-wY>)xdnvQi z*!iN-XFdG2S`DlRF^u!ghlY=h@*JbZkl$aMKf6|v#edz=^HgU{-`^hb2L!)I!cr|xXvlSRAX<@fWV$>!BU{q*f1PF2Ng<8)A=O^schBY6DXqmXNy z1koL|De8BStk=sg^wdn9hnT)4L8`ef{CogAvpvzgO^5Tns_0jvGWt93qa{((_{j40 zwC`LAKeEVY&E|3rN%$u_T6<5p5w8und<-7Cw+q}#@~~^Fv*31M9vwKCf=9lc5XpDA z5Sl%Te-1F`yH_(Fxhx4FH7x;bDpYmg2xsNSUefhrJ7)XzNEi(4MwfwIk2LOA9baA9LDU8(PRbSO`>5x%aWos$S`|DrZ#qu;B&-;ifANQeFdKNaR6wz04 z5AFLZupGy6`bI05c{B?C)WmX9=tl9Nt#luDna2aKYSH~)s_0vVq`G)9ZVt-?g|GzN zHY-cm^CgXcKK%r#&V4bsERc6858zI!=gI4^KSZ)NCMVy8*s03kHA@C#{nD{tr7CHA z?1qH0doZO_FMQlUw7XIc@o9TOXR*Y{nPrGp_nuLOyBd!dSy+FeBefNI%T^B^#`hm< zv-c-$dESnGbAlW)VHPZo06Undwiv>W>l@Mg8c26W_; z78VXj#@Z|!+@RD#1*^(2uRIlfluJ48)e~N7wVw=Jd+~&NJJg*!iPK&<@cK(;LTt_t zYM5-uwmLFSePW9|?@i>9KT?GVtswTcz5;`$Yhyxb6qUBu ziT*S5AYG?3EwM`A>ie-A>Uaoev=OCMYxCsi7CdLu0~()yLRfikCy5Snm=Zk^k2o!) z^AELo!=wFDt*g#sZI6ma|D_Q;OrZR37P#1@Ufz4{b{bplNfT}KxIudj-Sf1;3j^Q6 z<$zR<8Kp|f%ah<@-c@?nWQ{upZ-Bl#HTm|Knb_=u_QnDi{6ls;o+m?>=d|wR zZfttCoz&+Sh`(DM(5vSeh{|8f-`bn#+u}i3wRQoHADb$$dA2mmwd8e0CaAMI7T2UW z@$5fW2Gt zaOe7Bej}8F;;=z%GU6er^*K(THfUq$?hg2FLLr~Nb)7~pRptJ_I)lEqju5WciL4&X z+ys96E-cOE+L{yCOxKS;@!f4g94FCX@F zuajxbvw(jsUL4>WL@J6CDb9HZ#T}~=x0z3)Y<3j3b-D!;TTS_=Jd#osDut5lyRiS? zUm9}3iDw*H2qO+e;>rUmFe7Frhkm#Y6W<(ziVGEdxW{aGHbv@dej9P%s`adC9gANs zsA1Sw{o4DPWz@sn9~Fv*^7i|;sP{z|ytceqT(hf?voB2I9xsE)Vqgx%pX`Au$CX%V zy-d8>2B=baRP42S6s~Pdl`kwV7rQ*O=Rd6h_&jqz7<_y|8^`X#hMY{Ymi|-!m7kmv z_Rhcw<{r4t|0{K{_r|E1r-c_2ed&o;H@529fh|is*xbhxAO7u!zs7&0MQOSm>Aw;y zD+Z(4NO!ik>VdsBJ%EJ@!|{szHB1^63m=@kIq^h)jHr7m9&cUAi+Y>z$B&CyZS-|A z=%s^=&S6}Mcfs=%;4Lu(vY+JvJV)HmFWxu&ir@U^{jZ z4~mOG{q4F~Fd#)@Mh5cl!9ytR7I3V8G91{Qirp>s@LX~;-7;N^g|%yG*yAib<~#u3 zDpU*i$LT=-MfV`|UN{woWXc!LF@}+mS80YpJv=_pj}3lZ2YJ3Drp5IaZ^e9oy!*AF zc{p8SS^m&dEC-`uT3FXUgG;9Up@6WM%c<0^ zH9-FKi8ZdfV9IGp$LaWYUp}9fC1sD~9eE=#D0}cV`>%{{7SV z!Go>5&#oH}9yb_j-*)8mr8;nAMptxOeW><;f-x>xGKI9icNfA249A3nrhIsfE#hn` zx2aPsw^vTVz`3ii@>L@FZJWuTuH}nXi=D}(n`ELevf-4UYshuMK47yH_R73OGsUmM zw$hoxpQa)FxnnB6S~voq8M+}H4r6hlGONFe;hx(~bdu?d_qQx4{G_EG|M! z%)_6*LvYP1Q}$ahjeAa8!C6f!Am`R*O16~PxIiC%JoyYioHi8~ds)$Xxe41WZKvf| z@<{Jb7C1sB)&D$!En)>G)vU!wqie<7BvUN;l@CEbv!qPHu3Y+BS#I^9FJ?}Yk^Dq5 z=`M=pKlk&Yv9b#fPqyK@q57<5?}iHJhC+>`13Fj#rK%5;u|rlWtX%7Yqxba^U-jC| z4-R@mV)`_^^Sp$5Xa#b(dNWu|?n&i6hS9Z+PJGUEBVRT-$nJNQagxex&~7cp-g!H$ew~F{qbwldPZ!8|GZQ<8pQ8D#w>0_jfDPoBna8PfFVH^Cow!cQ1~r`3gH=*`a>$8U_}N#|DEc}>(=aEjwjPVQQ)Keq zq=DTlhKTN`<5+$(70R}|^Cyj)a2K-VRv%6ILHt8FdddLXYf8zkr#W3b(9C-$ETNRr zT!_7AAUeGb#a>g(g}6j_+Cc~TO=ovm51c;q7nFHRtS6qO zO$iP1r_cR_+9-3(_4pztK6wmxO(#;#^z_<6O-iWs!%Voa>o3f2*TD4`3ux^xJ$PZD zhWFI+(19EwLVk+&CfA9_lHbtvHQI1ioCdbjx(FV88ywfJfgc~vQ*B-?-!=}0bNU(R zzq^@6`x?<3-x=K8@dD*`m;;eJI)ZlZ6@1a5A7~h>W52N{IZQE{pLzyxqFq0H7V3bF zU+2<%$x-d~Q%k7O>B;7kZb9j1J8X&{$Sti*RmTFT!w3Zo`uau6;@?YKjvG?4-Fdp8 z@6WOx|ENo(qj+uBL#S?7#0zCz;cm1c>~c$ls~3l|x8_q=L|vfwdtF>}>mIF+FJa5> zL;2aS-;l5ViNwTST+>ZQ@<5eR^2SBn?>{vf)+-6@`ioT7w;AUB?0}PGJ-9~259iu! zugxx=z=QWjbH`cT=#)ZNK3V$)3eN>&a)=VU96Tkvep=> z!-$ezeC^kJ+P}IN}&ukGl?qW8FAt z+dghM9mw@gSE1E)A-$ab10L=@fKHxPDfCG)#cJxKX@lP%}AQ zs}}c%4#$}*nrY#K;W)ZJ9rTy(M!Srq_*QQ^KC73qi{>5`M}OJ@H>BD;<0N*=p)JMGF>+}yyB;Ng3%3X5xNrk5y zGqLj;3l5p$gd5g|!N4{Jobu@uMXv56Tsm&Zi{>}b+2FqX=BlaOJi>r8r{u6kzY4Lv z!i%HVMX_N@08c+X6<1G_i+zmViB%R392#|9Yz^4L?)9rkrDL`5O2?WftxlsDPfO8O z9L0z4-s6H}y*L_{^TgYsG-O!JNN{6P9$srK2v>oQ#ef$%`TcCgP}qH57PEgqtgK z=+E07^1}IksC=_Tta$6iFV76;ThCNc{^qeAP`ivE@(92n(~4iBb6*YN-7x#o6$_H_uTn{DI~&s^EOaFftJ za1TAZ?1v+NjYT!rBz)Uf5jUJ(Ov$sA;n_nq^fmZFpU0A@`(e6}l5v>g&zzv#lVKP-BTEDxXlp4WrgW`jTdnH>ILiqz&F*EQ9%4Ju!CK z6LK@m7mNlMK!mnGxdlo3rQvJ1BW1AK9ox&P%iC#iwHAN>JWS#@S=98O$tE3x(00=a ztZ?gwPkZ|DuQes`-YOK8iiXqasy|}bgM+lE!3?4wrLg%pUwmn)fHPeGz&qJqT43f( zABHq>>zrmDyHX#21vs(W)ZJuptPl7o@5i@y;xXCxhLBn}gvSj2BwATlKx6+J`crZU z;+sFoOhW#EW1syL`*S6A55G>e?GMPe%R4X)c~7N7X25_k2BPfPP>Ar9%cp1b=2I73 zXxWFowZZG=i*uyh8Lc=E8rM1m4Ug7P;m92E+Cyj2MXwVJPYuz@Y$R#F-$bUr|A67g zet2*DH(^xpKN$Q-9Xq_yN3S_r=+H3>_NZI%1SM_$-QSzbQhIURw|v_6YmfLKx)<6O z%*L=q&g>kR%m$CPu$5F(oO&m*zt(P2#@a0Gt7XN%$Nvz2nVRAG+A>+`uwq!^7{&gM zojDN_+3-U59Yy($UH~2bZ6VUTNj{RO(<4$*+$waTOm-XH(qP#AsZdI9}M4ahmZyhTo(BZ{!MrX z#V&E&(r**%2S_=6zcRUddo4qKE43Kd%4anyP*RW=CKy|BYx^PCx7QZuUjHj;yUHw! zcjwA=U4+;}c{H-Nm~>7?fc^;!8LR4Ha#1eDrVfNlQoi}f0uL^l?Mi3v3`d)LQeM{K z5>&VwgZ~Y$1BW4>#RkRMXff+GXy`nF`u*kNBUuWFx0>L@A$wlh+mNHqexjq_)G#uj ziVnFhr;hhWfqc_8nsCFBF9+?W;l)kh0O6$a?y0=bkp~pLVm3BCEa15I7V>#`T@(-q@(4xN?Fe&^m3_P4n+aynb&x#(XZj~*}o4x}ZuMEMBW0iS>O&As{d4Zp4 zCd`t27O|4QYjzKB&^tE?0`6-dYLB71MMIc=tE0Hm8uTiE3t=~Gxin`8*DZCSBFpaZ zW|5j$_f`?JSG=QthUZ}N(sAr_qzckcYvAg_C*q(OZ@e?>Jsi*914dnpBqpPjCOwpX zi#P>cauz_$2XDT+Z#|!@k`f@^JcK`qmSk~aG0k4S2}VZ8V@=={+GEodC%^nb-IW}1 z&(_}jF8GenhQ84FMg`AJ_Qm^Gi#W?;5D#75K%vDt5~;x0pDbubq$KSR$}2jhs7 zopJ8)YjEk>33_}&pC`K+VFD{*i@yq|rzOLvSrgcA+6<`AIR^hshvVSXQgG?=1!5Dl z`QgrI;1(E$d{+d!t=V8~+*9gDa!Hwwh=)rBoG_+0Ds5ST8AoHNY{bV0t&XG{`8C@lm%7BEB(^;^a z^bKMb#^R8BNMpV_v5>k^xDeognhpM&Z5XAko*)>$_XX7p zF9aWj0eEwoCspZg5<~h{bBpB9-jRs>a2TTFr(JZ#uvOUB&53&|KPIEbEcEFgf>jf= zF=zf=%B0Ek0sbS0TWz3L=mGaPXz`9EGU0mId>&?*%xPA=Ia(_n^M@61gq8vy{U`aR zH?9>|Hdlyl$!j>Q#t&np+UTVJYksJDn?i1Cish+x#7mP{Wn?K$-7rJAqq~i|XLjZI zRe#}X)qU#xqEfzYkmRL4+Xd|v5YM%Q;;+SNxINMWFLqx|=U=Yjsm7zQwW@?JPBLSq zxJ$6HG6%;$KPx))m$b++i};bY9=(w~$&cQ<;!P8gHpeBGi>y)xY4d z#ZR>9S}$($F6M1%o|I8K56X)+@c8yW^!Q3ov7{mzs&}jNL9^aGGp>fNbl=O*i&gpO zxijGSB!(AD7ar{wHwF ze83%FcVR^OC*cpwMb≻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 |M1Xs)TDavgW7wb>23Rz`CF?Tx2W-)`0- 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 z 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

$A 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 +7>`-Q8u$ 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≀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%0A{>?2+vxMF+SGx36VmR`n7m>T`C^+LQ<$% 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%0DE&rV08fvF!mv6~h2n@nRXx_ZD| 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 Zij%A1K(?}kx&;Q#ST;g}BO=1.3.0", + "livekit-api", + "livekit-protocol", + "livekit-wakeword>=0.1.1", + "python-dotenv>=1.0.0", + "sounddevice>=0.4.6", +] + +[tool.uv.sources] +livekit = { path = "../../livekit-rtc", editable = true } +livekit-api = { path = "../../livekit-api", editable = true } +livekit-protocol = { path = "../../livekit-protocol", editable = true } diff --git a/examples/wakeword_agent_dispatch/uv.lock b/examples/wakeword_agent_dispatch/uv.lock new file mode 100644 index 00000000..12a51cb6 --- /dev/null +++ b/examples/wakeword_agent_dispatch/uv.lock @@ -0,0 +1,2132 @@ +version = 1 +revision = 2 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.13'", + "python_full_version < '3.13'", +] + +[[package]] +name = "aiofiles" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/41/c3/534eac40372d8ee36ef40df62ec129bee4fdb5ad9706e58a29be53b2c970/aiofiles-25.1.0.tar.gz", hash = "sha256:a8d728f0a29de45dc521f18f07297428d56992a742f0cd2701ba86e44d23d5b2", size = 46354, upload-time = "2025-10-09T20:51:04.358Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/8a/340a1555ae33d7354dbca4faa54948d76d89a27ceef032c8c3bc661d003e/aiofiles-25.1.0-py3-none-any.whl", hash = "sha256:abe311e527c862958650f9438e859c1fa7568a141b22abcd015e120e86a85695", size = 14668, upload-time = "2025-10-09T20:51:03.174Z" }, +] + +[[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.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/f5/a20c4ac64aeaef1679e25c9983573618ff765d7aa829fa2b84ae7573169e/aiohttp-3.13.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ab7229b6f9b5c1ba4910d6c41a9eb11f543eadb3f384df1b4c293f4e73d44d6", size = 757513, upload-time = "2026-03-31T21:57:02.146Z" }, + { url = "https://files.pythonhosted.org/packages/75/0a/39fa6c6b179b53fcb3e4b3d2b6d6cad0180854eda17060c7218540102bef/aiohttp-3.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8f14c50708bb156b3a3ca7230b3d820199d56a48e3af76fa21c2d6087190fe3d", size = 506748, upload-time = "2026-03-31T21:57:04.275Z" }, + { url = "https://files.pythonhosted.org/packages/87/ec/e38ce072e724fd7add6243613f8d1810da084f54175353d25ccf9f9c7e5a/aiohttp-3.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e7d2f8616f0ff60bd332022279011776c3ac0faa0f1b463f7bb12326fbc97a1c", size = 501673, upload-time = "2026-03-31T21:57:06.208Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ba/3bc7525d7e2beaa11b309a70d48b0d3cfc3c2089ec6a7d0820d59c657053/aiohttp-3.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2567b72e1ffc3ab25510db43f355b29eeada56c0a622e58dcdb19530eb0a3cb", size = 1763757, upload-time = "2026-03-31T21:57:07.882Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ab/e87744cf18f1bd78263aba24924d4953b41086bd3a31d22452378e9028a0/aiohttp-3.13.5-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fb0540c854ac9c0c5ad495908fdfd3e332d553ec731698c0e29b1877ba0d2ec6", size = 1720152, upload-time = "2026-03-31T21:57:09.946Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f3/ed17a6f2d742af17b50bae2d152315ed1b164b07a5fd5cc1754d99e4dfa5/aiohttp-3.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9883051c6972f58bfc4ebb2116345ee2aa151178e99c3f2b2bbe2af712abd13", size = 1818010, upload-time = "2026-03-31T21:57:12.157Z" }, + { url = "https://files.pythonhosted.org/packages/53/06/ecbc63dc937192e2a5cb46df4d3edb21deb8225535818802f210a6ea5816/aiohttp-3.13.5-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2294172ce08a82fb7c7273485895de1fa1186cc8294cfeb6aef4af42ad261174", size = 1907251, upload-time = "2026-03-31T21:57:14.023Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a5/0521aa32c1ddf3aa1e71dcc466be0b7db2771907a13f18cddaa45967d97b/aiohttp-3.13.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3a807cabd5115fb55af198b98178997a5e0e57dead43eb74a93d9c07d6d4a7dc", size = 1759969, upload-time = "2026-03-31T21:57:16.146Z" }, + { url = "https://files.pythonhosted.org/packages/f6/78/a38f8c9105199dd3b9706745865a8a59d0041b6be0ca0cc4b2ccf1bab374/aiohttp-3.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:aa6d0d932e0f39c02b80744273cd5c388a2d9bc07760a03164f229c8e02662f6", size = 1616871, upload-time = "2026-03-31T21:57:17.856Z" }, + { url = "https://files.pythonhosted.org/packages/6f/41/27392a61ead8ab38072105c71aa44ff891e71653fe53d576a7067da2b4e8/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:60869c7ac4aaabe7110f26499f3e6e5696eae98144735b12a9c3d9eae2b51a49", size = 1739844, upload-time = "2026-03-31T21:57:19.679Z" }, + { url = "https://files.pythonhosted.org/packages/6e/55/5564e7ae26d94f3214250009a0b1c65a0c6af4bf88924ccb6fdab901de28/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:26d2f8546f1dfa75efa50c3488215a903c0168d253b75fba4210f57ab77a0fb8", size = 1731969, upload-time = "2026-03-31T21:57:22.006Z" }, + { url = "https://files.pythonhosted.org/packages/6d/c5/705a3929149865fc941bcbdd1047b238e4a72bcb215a9b16b9d7a2e8d992/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1162a1492032c82f14271e831c8f4b49f2b6078f4f5fc74de2c912fa225d51d", size = 1795193, upload-time = "2026-03-31T21:57:24.256Z" }, + { url = "https://files.pythonhosted.org/packages/a6/19/edabed62f718d02cff7231ca0db4ef1c72504235bc467f7b67adb1679f48/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8b14eb3262fad0dc2f89c1a43b13727e709504972186ff6a99a3ecaa77102b6c", size = 1606477, upload-time = "2026-03-31T21:57:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/de/fc/76f80ef008675637d88d0b21584596dc27410a990b0918cb1e5776545b5b/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ca9ac61ac6db4eb6c2a0cd1d0f7e1357647b638ccc92f7e9d8d133e71ed3c6ac", size = 1813198, upload-time = "2026-03-31T21:57:28.316Z" }, + { url = "https://files.pythonhosted.org/packages/e5/67/5b3ac26b80adb20ea541c487f73730dc8fa107d632c998f25bbbab98fcda/aiohttp-3.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7996023b2ed59489ae4762256c8516df9820f751cf2c5da8ed2fb20ee50abab3", size = 1752321, upload-time = "2026-03-31T21:57:30.549Z" }, + { url = "https://files.pythonhosted.org/packages/88/06/e4a2e49255ea23fa4feeb5ab092d90240d927c15e47b5b5c48dff5a9ce29/aiohttp-3.13.5-cp311-cp311-win32.whl", hash = "sha256:77dfa48c9f8013271011e51c00f8ada19851f013cde2c48fca1ba5e0caf5bb06", size = 439069, upload-time = "2026-03-31T21:57:32.388Z" }, + { url = "https://files.pythonhosted.org/packages/c0/43/8c7163a596dab4f8be12c190cf467a1e07e4734cf90eebb39f7f5d53fc6a/aiohttp-3.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:d3a4834f221061624b8887090637db9ad4f61752001eae37d56c52fddade2dc8", size = 462859, upload-time = "2026-03-31T21:57:34.455Z" }, + { url = "https://files.pythonhosted.org/packages/be/6f/353954c29e7dcce7cf00280a02c75f30e133c00793c7a2ed3776d7b2f426/aiohttp-3.13.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:023ecba036ddd840b0b19bf195bfae970083fd7024ce1ac22e9bba90464620e9", size = 748876, upload-time = "2026-03-31T21:57:36.319Z" }, + { url = "https://files.pythonhosted.org/packages/f5/1b/428a7c64687b3b2e9cd293186695affc0e1e54a445d0361743b231f11066/aiohttp-3.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15c933ad7920b7d9a20de151efcd05a6e38302cbf0e10c9b2acb9a42210a2416", size = 499557, upload-time = "2026-03-31T21:57:38.236Z" }, + { url = "https://files.pythonhosted.org/packages/29/47/7be41556bfbb6917069d6a6634bb7dd5e163ba445b783a90d40f5ac7e3a7/aiohttp-3.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab2899f9fa2f9f741896ebb6fa07c4c883bfa5c7f2ddd8cf2aafa86fa981b2d2", size = 500258, upload-time = "2026-03-31T21:57:39.923Z" }, + { url = "https://files.pythonhosted.org/packages/67/84/c9ecc5828cb0b3695856c07c0a6817a99d51e2473400f705275a2b3d9239/aiohttp-3.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60eaa2d440cd4707696b52e40ed3e2b0f73f65be07fd0ef23b6b539c9c0b0b4", size = 1749199, upload-time = "2026-03-31T21:57:41.938Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d3/3c6d610e66b495657622edb6ae7c7fd31b2e9086b4ec50b47897ad6042a9/aiohttp-3.13.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:55b3bdd3292283295774ab585160c4004f4f2f203946997f49aac032c84649e9", size = 1721013, upload-time = "2026-03-31T21:57:43.904Z" }, + { url = "https://files.pythonhosted.org/packages/49/a0/24409c12217456df0bae7babe3b014e460b0b38a8e60753d6cb339f6556d/aiohttp-3.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2b2355dc094e5f7d45a7bb262fe7207aa0460b37a0d87027dcf21b5d890e7d5", size = 1781501, upload-time = "2026-03-31T21:57:46.285Z" }, + { url = "https://files.pythonhosted.org/packages/98/9d/b65ec649adc5bccc008b0957a9a9c691070aeac4e41cea18559fef49958b/aiohttp-3.13.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b38765950832f7d728297689ad78f5f2cf79ff82487131c4d26fe6ceecdc5f8e", size = 1878981, upload-time = "2026-03-31T21:57:48.734Z" }, + { url = "https://files.pythonhosted.org/packages/57/d8/8d44036d7eb7b6a8ec4c5494ea0c8c8b94fbc0ed3991c1a7adf230df03bf/aiohttp-3.13.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b18f31b80d5a33661e08c89e202edabf1986e9b49c42b4504371daeaa11b47c1", size = 1767934, upload-time = "2026-03-31T21:57:51.171Z" }, + { url = "https://files.pythonhosted.org/packages/31/04/d3f8211f273356f158e3464e9e45484d3fb8c4ce5eb2f6fe9405c3273983/aiohttp-3.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:33add2463dde55c4f2d9635c6ab33ce154e5ecf322bd26d09af95c5f81cfa286", size = 1566671, upload-time = "2026-03-31T21:57:53.326Z" }, + { url = "https://files.pythonhosted.org/packages/41/db/073e4ebe00b78e2dfcacff734291651729a62953b48933d765dc513bf798/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:327cc432fdf1356fb4fbc6fe833ad4e9f6aacb71a8acaa5f1855e4b25910e4a9", size = 1705219, upload-time = "2026-03-31T21:57:55.385Z" }, + { url = "https://files.pythonhosted.org/packages/48/45/7dfba71a2f9fd97b15c95c06819de7eb38113d2cdb6319669195a7d64270/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7c35b0bf0b48a70b4cb4fc5d7bed9b932532728e124874355de1a0af8ec4bc88", size = 1743049, upload-time = "2026-03-31T21:57:57.341Z" }, + { url = "https://files.pythonhosted.org/packages/18/71/901db0061e0f717d226386a7f471bb59b19566f2cae5f0d93874b017271f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:df23d57718f24badef8656c49743e11a89fd6f5358fa8a7b96e728fda2abf7d3", size = 1749557, upload-time = "2026-03-31T21:57:59.626Z" }, + { url = "https://files.pythonhosted.org/packages/08/d5/41eebd16066e59cd43728fe74bce953d7402f2b4ddfdfef2c0e9f17ca274/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:02e048037a6501a5ec1f6fc9736135aec6eb8a004ce48838cb951c515f32c80b", size = 1558931, upload-time = "2026-03-31T21:58:01.972Z" }, + { url = "https://files.pythonhosted.org/packages/30/e6/4a799798bf05740e66c3a1161079bda7a3dd8e22ca392481d7a7f9af82a6/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31cebae8b26f8a615d2b546fee45d5ffb76852ae6450e2a03f42c9102260d6fe", size = 1774125, upload-time = "2026-03-31T21:58:04.007Z" }, + { url = "https://files.pythonhosted.org/packages/84/63/7749337c90f92bc2cb18f9560d67aa6258c7060d1397d21529b8004fcf6f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:888e78eb5ca55a615d285c3c09a7a91b42e9dd6fc699b166ebd5dee87c9ccf14", size = 1732427, upload-time = "2026-03-31T21:58:06.337Z" }, + { url = "https://files.pythonhosted.org/packages/98/de/cf2f44ff98d307e72fb97d5f5bbae3bfcb442f0ea9790c0bf5c5c2331404/aiohttp-3.13.5-cp312-cp312-win32.whl", hash = "sha256:8bd3ec6376e68a41f9f95f5ed170e2fcf22d4eb27a1f8cb361d0508f6e0557f3", size = 433534, upload-time = "2026-03-31T21:58:08.712Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ca/eadf6f9c8fa5e31d40993e3db153fb5ed0b11008ad5d9de98a95045bed84/aiohttp-3.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:110e448e02c729bcebb18c60b9214a87ba33bac4a9fa5e9a5f139938b56c6cb1", size = 460446, upload-time = "2026-03-31T21:58:10.945Z" }, + { url = "https://files.pythonhosted.org/packages/78/e9/d76bf503005709e390122d34e15256b88f7008e246c4bdbe915cd4f1adce/aiohttp-3.13.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5029cc80718bbd545123cd8fe5d15025eccaaaace5d0eeec6bd556ad6163d61", size = 742930, upload-time = "2026-03-31T21:58:13.155Z" }, + { url = "https://files.pythonhosted.org/packages/57/00/4b7b70223deaebd9bb85984d01a764b0d7bd6526fcdc73cca83bcbe7243e/aiohttp-3.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bb6bf5811620003614076bdc807ef3b5e38244f9d25ca5fe888eaccea2a9832", size = 496927, upload-time = "2026-03-31T21:58:15.073Z" }, + { url = "https://files.pythonhosted.org/packages/9c/f5/0fb20fb49f8efdcdce6cd8127604ad2c503e754a8f139f5e02b01626523f/aiohttp-3.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a84792f8631bf5a94e52d9cc881c0b824ab42717165a5579c760b830d9392ac9", size = 497141, upload-time = "2026-03-31T21:58:17.009Z" }, + { url = "https://files.pythonhosted.org/packages/3b/86/b7c870053e36a94e8951b803cb5b909bfbc9b90ca941527f5fcafbf6b0fa/aiohttp-3.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57653eac22c6a4c13eb22ecf4d673d64a12f266e72785ab1c8b8e5940d0e8090", size = 1732476, upload-time = "2026-03-31T21:58:18.925Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e5/4e161f84f98d80c03a238671b4136e6530453d65262867d989bbe78244d0/aiohttp-3.13.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5e5f7debc7a57af53fdf5c5009f9391d9f4c12867049d509bf7bb164a6e295b", size = 1706507, upload-time = "2026-03-31T21:58:21.094Z" }, + { url = "https://files.pythonhosted.org/packages/d4/56/ea11a9f01518bd5a2a2fcee869d248c4b8a0cfa0bb13401574fa31adf4d4/aiohttp-3.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c719f65bebcdf6716f10e9eff80d27567f7892d8988c06de12bbbd39307c6e3a", size = 1773465, upload-time = "2026-03-31T21:58:23.159Z" }, + { url = "https://files.pythonhosted.org/packages/eb/40/333ca27fb74b0383f17c90570c748f7582501507307350a79d9f9f3c6eb1/aiohttp-3.13.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d97f93fdae594d886c5a866636397e2bcab146fd7a132fd6bb9ce182224452f8", size = 1873523, upload-time = "2026-03-31T21:58:25.59Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d2/e2f77eef1acb7111405433c707dc735e63f67a56e176e72e9e7a2cd3f493/aiohttp-3.13.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df334e39d4c2f899a914f1dba283c1aadc311790733f705182998c6f7cae665", size = 1754113, upload-time = "2026-03-31T21:58:27.624Z" }, + { url = "https://files.pythonhosted.org/packages/fb/56/3f653d7f53c89669301ec9e42c95233e2a0c0a6dd051269e6e678db4fdb0/aiohttp-3.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe6970addfea9e5e081401bcbadf865d2b6da045472f58af08427e108d618540", size = 1562351, upload-time = "2026-03-31T21:58:29.918Z" }, + { url = "https://files.pythonhosted.org/packages/ec/a6/9b3e91eb8ae791cce4ee736da02211c85c6f835f1bdfac0594a8a3b7018c/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7becdf835feff2f4f335d7477f121af787e3504b48b449ff737afb35869ba7bb", size = 1693205, upload-time = "2026-03-31T21:58:32.214Z" }, + { url = "https://files.pythonhosted.org/packages/98/fc/bfb437a99a2fcebd6b6eaec609571954de2ed424f01c352f4b5504371dd3/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:676e5651705ad5d8a70aeb8eb6936c436d8ebbd56e63436cb7dd9bb36d2a9a46", size = 1730618, upload-time = "2026-03-31T21:58:34.728Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b6/c8534862126191a034f68153194c389addc285a0f1347d85096d349bbc15/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:9b16c653d38eb1a611cc898c41e76859ca27f119d25b53c12875fd0474ae31a8", size = 1745185, upload-time = "2026-03-31T21:58:36.909Z" }, + { url = "https://files.pythonhosted.org/packages/0b/93/4ca8ee2ef5236e2707e0fd5fecb10ce214aee1ff4ab307af9c558bda3b37/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:999802d5fa0389f58decd24b537c54aa63c01c3219ce17d1214cbda3c2b22d2d", size = 1557311, upload-time = "2026-03-31T21:58:39.38Z" }, + { url = "https://files.pythonhosted.org/packages/57/ae/76177b15f18c5f5d094f19901d284025db28eccc5ae374d1d254181d33f4/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ec707059ee75732b1ba130ed5f9580fe10ff75180c812bc267ded039db5128c6", size = 1773147, upload-time = "2026-03-31T21:58:41.476Z" }, + { url = "https://files.pythonhosted.org/packages/01/a4/62f05a0a98d88af59d93b7fcac564e5f18f513cb7471696ac286db970d6a/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d6d44a5b48132053c2f6cd5c8cb14bc67e99a63594e336b0f2af81e94d5530c", size = 1730356, upload-time = "2026-03-31T21:58:44.049Z" }, + { url = "https://files.pythonhosted.org/packages/e4/85/fc8601f59dfa8c9523808281f2da571f8b4699685f9809a228adcc90838d/aiohttp-3.13.5-cp313-cp313-win32.whl", hash = "sha256:329f292ed14d38a6c4c435e465f48bebb47479fd676a0411936cc371643225cc", size = 432637, upload-time = "2026-03-31T21:58:46.167Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1b/ac685a8882896acf0f6b31d689e3792199cfe7aba37969fa91da63a7fa27/aiohttp-3.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:69f571de7500e0557801c0b51f4780482c0ec5fe2ac851af5a92cfce1af1cb83", size = 458896, upload-time = "2026-03-31T21:58:48.119Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ce/46572759afc859e867a5bc8ec3487315869013f59281ce61764f76d879de/aiohttp-3.13.5-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:eb4639f32fd4a9904ab8fb45bf3383ba71137f3d9d4ba25b3b3f3109977c5b8c", size = 745721, upload-time = "2026-03-31T21:58:50.229Z" }, + { url = "https://files.pythonhosted.org/packages/13/fe/8a2efd7626dbe6049b2ef8ace18ffda8a4dfcbe1bcff3ac30c0c7575c20b/aiohttp-3.13.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:7e5dc4311bd5ac493886c63cbf76ab579dbe4641268e7c74e48e774c74b6f2be", size = 497663, upload-time = "2026-03-31T21:58:52.232Z" }, + { url = "https://files.pythonhosted.org/packages/9b/91/cc8cc78a111826c54743d88651e1687008133c37e5ee615fee9b57990fac/aiohttp-3.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:756c3c304d394977519824449600adaf2be0ccee76d206ee339c5e76b70ded25", size = 499094, upload-time = "2026-03-31T21:58:54.566Z" }, + { url = "https://files.pythonhosted.org/packages/0a/33/a8362cb15cf16a3af7e86ed11962d5cd7d59b449202dc576cdc731310bde/aiohttp-3.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecc26751323224cf8186efcf7fbcbc30f4e1d8c7970659daf25ad995e4032a56", size = 1726701, upload-time = "2026-03-31T21:58:56.864Z" }, + { url = "https://files.pythonhosted.org/packages/45/0c/c091ac5c3a17114bd76cbf85d674650969ddf93387876cf67f754204bd77/aiohttp-3.13.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10a75acfcf794edf9d8db50e5a7ec5fc818b2a8d3f591ce93bc7b1210df016d2", size = 1683360, upload-time = "2026-03-31T21:58:59.072Z" }, + { url = "https://files.pythonhosted.org/packages/23/73/bcee1c2b79bc275e964d1446c55c54441a461938e70267c86afaae6fba27/aiohttp-3.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f7a18f258d124cd678c5fe072fe4432a4d5232b0657fca7c1847f599233c83a", size = 1773023, upload-time = "2026-03-31T21:59:01.776Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ef/720e639df03004fee2d869f771799d8c23046dec47d5b81e396c7cda583a/aiohttp-3.13.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:df6104c009713d3a89621096f3e3e88cc323fd269dbd7c20afe18535094320be", size = 1853795, upload-time = "2026-03-31T21:59:04.568Z" }, + { url = "https://files.pythonhosted.org/packages/bd/c9/989f4034fb46841208de7aeeac2c6d8300745ab4f28c42f629ba77c2d916/aiohttp-3.13.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:241a94f7de7c0c3b616627aaad530fe2cb620084a8b144d3be7b6ecfe95bae3b", size = 1730405, upload-time = "2026-03-31T21:59:07.221Z" }, + { url = "https://files.pythonhosted.org/packages/ce/75/ee1fd286ca7dc599d824b5651dad7b3be7ff8d9a7e7b3fe9820d9180f7db/aiohttp-3.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c974fb66180e58709b6fc402846f13791240d180b74de81d23913abe48e96d94", size = 1558082, upload-time = "2026-03-31T21:59:09.484Z" }, + { url = "https://files.pythonhosted.org/packages/c3/20/1e9e6650dfc436340116b7aa89ff8cb2bbdf0abc11dfaceaad8f74273a10/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6e27ea05d184afac78aabbac667450c75e54e35f62238d44463131bd3f96753d", size = 1692346, upload-time = "2026-03-31T21:59:12.068Z" }, + { url = "https://files.pythonhosted.org/packages/d8/40/8ebc6658d48ea630ac7903912fe0dd4e262f0e16825aa4c833c56c9f1f56/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a79a6d399cef33a11b6f004c67bb07741d91f2be01b8d712d52c75711b1e07c7", size = 1698891, upload-time = "2026-03-31T21:59:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/d8/78/ea0ae5ec8ba7a5c10bdd6e318f1ba5e76fcde17db8275188772afc7917a4/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c632ce9c0b534fbe25b52c974515ed674937c5b99f549a92127c85f771a78772", size = 1742113, upload-time = "2026-03-31T21:59:17.068Z" }, + { url = "https://files.pythonhosted.org/packages/8a/66/9d308ed71e3f2491be1acb8769d96c6f0c47d92099f3bc9119cada27b357/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fceedde51fbd67ee2bcc8c0b33d0126cc8b51ef3bbde2f86662bd6d5a6f10ec5", size = 1553088, upload-time = "2026-03-31T21:59:19.541Z" }, + { url = "https://files.pythonhosted.org/packages/da/a6/6cc25ed8dfc6e00c90f5c6d126a98e2cf28957ad06fa1036bd34b6f24a2c/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f92995dfec9420bb69ae629abf422e516923ba79ba4403bc750d94fb4a6c68c1", size = 1757976, upload-time = "2026-03-31T21:59:22.311Z" }, + { url = "https://files.pythonhosted.org/packages/c1/2b/cce5b0ffe0de99c83e5e36d8f828e4161e415660a9f3e58339d07cce3006/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20ae0ff08b1f2c8788d6fb85afcb798654ae6ba0b747575f8562de738078457b", size = 1712444, upload-time = "2026-03-31T21:59:24.635Z" }, + { url = "https://files.pythonhosted.org/packages/6c/cf/9e1795b4160c58d29421eafd1a69c6ce351e2f7c8d3c6b7e4ca44aea1a5b/aiohttp-3.13.5-cp314-cp314-win32.whl", hash = "sha256:b20df693de16f42b2472a9c485e1c948ee55524786a0a34345511afdd22246f3", size = 438128, upload-time = "2026-03-31T21:59:27.291Z" }, + { url = "https://files.pythonhosted.org/packages/22/4d/eaedff67fc805aeba4ba746aec891b4b24cebb1a7d078084b6300f79d063/aiohttp-3.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:f85c6f327bf0b8c29da7d93b1cabb6363fb5e4e160a32fa241ed2dce21b73162", size = 464029, upload-time = "2026-03-31T21:59:29.429Z" }, + { url = "https://files.pythonhosted.org/packages/79/11/c27d9332ee20d68dd164dc12a6ecdef2e2e35ecc97ed6cf0d2442844624b/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:1efb06900858bb618ff5cee184ae2de5828896c448403d51fb633f09e109be0a", size = 778758, upload-time = "2026-03-31T21:59:31.547Z" }, + { url = "https://files.pythonhosted.org/packages/04/fb/377aead2e0a3ba5f09b7624f702a964bdf4f08b5b6728a9799830c80041e/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fee86b7c4bd29bdaf0d53d14739b08a106fdda809ca5fe032a15f52fae5fe254", size = 512883, upload-time = "2026-03-31T21:59:34.098Z" }, + { url = "https://files.pythonhosted.org/packages/bb/a6/aa109a33671f7a5d3bd78b46da9d852797c5e665bfda7d6b373f56bff2ec/aiohttp-3.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:20058e23909b9e65f9da62b396b77dfa95965cbe840f8def6e572538b1d32e36", size = 516668, upload-time = "2026-03-31T21:59:36.497Z" }, + { url = "https://files.pythonhosted.org/packages/79/b3/ca078f9f2fa9563c36fb8ef89053ea2bb146d6f792c5104574d49d8acb63/aiohttp-3.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cf20a8d6868cb15a73cab329ffc07291ba8c22b1b88176026106ae39aa6df0f", size = 1883461, upload-time = "2026-03-31T21:59:38.723Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e3/a7ad633ca1ca497b852233a3cce6906a56c3225fb6d9217b5e5e60b7419d/aiohttp-3.13.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:330f5da04c987f1d5bdb8ae189137c77139f36bd1cb23779ca1a354a4b027800", size = 1747661, upload-time = "2026-03-31T21:59:41.187Z" }, + { url = "https://files.pythonhosted.org/packages/33/b9/cd6fe579bed34a906d3d783fe60f2fa297ef55b27bb4538438ee49d4dc41/aiohttp-3.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f1cbf0c7926d315c3c26c2da41fd2b5d2fe01ac0e157b78caefc51a782196cf", size = 1863800, upload-time = "2026-03-31T21:59:43.84Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3f/2c1e2f5144cefa889c8afd5cf431994c32f3b29da9961698ff4e3811b79a/aiohttp-3.13.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:53fc049ed6390d05423ba33103ded7281fe897cf97878f369a527070bd95795b", size = 1958382, upload-time = "2026-03-31T21:59:46.187Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/f31ec3f1013723b3babe3609e7f119c2c2fb6ef33da90061a705ef3e1bc8/aiohttp-3.13.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:898703aa2667e3c5ca4c54ca36cd73f58b7a38ef87a5606414799ebce4d3fd3a", size = 1803724, upload-time = "2026-03-31T21:59:48.656Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b4/57712dfc6f1542f067daa81eb61da282fab3e6f1966fca25db06c4fc62d5/aiohttp-3.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0494a01ca9584eea1e5fbd6d748e61ecff218c51b576ee1999c23db7066417d8", size = 1640027, upload-time = "2026-03-31T21:59:51.284Z" }, + { url = "https://files.pythonhosted.org/packages/25/3c/734c878fb43ec083d8e31bf029daae1beafeae582d1b35da234739e82ee7/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6cf81fe010b8c17b09495cbd15c1d35afbc8fb405c0c9cf4738e5ae3af1d65be", size = 1806644, upload-time = "2026-03-31T21:59:53.753Z" }, + { url = "https://files.pythonhosted.org/packages/20/a5/f671e5cbec1c21d044ff3078223f949748f3a7f86b14e34a365d74a5d21f/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:c564dd5f09ddc9d8f2c2d0a301cd30a79a2cc1b46dd1a73bef8f0038863d016b", size = 1791630, upload-time = "2026-03-31T21:59:56.239Z" }, + { url = "https://files.pythonhosted.org/packages/0b/63/fb8d0ad63a0b8a99be97deac8c04dacf0785721c158bdf23d679a87aa99e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2994be9f6e51046c4f864598fd9abeb4fba6e88f0b2152422c9666dcd4aea9c6", size = 1809403, upload-time = "2026-03-31T21:59:59.103Z" }, + { url = "https://files.pythonhosted.org/packages/59/0c/bfed7f30662fcf12206481c2aac57dedee43fe1c49275e85b3a1e1742294/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:157826e2fa245d2ef46c83ea8a5faf77ca19355d278d425c29fda0beb3318037", size = 1634924, upload-time = "2026-03-31T22:00:02.116Z" }, + { url = "https://files.pythonhosted.org/packages/17/d6/fd518d668a09fd5a3319ae5e984d4d80b9a4b3df4e21c52f02251ef5a32e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a8aca50daa9493e9e13c0f566201a9006f080e7c50e5e90d0b06f53146a54500", size = 1836119, upload-time = "2026-03-31T22:00:04.756Z" }, + { url = "https://files.pythonhosted.org/packages/78/b7/15fb7a9d52e112a25b621c67b69c167805cb1f2ab8f1708a5c490d1b52fe/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3b13560160d07e047a93f23aaa30718606493036253d5430887514715b67c9d9", size = 1772072, upload-time = "2026-03-31T22:00:07.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/df/57ba7f0c4a553fc2bd8b6321df236870ec6fd64a2a473a8a13d4f733214e/aiohttp-3.13.5-cp314-cp314t-win32.whl", hash = "sha256:9a0f4474b6ea6818b41f82172d799e4b3d29e22c2c520ce4357856fced9af2f8", size = 471819, upload-time = "2026-03-31T22:00:10.277Z" }, + { url = "https://files.pythonhosted.org/packages/62/29/2f8418269e46454a26171bfdd6a055d74febf32234e474930f2f60a17145/aiohttp-3.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:18a2f6c1182c51baa1d28d68fea51513cb2a76612f038853c0ad3c145423d3d9", size = 505441, upload-time = "2026-03-31T22:00:12.791Z" }, +] + +[[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.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "av" +version = "17.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/f0/8c8dca97ae0cf00e8e2a53bb5cb9aca5fd484f585ef3e9b412200aff3ebd/av-17.0.1.tar.gz", hash = "sha256:fbcbd4aa43bca6a8691816283112d1659a27f407bbeb66d1397023691339f5d4", size = 4411938, upload-time = "2026-04-18T17:12:34.29Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/82/e7007dcef7bd2d2c377e2e85977701384f42d19fc808c2ccb3a99eaf58f2/av-17.0.1-cp311-abi3-macosx_11_0_x86_64.whl", hash = "sha256:987f4f46ceae4da6c614dcbd2b8149be9dbf680c3bb7a6841c58af9cff4d9230", size = 23238802, upload-time = "2026-04-18T17:11:51.166Z" }, + { url = "https://files.pythonhosted.org/packages/6b/aa/858b09a08ea6f83f91be44b5a5adad13ae8d9ac8b80fda27e73c24bfb160/av-17.0.1-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:d97f54e55b18a74912f479c1978aadd1341d38d892dee95bb5c2f2dccfa72f32", size = 18709338, upload-time = "2026-04-18T17:11:53.286Z" }, + { url = "https://files.pythonhosted.org/packages/a8/8b/8de3fd21c4b0b74d44337421abeab0e71462337fb6a28fff888e0c356cbd/av-17.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e6eee84afa48d0e9321047cd3e4facd44b401493f6bdc753e2e1d1e7c9e6d13e", size = 34007351, upload-time = "2026-04-18T17:11:56.116Z" }, + { url = "https://files.pythonhosted.org/packages/02/28/167b291356c2cc315a2d62a95b0ceace72b5b0bf547de30b89313110f032/av-17.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:c58c71bffd9383908c85695ac61d3184c668accb04a5bd1b262e0fb8d09f60a5", size = 36345295, upload-time = "2026-04-18T17:11:59.125Z" }, + { url = "https://files.pythonhosted.org/packages/04/fa/aae56f2ff2c204c408641e1120f5ca5ce9c3390cf5362245c6f1158704b5/av-17.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:42d6745d30a410ec9b22aef79a52a7ab5a001eb8f5adfd952946606a30983318", size = 35183754, upload-time = "2026-04-18T17:12:01.697Z" }, + { url = "https://files.pythonhosted.org/packages/ba/bd/776046f27093aef80155a204ca7d82a887ae4ee72ba4ef8411b46ea7898c/av-17.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3ed6bcd7021fe55832f95b8ef78dd01a4cb21faf3cd71f1e1bf4f20bf100b278", size = 37430809, upload-time = "2026-04-18T17:12:04.231Z" }, + { url = "https://files.pythonhosted.org/packages/d9/d5/3261bd2c6b7f6c0aa8379fc970d1ecf496330990b992ad28607785074268/av-17.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:9af524e8632a54032e361d6b88895bd3e7c6212ca560de60f5ccc525323c764c", size = 28889649, upload-time = "2026-04-18T17:12:07.04Z" }, + { url = "https://files.pythonhosted.org/packages/98/39/381104e427a0c7231d2ec0d25d538d58fc20fc0458846b95860d3ef8073b/av-17.0.1-cp311-abi3-win_arm64.whl", hash = "sha256:50e58a473d65ea29b645e45c9fd8518a6783737135683ecc40571a91592bdfe4", size = 21918412, upload-time = "2026-04-18T17:12:09.312Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8c/bb1498f031abb6157b30b7fc2379359176953821b6ba59fbd89dbb56f61f/av-17.0.1-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:1d33871742d1e71562db3c8e752cacc5a62766d7efc3ae408bff1c3e26ebb46e", size = 23484157, upload-time = "2026-04-18T17:12:11.67Z" }, + { url = "https://files.pythonhosted.org/packages/1a/58/dedaef187b797243cd5762722e376c69c5ad95ab23db44127f09afc2cd66/av-17.0.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:1229e879f4b6431bc00f69d7f8891fe9a683b0a6e0e009e6c98eb7e449f0383d", size = 18920872, upload-time = "2026-04-18T17:12:14.826Z" }, + { url = "https://files.pythonhosted.org/packages/9b/26/5c550231651d6285e6a5c4f6f4a0e67459bfe2b622a7c9352be8cca8c819/av-17.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:4744837f4116964280bcc72285e3cdd51361e98a696205aadd924203440ef511", size = 37471077, upload-time = "2026-04-18T17:12:17.349Z" }, + { url = "https://files.pythonhosted.org/packages/59/e4/9807b89a9d775c6f015677996c48bce48aaff70b5d95885adf39e59832a2/av-17.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:3d0a7d45d9599bf9df9f8249827113d4f36df1cd6b5356227b997f0552dbc98e", size = 39566981, upload-time = "2026-04-18T17:12:19.942Z" }, + { url = "https://files.pythonhosted.org/packages/5c/72/a22a657abc3de652f5b4f46cbbebdf7cba629752112791b81f05d340991d/av-17.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9acd0b6a6e02af2b37f63d97a03ee2c47936d58e82425c3cd075a95245937c59", size = 38397369, upload-time = "2026-04-18T17:12:22.909Z" }, + { url = "https://files.pythonhosted.org/packages/ae/b2/f4e83e41c1e3c186f34b7df506779d0cd7e40499e2e19519c7ece148cd20/av-17.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3d3a36204cb1f1e7691e6446afa8d6b7097b09946dae732c71c5d05ce09e506e", size = 40582445, upload-time = "2026-04-18T17:12:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/c8/59/8676188b72eed09d48ce6cfaf0f22b0bb9f3cfd74d388ee2b7fdf960536d/av-17.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:b87b98afe971cde123953073bc9c95ab0b7efd2ecc082dd2dbd11f9d9abf190e", size = 29217136, upload-time = "2026-04-18T17:12:29.189Z" }, + { url = "https://files.pythonhosted.org/packages/5f/af/0a6e1d2a845988039f6c197fa7269b5e9abbe17354fb41cc9d75bb260fcb/av-17.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:a87a42c36e29f75e7dff7281944f2a6876a2c8875e225ccbf6c1ae62748b4caa", size = 22072676, upload-time = "2026-04-18T17:12:31.836Z" }, +] + +[[package]] +name = "certifi" +version = "2026.4.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", hash = "sha256:8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580", size = 137077, upload-time = "2026-04-22T11:26:11.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" }, + { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" }, + { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" }, + { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" }, + { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" }, + { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" }, + { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" }, + { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" }, + { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" }, + { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" }, + { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" }, + { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" }, + { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" }, + { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" }, + { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" }, + { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" }, + { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" }, + { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" }, + { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" }, + { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" }, + { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" }, + { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" }, + { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" }, + { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" }, + { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" }, + { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" }, + { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" }, + { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" }, + { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" }, + { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" }, + { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" }, + { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" }, + { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" }, + { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" }, + { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" }, + { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" }, + { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" }, + { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" }, + { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" }, +] + +[[package]] +name = "click" +version = "8.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" }, +] + +[[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 = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, +] + +[[package]] +name = "docstring-parser" +version = "0.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/4d/f332313098c1de1b2d2ff91cf2674415cc7cddab2ca1b01ae29774bd5fdf/docstring_parser-0.18.0.tar.gz", hash = "sha256:292510982205c12b1248696f44959db3cdd1740237a968ea1e2e7a900eeb2015", size = 29341, upload-time = "2026-04-14T04:09:19.867Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" }, +] + +[[package]] +name = "eval-type-backport" +version = "0.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fb/a3/cafafb4558fd638aadfe4121dc6cefb8d743368c085acb2f521df0f3d9d7/eval_type_backport-0.3.1.tar.gz", hash = "sha256:57e993f7b5b69d271e37482e62f74e76a0276c82490cf8e4f0dffeb6b332d5ed", size = 9445, upload-time = "2025-12-02T11:51:42.987Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/22/fdc2e30d43ff853720042fa15baa3e6122722be1a7950a98233ebb55cd71/eval_type_backport-0.3.1-py3-none-any.whl", hash = "sha256:279ab641905e9f11129f56a8a78f493518515b83402b860f6f06dd7c011fdfa8", size = 6063, upload-time = "2025-12-02T11:51:41.665Z" }, +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" }, + { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" }, + { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" }, + { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" }, + { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" }, + { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" }, + { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" }, + { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" }, + { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" }, + { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" }, + { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" }, + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + +[[package]] +name = "googleapis-common-protos" +version = "1.74.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/20/18/a746c8344152d368a5aac738d4c857012f2c5d1fd2eac7e17b647a7861bd/googleapis_common_protos-1.74.0.tar.gz", hash = "sha256:57971e4eeeba6aad1163c1f0fc88543f965bb49129b8bb55b2b7b26ecab084f1", size = 151254, upload-time = "2026-04-02T21:23:26.679Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/b0/be5d3329badb9230b765de6eea66b73abd5944bdeb5afb3562ddcd80ae84/googleapis_common_protos-1.74.0-py3-none-any.whl", hash = "sha256:702216f78610bb510e3f12ac3cafd281b7ac45cc5d86e90ad87e4d301a3426b5", size = 300743, upload-time = "2026-04-02T21:22:49.108Z" }, +] + +[[package]] +name = "grpcio" +version = "1.80.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" }, + { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" }, + { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" }, + { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" }, + { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" }, + { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" }, + { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" }, + { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" }, + { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" }, + { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" }, + { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" }, + { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" }, + { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/7c3c25789e3f069e581dc342e03613c5b1cb012c4e8c7d9d5cf960a75856/grpcio-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e9e408fc016dffd20661f0126c53d8a31c2821b5c13c5d67a0f5ed5de93319ad", size = 6017243, upload-time = "2026-03-30T08:47:40.075Z" }, + { url = "https://files.pythonhosted.org/packages/04/19/21a9806eb8240e174fd1ab0cd5b9aa948bb0e05c2f2f55f9d5d7405e6d08/grpcio-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:92d787312e613754d4d8b9ca6d3297e69994a7912a32fa38c4c4e01c272974b0", size = 12010840, upload-time = "2026-03-30T08:47:43.11Z" }, + { url = "https://files.pythonhosted.org/packages/18/3a/23347d35f76f639e807fb7a36fad3068aed100996849a33809591f26eca6/grpcio-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac393b58aa16991a2f1144ec578084d544038c12242da3a215966b512904d0f", size = 6567644, upload-time = "2026-03-30T08:47:46.806Z" }, + { url = "https://files.pythonhosted.org/packages/ff/40/96e07ecb604a6a67ae6ab151e3e35b132875d98bc68ec65f3e5ab3e781d7/grpcio-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:68e5851ac4b9afe07e7f84483803ad167852570d65326b34d54ca560bfa53fb6", size = 7277830, upload-time = "2026-03-30T08:47:49.643Z" }, + { url = "https://files.pythonhosted.org/packages/9b/e2/da1506ecea1f34a5e365964644b35edef53803052b763ca214ba3870c856/grpcio-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:873ff5d17d68992ef6605330127425d2fc4e77e612fa3c3e0ed4e668685e3140", size = 6783216, upload-time = "2026-03-30T08:47:52.817Z" }, + { url = "https://files.pythonhosted.org/packages/44/83/3b20ff58d0c3b7f6caaa3af9a4174d4023701df40a3f39f7f1c8e7c48f9d/grpcio-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2bea16af2750fd0a899bf1abd9022244418b55d1f37da2202249ba4ba673838d", size = 7385866, upload-time = "2026-03-30T08:47:55.687Z" }, + { url = "https://files.pythonhosted.org/packages/47/45/55c507599c5520416de5eefecc927d6a0d7af55e91cfffb2e410607e5744/grpcio-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba0db34f7e1d803a878284cd70e4c63cb6ae2510ba51937bf8f45ba997cefcf7", size = 8391602, upload-time = "2026-03-30T08:47:58.303Z" }, + { url = "https://files.pythonhosted.org/packages/10/bb/dd06f4c24c01db9cf11341b547d0a016b2c90ed7dbbb086a5710df7dd1d7/grpcio-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8eb613f02d34721f1acf3626dfdb3545bd3c8505b0e52bf8b5710a28d02e8aa7", size = 7826752, upload-time = "2026-03-30T08:48:01.311Z" }, + { url = "https://files.pythonhosted.org/packages/f9/1e/9d67992ba23371fd63d4527096eb8c6b76d74d52b500df992a3343fd7251/grpcio-1.80.0-cp313-cp313-win32.whl", hash = "sha256:93b6f823810720912fd131f561f91f5fed0fda372b6b7028a2681b8194d5d294", size = 4142310, upload-time = "2026-03-30T08:48:04.594Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e6/283326a27da9e2c3038bc93eeea36fb118ce0b2d03922a9cda6688f53c5b/grpcio-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:e172cf795a3ba5246d3529e4d34c53db70e888fa582a8ffebd2e6e48bc0cba50", size = 4882833, upload-time = "2026-03-30T08:48:07.363Z" }, + { url = "https://files.pythonhosted.org/packages/c5/6d/e65307ce20f5a09244ba9e9d8476e99fb039de7154f37fb85f26978b59c3/grpcio-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:3d4147a97c8344d065d01bbf8b6acec2cf86fb0400d40696c8bdad34a64ffc0e", size = 6017376, upload-time = "2026-03-30T08:48:10.005Z" }, + { url = "https://files.pythonhosted.org/packages/69/10/9cef5d9650c72625a699c549940f0abb3c4bfdb5ed45a5ce431f92f31806/grpcio-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8e11f167935b3eb089ac9038e1a063e6d7dbe995c0bb4a661e614583352e76f", size = 12018133, upload-time = "2026-03-30T08:48:12.927Z" }, + { url = "https://files.pythonhosted.org/packages/04/82/983aabaad82ba26113caceeb9091706a0696b25da004fe3defb5b346e15b/grpcio-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f14b618fc30de822681ee986cfdcc2d9327229dc4c98aed16896761cacd468b9", size = 6574748, upload-time = "2026-03-30T08:48:16.386Z" }, + { url = "https://files.pythonhosted.org/packages/07/d7/031666ef155aa0bf399ed7e19439656c38bbd143779ae0861b038ce82abd/grpcio-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4ed39fbdcf9b87370f6e8df4e39ca7b38b3e5e9d1b0013c7b6be9639d6578d14", size = 7277711, upload-time = "2026-03-30T08:48:19.627Z" }, + { url = "https://files.pythonhosted.org/packages/e8/43/f437a78f7f4f1d311804189e8f11fb311a01049b2e08557c1068d470cb2e/grpcio-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2dcc70e9f0ba987526e8e8603a610fb4f460e42899e74e7a518bf3c68fe1bf05", size = 6785372, upload-time = "2026-03-30T08:48:22.373Z" }, + { url = "https://files.pythonhosted.org/packages/93/3d/f6558e9c6296cb4227faa5c43c54a34c68d32654b829f53288313d16a86e/grpcio-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:448c884b668b868562b1bda833c5fce6272d26e1926ec46747cda05741d302c1", size = 7395268, upload-time = "2026-03-30T08:48:25.638Z" }, + { url = "https://files.pythonhosted.org/packages/06/21/0fdd77e84720b08843c371a2efa6f2e19dbebf56adc72df73d891f5506f0/grpcio-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a1dc80fe55685b4a543555e6eef975303b36c8db1023b1599b094b92aa77965f", size = 8392000, upload-time = "2026-03-30T08:48:28.974Z" }, + { url = "https://files.pythonhosted.org/packages/f5/68/67f4947ed55d2e69f2cc199ab9fd85e0a0034d813bbeef84df6d2ba4d4b7/grpcio-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:31b9ac4ad1aa28ffee5503821fafd09e4da0a261ce1c1281c6c8da0423c83b6e", size = 7828477, upload-time = "2026-03-30T08:48:32.054Z" }, + { url = "https://files.pythonhosted.org/packages/44/b6/8d4096691b2e385e8271911a0de4f35f0a6c7d05aff7098e296c3de86939/grpcio-1.80.0-cp314-cp314-win32.whl", hash = "sha256:367ce30ba67d05e0592470428f0ec1c31714cab9ef19b8f2e37be1f4c7d32fae", size = 4218563, upload-time = "2026-03-30T08:48:34.538Z" }, + { url = "https://files.pythonhosted.org/packages/e5/8c/bbe6baf2557262834f2070cf668515fa308b2d38a4bbf771f8f7872a7036/grpcio-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:3b01e1f5464c583d2f567b2e46ff0d516ef979978f72091fd81f5ab7fa6e2e7f", size = 5019457, upload-time = "2026-03-30T08:48:37.308Z" }, +] + +[[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 = "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]] +name = "idna" +version = "3.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/cc/762dfb036166873f0059f3b7de4565e1b5bc3d6f28a414c13da27e442f99/idna-3.13.tar.gz", hash = "sha256:585ea8fe5d69b9181ec1afba340451fba6ba764af97026f92a91d4eef164a242", size = 194210, upload-time = "2026-04-22T16:42:42.314Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/13/ad7d7ca3808a898b4612b6fe93cde56b53f3034dcde235acb1f0e1df24c6/idna-3.13-py3-none-any.whl", hash = "sha256:892ea0cde124a99ce773decba204c5552b69c3c67ffd5f232eb7696135bc8bb3", size = 68629, upload-time = "2026-04-22T16:42:40.909Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "8.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" }, +] + +[[package]] +name = "jiter" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6e/c1/0cddc6eb17d4c53a99840953f95dd3accdc5cfc7a337b0e9b26476276be9/jiter-0.14.0.tar.gz", hash = "sha256:e8a39e66dac7153cf3f964a12aad515afa8d74938ec5cc0018adcdae5367c79e", size = 165725, upload-time = "2026-04-10T14:28:42.01Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/1f/198ae537fccb7080a0ed655eb56abf64a92f79489dfbf79f40fa34225bcd/jiter-0.14.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7e791e247b8044512e070bd1f3633dc08350d32776d2d6e7473309d0edf256a2", size = 316896, upload-time = "2026-04-10T14:26:01.986Z" }, + { url = "https://files.pythonhosted.org/packages/cf/34/da67cff3fce964a36d03c3e365fb0f8726ade2a6cfd4d3c70107e216ead6/jiter-0.14.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71527ce13fd5a0c4e40ad37331f8c547177dbb2dd0a93e5278b6a5eecf748804", size = 321085, upload-time = "2026-04-10T14:26:03.364Z" }, + { url = "https://files.pythonhosted.org/packages/ed/36/4c72e67180d4e71a4f5dcf7886d0840e83c49ab11788172177a77570326e/jiter-0.14.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02c4a7ab56f746014874f2c525584c0daca1dec37f66fd707ecef3b7e5c2228c", size = 347393, upload-time = "2026-04-10T14:26:05.314Z" }, + { url = "https://files.pythonhosted.org/packages/bc/db/9b39e09ceafa9878235c0fc29e3e3f9b12a4c6a98ea3085b998cadf3accc/jiter-0.14.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:376e9dafff914253bb9d46cdc5f7965607fbe7feb0a491c34e35f92b2770702e", size = 372937, upload-time = "2026-04-10T14:26:06.884Z" }, + { url = "https://files.pythonhosted.org/packages/b0/96/0dcba1d7a82c1b720774b48ef239376addbaf30df24c34742ac4a57b67b2/jiter-0.14.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:23ad2a7a9da1935575c820428dd8d2490ce4d23189691ce33da1fc0a58e14e1c", size = 463646, upload-time = "2026-04-10T14:26:08.345Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e3/f61b71543e746e6b8b805e7755814fc242715c16f1dba58e1cbccb8032c2/jiter-0.14.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:54b3ddf5786bc7732d293bba3411ac637ecfa200a39983166d1df86a59a43c9f", size = 380225, upload-time = "2026-04-10T14:26:10.161Z" }, + { url = "https://files.pythonhosted.org/packages/ad/5e/0ddeb7096aca099114abe36c4921016e8d251e6f35f5890240b31f1f60ae/jiter-0.14.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c001d5a646c2a50dc055dd526dad5d5245969e8234d2b1131d0451e81f3a373", size = 358682, upload-time = "2026-04-10T14:26:11.574Z" }, + { url = "https://files.pythonhosted.org/packages/e9/d1/fe0c46cd7fda9cad8f1ff9ad217dc61f1e4280b21052ec6dfe88c1446ef2/jiter-0.14.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:834bb5bdabca2e91592a03d373838a8d0a1b8bbde7077ae6913fd2fc51812d00", size = 359973, upload-time = "2026-04-10T14:26:13.316Z" }, + { url = "https://files.pythonhosted.org/packages/ac/21/f5317f91729b501019184771c80d60abd89907009e7bfa6c7e348c5bdd44/jiter-0.14.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4e9178be60e229b1b2b0710f61b9e24d1f4f8556985a83ff4c4f95920eea7314", size = 397568, upload-time = "2026-04-10T14:26:15.212Z" }, + { url = "https://files.pythonhosted.org/packages/e9/05/79d8f33fb2bf168db0df5c9cd16fe440a8ada57e929d3677b22712c2568f/jiter-0.14.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a7e4ccff04ec03614e62c613e976a3a5860dc9714ce8266f44328bdc8b1cab2c", size = 522535, upload-time = "2026-04-10T14:26:16.956Z" }, + { url = "https://files.pythonhosted.org/packages/5c/00/d1e3ff3d2a465e67f08507d74bafb2dcd29eba91dc939820e39e8dea38b8/jiter-0.14.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:69539d936fb5d55caf6ecd33e2e884de083ff0ea28579780d56c4403094bb8d9", size = 556709, upload-time = "2026-04-10T14:26:18.5Z" }, + { url = "https://files.pythonhosted.org/packages/60/5b/bbb2189f62ace8d95e869aa4c84c9946616f301e2d02895a6f20dcc3bba3/jiter-0.14.0-cp311-cp311-win32.whl", hash = "sha256:4927d09b3e572787cc5e0a5318601448e1ab9391bcef95677f5840c2d00eaa6d", size = 208660, upload-time = "2026-04-10T14:26:20.511Z" }, + { url = "https://files.pythonhosted.org/packages/b8/86/c500b53dcbf08575f5963e536ebd757a1f7c568272ba5d180b212c9a87fb/jiter-0.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:42d6ed359ac49eb922fdd565f209c57340aa06d589c84c8413e42a0f9ae1b842", size = 204659, upload-time = "2026-04-10T14:26:22.152Z" }, + { url = "https://files.pythonhosted.org/packages/75/4a/a676249049d42cb29bef82233e4fe0524d414cbe3606c7a4b311193c2f77/jiter-0.14.0-cp311-cp311-win_arm64.whl", hash = "sha256:6dd689f5f4a5a33747b28686e051095beb214fe28cfda5e9fe58a295a788f593", size = 194772, upload-time = "2026-04-10T14:26:23.458Z" }, + { url = "https://files.pythonhosted.org/packages/5a/68/7390a418f10897da93b158f2d5a8bd0bcd73a0f9ec3bb36917085bb759ef/jiter-0.14.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:2fb2ce3a7bc331256dfb14cefc34832366bb28a9aca81deaf43bbf2a5659e607", size = 316295, upload-time = "2026-04-10T14:26:24.887Z" }, + { url = "https://files.pythonhosted.org/packages/60/a0/5854ac00ff63551c52c6c89534ec6aba4b93474e7924d64e860b1c94165b/jiter-0.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5252a7ca23785cef5d02d4ece6077a1b556a410c591b379f82091c3001e14844", size = 315898, upload-time = "2026-04-10T14:26:26.601Z" }, + { url = "https://files.pythonhosted.org/packages/41/a1/4f44832650a16b18e8391f1bf1d6ca4909bc738351826bcc198bba4357f4/jiter-0.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c409578cbd77c338975670ada777add4efd53379667edf0aceea730cabede6fb", size = 343730, upload-time = "2026-04-10T14:26:28.326Z" }, + { url = "https://files.pythonhosted.org/packages/48/64/a329e9d469f86307203594b1707e11ae51c3348d03bfd514a5f997870012/jiter-0.14.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7ede4331a1899d604463369c730dbb961ffdc5312bc7f16c41c2896415b1304a", size = 370102, upload-time = "2026-04-10T14:26:30.089Z" }, + { url = "https://files.pythonhosted.org/packages/94/c1/5e3dfc59635aa4d4c7bd20a820ac1d09b8ed851568356802cf1c08edb3cf/jiter-0.14.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92cd8b6025981a041f5310430310b55b25ca593972c16407af8837d3d7d2ca01", size = 461335, upload-time = "2026-04-10T14:26:31.911Z" }, + { url = "https://files.pythonhosted.org/packages/e3/1b/dd157009dbc058f7b00108f545ccb72a2d56461395c4fc7b9cfdccb00af4/jiter-0.14.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:351bf6eda4e3a7ceb876377840c702e9a3e4ecc4624dbfb2d6463c67ae52637d", size = 378536, upload-time = "2026-04-10T14:26:33.595Z" }, + { url = "https://files.pythonhosted.org/packages/91/78/256013667b7c10b8834f8e6e54cd3e562d4c6e34227a1596addccc05e38c/jiter-0.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1dcfbeb93d9ecd9ca128bbf8910120367777973fa193fb9a39c31237d8df165", size = 353859, upload-time = "2026-04-10T14:26:35.098Z" }, + { url = "https://files.pythonhosted.org/packages/de/d9/137d65ade9093a409fe80955ce60b12bb753722c986467aeda47faf450ad/jiter-0.14.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:ae039aaef8de3f8157ecc1fdd4d85043ac4f57538c245a0afaecb8321ec951c3", size = 357626, upload-time = "2026-04-10T14:26:36.685Z" }, + { url = "https://files.pythonhosted.org/packages/2e/48/76750835b87029342727c1a268bea8878ab988caf81ee4e7b880900eeb5a/jiter-0.14.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7d9d51eb96c82a9652933bd769fe6de66877d6eb2b2440e281f2938c51b5643e", size = 393172, upload-time = "2026-04-10T14:26:38.097Z" }, + { url = "https://files.pythonhosted.org/packages/a6/60/456c4e81d5c8045279aefe60e9e483be08793828800a4e64add8fdde7f2a/jiter-0.14.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d824ca4148b705970bf4e120924a212fdfca9859a73e42bd7889a63a4ea6bb98", size = 520300, upload-time = "2026-04-10T14:26:39.532Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9f/2020e0984c235f678dced38fe4eec3058cf528e6af36ebf969b410305941/jiter-0.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ff3a6465b3a0f54b1a430f45c3c0ba7d61ceb45cbc3e33f9e1a7f638d690baf3", size = 553059, upload-time = "2026-04-10T14:26:40.991Z" }, + { url = "https://files.pythonhosted.org/packages/ef/32/e2d298e1a22a4bbe6062136d1c7192db7dba003a6975e51d9a9eecabc4c2/jiter-0.14.0-cp312-cp312-win32.whl", hash = "sha256:5dec7c0a3e98d2a3f8a2e67382d0d7c3ac60c69103a4b271da889b4e8bb1e129", size = 206030, upload-time = "2026-04-10T14:26:42.517Z" }, + { url = "https://files.pythonhosted.org/packages/36/ac/96369141b3d8a4a8e4590e983085efe1c436f35c0cda940dd76d942e3e40/jiter-0.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:fc7e37b4b8bc7e80a63ad6cfa5fc11fab27dbfea4cc4ae644b1ab3f273dc348f", size = 201603, upload-time = "2026-04-10T14:26:44.328Z" }, + { url = "https://files.pythonhosted.org/packages/01/c3/75d847f264647017d7e3052bbcc8b1e24b95fa139c320c5f5066fa7a0bdd/jiter-0.14.0-cp312-cp312-win_arm64.whl", hash = "sha256:ee4a72f12847ef29b072aee9ad5474041ab2924106bdca9fcf5d7d965853e057", size = 191525, upload-time = "2026-04-10T14:26:46Z" }, + { url = "https://files.pythonhosted.org/packages/97/2a/09f70020898507a89279659a1afe3364d57fc1b2c89949081975d135f6f5/jiter-0.14.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:af72f204cf4d44258e5b4c1745130ac45ddab0e71a06333b01de660ab4187a94", size = 315502, upload-time = "2026-04-10T14:26:47.697Z" }, + { url = "https://files.pythonhosted.org/packages/d6/be/080c96a45cd74f9fce5db4fd68510b88087fb37ffe2541ff73c12db92535/jiter-0.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4b77da71f6e819be5fbcec11a453fde5b1d0267ef6ed487e2a392fd8e14e4e3a", size = 314870, upload-time = "2026-04-10T14:26:49.149Z" }, + { url = "https://files.pythonhosted.org/packages/7d/5e/2d0fee155826a968a832cc32438de5e2a193292c8721ca70d0b53e58245b/jiter-0.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f4ea612fe8b84b8b04e51d0e78029ecf3466348e25973f953de6e6a59aa4c1", size = 343406, upload-time = "2026-04-10T14:26:50.762Z" }, + { url = "https://files.pythonhosted.org/packages/70/af/bf9ee0d3a4f8dc0d679fc1337f874fe60cdbf841ebbb304b374e1c9aaceb/jiter-0.14.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:62fe2451f8fcc0240261e6a4df18ecbcd58327857e61e625b2393ea3b468aac9", size = 369415, upload-time = "2026-04-10T14:26:52.188Z" }, + { url = "https://files.pythonhosted.org/packages/0f/83/8e8561eadba31f4d3948a5b712fb0447ec71c3560b57a855449e7b8ddc98/jiter-0.14.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6112f26f5afc75bcb475787d29da3aa92f9d09c7858f632f4be6ffe607be82e9", size = 461456, upload-time = "2026-04-10T14:26:53.611Z" }, + { url = "https://files.pythonhosted.org/packages/f6/c9/c5299e826a5fe6108d172b344033f61c69b1bb979dd8d9ddd4278a160971/jiter-0.14.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:215a6cb8fb7dc702aa35d475cc00ddc7f970e5c0b1417fb4b4ac5d82fa2a29db", size = 378488, upload-time = "2026-04-10T14:26:55.211Z" }, + { url = "https://files.pythonhosted.org/packages/5d/37/c16d9d15c0a471b8644b1abe3c82668092a707d9bedcf076f24ff2e380cd/jiter-0.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4ab96a30fb3cb2c7e0cd33f7616c8860da5f5674438988a54ac717caccdbaa", size = 353242, upload-time = "2026-04-10T14:26:56.705Z" }, + { url = "https://files.pythonhosted.org/packages/58/ea/8050cb0dc654e728e1bfacbc0c640772f2181af5dedd13ae70145743a439/jiter-0.14.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3a99c1387b1f2928f799a9de899193484d66206a50e98233b6b088a7f0c1edb2", size = 356823, upload-time = "2026-04-10T14:26:58.281Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/cf71506d270e5f84d97326bf220e47aed9b95e9a4a060758fb07772170ab/jiter-0.14.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ab18d11074485438695f8d34a1b6da61db9754248f96d51341956607a8f39985", size = 392564, upload-time = "2026-04-10T14:27:00.018Z" }, + { url = "https://files.pythonhosted.org/packages/b0/cc/8c6c74a3efb5bd671bfd14f51e8a73375464ca914b1551bc3b40e26ac2c9/jiter-0.14.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:801028dcfc26ac0895e4964cbc0fd62c73be9fd4a7d7b1aaf6e5790033a719b7", size = 520322, upload-time = "2026-04-10T14:27:01.664Z" }, + { url = "https://files.pythonhosted.org/packages/41/24/68d7b883ec959884ddf00d019b2e0e82ba81b167e1253684fa90519ce33c/jiter-0.14.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ad425b087aafb4a1c7e1e98a279200743b9aaf30c3e0ba723aec93f061bd9bc8", size = 552619, upload-time = "2026-04-10T14:27:03.316Z" }, + { url = "https://files.pythonhosted.org/packages/b6/89/b1a0985223bbf3150ff9e8f46f98fc9360c1de94f48abe271bbe1b465682/jiter-0.14.0-cp313-cp313-win32.whl", hash = "sha256:882bcb9b334318e233950b8be366fe5f92c86b66a7e449e76975dfd6d776a01f", size = 205699, upload-time = "2026-04-10T14:27:04.662Z" }, + { url = "https://files.pythonhosted.org/packages/4c/19/3f339a5a7f14a11730e67f6be34f9d5105751d547b615ef593fa122a5ded/jiter-0.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:9b8c571a5dba09b98bd3462b5a53f27209a5cbbe85670391692ede71974e979f", size = 201323, upload-time = "2026-04-10T14:27:06.139Z" }, + { url = "https://files.pythonhosted.org/packages/50/56/752dd89c84be0e022a8ea3720bcfa0a8431db79a962578544812ce061739/jiter-0.14.0-cp313-cp313-win_arm64.whl", hash = "sha256:34f19dcc35cb1abe7c369b3756babf8c7f04595c0807a848df8f26ef8298ef92", size = 191099, upload-time = "2026-04-10T14:27:07.564Z" }, + { url = "https://files.pythonhosted.org/packages/91/28/292916f354f25a1fe8cf2c918d1415c699a4a659ae00be0430e1c5d9ffea/jiter-0.14.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e89bcd7d426a75bb4952c696b267075790d854a07aad4c9894551a82c5b574ab", size = 320880, upload-time = "2026-04-10T14:27:09.326Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c7/b002a7d8b8957ac3d469bd59c18ef4b1595a5216ae0de639a287b9816023/jiter-0.14.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b25beaa0d4447ea8c7ae0c18c688905d34840d7d0b937f2f7bdd52162c98a40", size = 346563, upload-time = "2026-04-10T14:27:11.287Z" }, + { url = "https://files.pythonhosted.org/packages/f9/3b/f8d07580d8706021d255a6356b8fab13ee4c869412995550ce6ed4ddf97d/jiter-0.14.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:651a8758dd413c51e3b7f6557cdc6921faf70b14106f45f969f091f5cda990ea", size = 357928, upload-time = "2026-04-10T14:27:12.729Z" }, + { url = "https://files.pythonhosted.org/packages/47/5b/ac1a974da29e35507230383110ffec59998b290a8732585d04e19a9eb5ba/jiter-0.14.0-cp313-cp313t-win_amd64.whl", hash = "sha256:e1a7eead856a5038a8d291f1447176ab0b525c77a279a058121b5fccee257f6f", size = 203519, upload-time = "2026-04-10T14:27:14.125Z" }, + { url = "https://files.pythonhosted.org/packages/96/6d/9fc8433d667d2454271378a79747d8c76c10b51b482b454e6190e511f244/jiter-0.14.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e692633a12cda97e352fdcd1c4acc971b1c28707e1e33aeef782b0cbf051975", size = 190113, upload-time = "2026-04-10T14:27:16.638Z" }, + { url = "https://files.pythonhosted.org/packages/4f/1e/354ed92461b165bd581f9ef5150971a572c873ec3b68a916d5aa91da3cc2/jiter-0.14.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:6f396837fc7577871ca8c12edaf239ed9ccef3bbe39904ae9b8b63ce0a48b140", size = 315277, upload-time = "2026-04-10T14:27:18.109Z" }, + { url = "https://files.pythonhosted.org/packages/a6/95/8c7c7028aa8636ac21b7a55faef3e34215e6ed0cbf5ae58258427f621aa3/jiter-0.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a4d50ea3d8ba4176f79754333bd35f1bbcd28e91adc13eb9b7ca91bc52a6cef9", size = 315923, upload-time = "2026-04-10T14:27:19.603Z" }, + { url = "https://files.pythonhosted.org/packages/47/40/e2a852a44c4a089f2681a16611b7ce113224a80fd8504c46d78491b47220/jiter-0.14.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce17f8a050447d1b4153bda4fb7d26e6a9e74eb4f4a41913f30934c5075bf615", size = 344943, upload-time = "2026-04-10T14:27:21.262Z" }, + { url = "https://files.pythonhosted.org/packages/fc/1f/670f92adee1e9895eac41e8a4d623b6da68c4d46249d8b556b60b63f949e/jiter-0.14.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4f1c4b125e1652aefbc2e2c1617b60a160ab789d180e3d423c41439e5f32850", size = 369725, upload-time = "2026-04-10T14:27:22.766Z" }, + { url = "https://files.pythonhosted.org/packages/01/2f/541c9ba567d05de1c4874a0f8f8c5e3fd78e2b874266623da9a775cf46e0/jiter-0.14.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be808176a6a3a14321d18c603f2d40741858a7c4fc982f83232842689fe86dd9", size = 461210, upload-time = "2026-04-10T14:27:24.315Z" }, + { url = "https://files.pythonhosted.org/packages/ce/a9/c31cbec09627e0d5de7aeaec7690dba03e090caa808fefd8133137cf45bc/jiter-0.14.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26679d58ba816f88c3849306dd58cb863a90a1cf352cdd4ef67e30ccf8a77994", size = 380002, upload-time = "2026-04-10T14:27:26.155Z" }, + { url = "https://files.pythonhosted.org/packages/50/02/3c05c1666c41904a2f607475a73e7a4763d1cbde2d18229c4f85b22dc253/jiter-0.14.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80381f5a19af8fa9aef743f080e34f6b25ebd89656475f8cf0470ec6157052aa", size = 354678, upload-time = "2026-04-10T14:27:27.701Z" }, + { url = "https://files.pythonhosted.org/packages/7d/97/e15b33545c2b13518f560d695f974b9891b311641bdcf178d63177e8801e/jiter-0.14.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:004df5fdb8ecbd6d99f3227df18ba1a259254c4359736a2e6f036c944e02d7c5", size = 358920, upload-time = "2026-04-10T14:27:29.256Z" }, + { url = "https://files.pythonhosted.org/packages/ad/d2/8b1461def6b96ba44530df20d07ef7a1c7da22f3f9bf1727e2d611077bf1/jiter-0.14.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cff5708f7ed0fa098f2b53446c6fa74c48469118e5cd7497b4f1cd569ab06928", size = 394512, upload-time = "2026-04-10T14:27:31.344Z" }, + { url = "https://files.pythonhosted.org/packages/e3/88/837566dd6ed6e452e8d3205355afd484ce44b2533edfa4ed73a298ea893e/jiter-0.14.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:2492e5f06c36a976d25c7cc347a60e26d5470178d44cde1b9b75e60b4e519f28", size = 521120, upload-time = "2026-04-10T14:27:33.299Z" }, + { url = "https://files.pythonhosted.org/packages/89/6b/b00b45c4d1b4c031777fe161d620b755b5b02cdade1e316dcb46e4471d63/jiter-0.14.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:7609cfbe3a03d37bfdbf5052012d5a879e72b83168a363deae7b3a26564d57de", size = 553668, upload-time = "2026-04-10T14:27:34.868Z" }, + { url = "https://files.pythonhosted.org/packages/ad/d8/6fe5b42011d19397433d345716eac16728ac241862a2aac9c91923c7509a/jiter-0.14.0-cp314-cp314-win32.whl", hash = "sha256:7282342d32e357543565286b6450378c3cd402eea333fc1ebe146f1fabb306fc", size = 207001, upload-time = "2026-04-10T14:27:36.455Z" }, + { url = "https://files.pythonhosted.org/packages/e5/43/5c2e08da1efad5e410f0eaaabeadd954812612c33fbbd8fd5328b489139d/jiter-0.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:bd77945f38866a448e73b0b7637366afa814d4617790ecd88a18ca74377e6c02", size = 202187, upload-time = "2026-04-10T14:27:38Z" }, + { url = "https://files.pythonhosted.org/packages/aa/1f/6e39ac0b4cdfa23e606af5b245df5f9adaa76f35e0c5096790da430ca506/jiter-0.14.0-cp314-cp314-win_arm64.whl", hash = "sha256:f2d4c61da0821ee42e0cdf5489da60a6d074306313a377c2b35af464955a3611", size = 192257, upload-time = "2026-04-10T14:27:39.504Z" }, + { url = "https://files.pythonhosted.org/packages/05/57/7dbc0ffbbb5176a27e3518716608aa464aee2e2887dc938f0b900a120449/jiter-0.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1bf7ff85517dd2f20a5750081d2b75083c1b269cf75afc7511bdf1f9548beb3b", size = 323441, upload-time = "2026-04-10T14:27:41.039Z" }, + { url = "https://files.pythonhosted.org/packages/83/6e/7b3314398d8983f06b557aa21b670511ec72d3b79a68ee5e4d9bff972286/jiter-0.14.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8ef8791c3e78d6c6b157c6d360fbb5c715bebb8113bc6a9303c5caff012754a", size = 348109, upload-time = "2026-04-10T14:27:42.552Z" }, + { url = "https://files.pythonhosted.org/packages/ae/4f/8dc674bcd7db6dba566de73c08c763c337058baff1dbeb34567045b27cdc/jiter-0.14.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e74663b8b10da1fe0f4e4703fd7980d24ad17174b6bb35d8498d6e3ebce2ae6a", size = 368328, upload-time = "2026-04-10T14:27:44.574Z" }, + { url = "https://files.pythonhosted.org/packages/3b/5f/188e09a1f20906f98bbdec44ed820e19f4e8eb8aff88b9d1a5a497587ff3/jiter-0.14.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1aca29ba52913f78362ec9c2da62f22cdc4c3083313403f90c15460979b84d9b", size = 463301, upload-time = "2026-04-10T14:27:46.717Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f0/19046ef965ed8f349e8554775bb12ff4352f443fbe12b95d31f575891256/jiter-0.14.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8b39b7d87a952b79949af5fef44d2544e58c21a28da7f1bae3ef166455c61746", size = 378891, upload-time = "2026-04-10T14:27:48.32Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c3/da43bd8431ee175695777ee78cf0e93eacbb47393ff493f18c45231b427d/jiter-0.14.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78d918a68b26e9fab068c2b5453577ef04943ab2807b9a6275df2a812599a310", size = 360749, upload-time = "2026-04-10T14:27:49.88Z" }, + { url = "https://files.pythonhosted.org/packages/72/26/e054771be889707c6161dbdec9c23d33a9ec70945395d70f07cfea1e9a6f/jiter-0.14.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:b08997c35aee1201c1a5361466a8fb9162d03ae7bf6568df70b6c859f1e654a4", size = 358526, upload-time = "2026-04-10T14:27:51.504Z" }, + { url = "https://files.pythonhosted.org/packages/c3/0f/7bea65ea2a6d91f2bf989ff11a18136644392bf2b0497a1fa50934c30a9c/jiter-0.14.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:260bf7ca20704d58d41f669e5e9fe7fe2fa72901a6b324e79056f5d52e9c9be2", size = 393926, upload-time = "2026-04-10T14:27:53.368Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/b1ff7d70deef61ac0b7c6c2f12d2ace950cdeecb4fdc94500a0926802857/jiter-0.14.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:37826e3df29e60f30a382f9294348d0238ef127f4b5d7f5f8da78b5b9e050560", size = 521052, upload-time = "2026-04-10T14:27:55.058Z" }, + { url = "https://files.pythonhosted.org/packages/0b/7b/3b0649983cbaf15eda26a414b5b1982e910c67bd6f7b1b490f3cfc76896a/jiter-0.14.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:645be49c46f2900937ba0eaf871ad5183c96858c0af74b6becc7f4e367e36e06", size = 553716, upload-time = "2026-04-10T14:27:57.269Z" }, + { url = "https://files.pythonhosted.org/packages/97/f8/33d78c83bd93ae0c0af05293a6660f88a1977caef39a6d72a84afab94ce0/jiter-0.14.0-cp314-cp314t-win32.whl", hash = "sha256:2f7877ed45118de283786178eceaf877110abacd04fde31efff3940ae9672674", size = 207957, upload-time = "2026-04-10T14:27:59.285Z" }, + { url = "https://files.pythonhosted.org/packages/d6/ac/2b760516c03e2227826d1f7025d89bf6bf6357a28fe75c2a2800873c50bf/jiter-0.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:14c0cb10337c49f5eafe8e7364daca5e29a020ea03580b8f8e6c597fed4e1588", size = 204690, upload-time = "2026-04-10T14:28:00.962Z" }, + { url = "https://files.pythonhosted.org/packages/dc/2e/a44c20c58aeed0355f2d326969a181696aeb551a25195f47563908a815be/jiter-0.14.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5419d4aa2024961da9fe12a9cfe7484996735dca99e8e090b5c88595ef1951ff", size = 191338, upload-time = "2026-04-10T14:28:02.853Z" }, + { url = "https://files.pythonhosted.org/packages/32/a1/ef34ca2cab2962598591636a1804b93645821201cc0095d4a93a9a329c9d/jiter-0.14.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:a25ffa2dbbdf8721855612f6dca15c108224b12d0c4024d0ac3d7902132b4211", size = 311366, upload-time = "2026-04-10T14:28:27.943Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/520576a532a6b8a6f42747afed289c8448c879a34d7802fe2c832d4fd38f/jiter-0.14.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0ac9cbaa86c10996b92bd12c91659b60f939f8e28fcfa6bc11a0e90a774ce95b", size = 309873, upload-time = "2026-04-10T14:28:29.688Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7c/c16db114ea1f2f532f198aa8dc39585026af45af362c69a0492f31bc4821/jiter-0.14.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:844e73b6c56b505e9e169234ea3bdea2ea43f769f847f47ac559ba1d2361ebea", size = 344816, upload-time = "2026-04-10T14:28:31.348Z" }, + { url = "https://files.pythonhosted.org/packages/99/8f/15e7741ff19e9bcd4d753f7ff22f988fd54592f134ca13701c13ea8c20e0/jiter-0.14.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e52c076f187405fc21523c746c04399c9af8ece566077ed147b2126f2bcba577", size = 351445, upload-time = "2026-04-10T14:28:33.093Z" }, + { url = "https://files.pythonhosted.org/packages/21/42/9042c3f3019de4adcb8c16591c325ec7255beea9fcd33a42a43f3b0b1000/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:fbd9e482663ca9d005d051330e4d2d8150bb208a209409c10f7e7dfdf7c49da9", size = 308810, upload-time = "2026-04-10T14:28:34.673Z" }, + { url = "https://files.pythonhosted.org/packages/60/cf/a7e19b308bd86bb04776803b1f01a5f9a287a4c55205f4708827ee487fbf/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:33a20d838b91ef376b3a56896d5b04e725c7df5bc4864cc6569cf046a8d73b6d", size = 308443, upload-time = "2026-04-10T14:28:36.658Z" }, + { url = "https://files.pythonhosted.org/packages/ca/44/e26ede3f0caeff93f222559cb0cc4ca68579f07d009d7b6010c5b586f9b1/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:432c4db5255d86a259efde91e55cb4c8d18c0521d844c9e2e7efcce3899fb016", size = 343039, upload-time = "2026-04-10T14:28:38.356Z" }, + { url = "https://files.pythonhosted.org/packages/da/e9/1f9ada30cef7b05e74bb06f52127e7a724976c225f46adb65c37b1dadfb6/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f00d94b281174144d6532a04b66a12cb866cbdc47c3af3bfe2973677f9861a", size = 349613, upload-time = "2026-04-10T14:28:40.066Z" }, +] + +[[package]] +name = "livekit" +source = { editable = "../../livekit-rtc" } +dependencies = [ + { name = "aiofiles" }, + { name = "numpy" }, + { name = "protobuf" }, + { name = "types-protobuf" }, +] + +[package.metadata] +requires-dist = [ + { name = "aiofiles", specifier = ">=24" }, + { name = "numpy", specifier = ">=1.26" }, + { name = "protobuf", specifier = ">=4.25.0" }, + { name = "types-protobuf", specifier = ">=3" }, +] + +[[package]] +name = "livekit-agents" +version = "1.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiofiles" }, + { name = "aiohttp" }, + { name = "av" }, + { name = "certifi" }, + { name = "click" }, + { name = "colorama" }, + { name = "docstring-parser" }, + { name = "eval-type-backport" }, + { name = "livekit" }, + { name = "livekit-api" }, + { name = "livekit-blingfire" }, + { name = "livekit-protocol" }, + { name = "nest-asyncio" }, + { name = "numpy" }, + { name = "openai" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp" }, + { name = "opentelemetry-sdk" }, + { name = "prometheus-client" }, + { name = "protobuf" }, + { name = "psutil" }, + { name = "pydantic" }, + { name = "pyjwt" }, + { name = "sounddevice" }, + { name = "typer" }, + { name = "types-protobuf" }, + { name = "typing-extensions" }, + { name = "watchfiles" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b4/05/44a505c2173f60156f04f10b38996dbe41d39d2443fb0207c7269779c7f9/livekit_agents-1.5.6.tar.gz", hash = "sha256:a35a77889f2347fbb1cad6020d748bae66838d30e7a8f592f4928209bc957194", size = 2485827, upload-time = "2026-04-22T20:21:31.521Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/22/e0a5fc0f3f4145c46fbf5a373c2c199571685b57ac275fdcbb42444862ab/livekit_agents-1.5.6-py3-none-any.whl", hash = "sha256:8c4cf05e20a5b2c7127d3d2ad8f8fa0e6f3aa753cfa00b4099b8a59471bd428c", size = 2585534, upload-time = "2026-04-22T20:21:29.412Z" }, +] + +[package.optional-dependencies] +codecs = [ + { name = "numpy" }, +] +images = [ + { name = "pillow" }, +] +openai = [ + { name = "livekit-plugins-openai" }, +] +xai = [ + { name = "livekit-plugins-xai" }, +] + +[[package]] +name = "livekit-api" +source = { editable = "../../livekit-api" } +dependencies = [ + { name = "aiohttp" }, + { name = "livekit-protocol" }, + { name = "protobuf" }, + { name = "pyjwt" }, + { name = "types-protobuf" }, +] + +[package.metadata] +requires-dist = [ + { name = "aiohttp", specifier = ">=3.9.0" }, + { name = "livekit-protocol", editable = "../../livekit-protocol" }, + { name = "protobuf", specifier = ">=4" }, + { name = "pyjwt", specifier = ">=2.0.0" }, + { name = "types-protobuf", specifier = ">=4" }, +] + +[[package]] +name = "livekit-blingfire" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/09/1095ace608a41810d5c0f343eff36154505487c415acd9c653a882ff2cf1/livekit_blingfire-1.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0358058ba6cba59379d22a01acef6ff8a729b0facf880c0f75d13c26f1315c9d", size = 153650, upload-time = "2025-12-16T00:48:05.976Z" }, + { url = "https://files.pythonhosted.org/packages/80/a5/f4eb0e5d97334581440d37ced2a1db4fdfc8454c641c7c144e858012f1ce/livekit_blingfire-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a0741a8abcfaa1f3af2313271f15ac0f79777681a8e3ab9a782a68d8eb121c89", size = 148628, upload-time = "2025-12-16T00:48:06.998Z" }, + { url = "https://files.pythonhosted.org/packages/89/f9/dc5ad008cb8b9c2a300bb7f7d44f022cd4970a32707eb90358290a07f0e1/livekit_blingfire-1.1.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d99d7a34c9350da3a6ea738bc282a5f5b4ac4ffb7f8aa5251dfa96070ad845f6", size = 166832, upload-time = "2025-12-16T00:48:07.919Z" }, + { url = "https://files.pythonhosted.org/packages/8f/27/408c435cbed31fa3601ff32ef0499ff594cd898b483c9b4017e9df906de6/livekit_blingfire-1.1.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:815aca6c2f823fa25d7a15d8d76ce18b0295aa5ce2c988ed64fdbd9c4d3ced0a", size = 173959, upload-time = "2025-12-16T00:48:09.153Z" }, + { url = "https://files.pythonhosted.org/packages/2f/12/c826a40b32bfda29e7f826e50dfbd3c0a70726cb8c0cb5023d2311823bd2/livekit_blingfire-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:7ae045d44d8cb867fc449f44a95c0287f6e5d225e62e24f4574bac8f26ede845", size = 130006, upload-time = "2025-12-16T00:48:10.176Z" }, + { url = "https://files.pythonhosted.org/packages/dd/18/8be31c84e911218011e6e653ca466fef320a4e7bc926aa694bc4cb6625f9/livekit_blingfire-1.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9d5fb6746263529b780dc8bf7a6e6a80ff5fa7fa729e403f2b925996d041e039", size = 154567, upload-time = "2025-12-16T00:48:11.097Z" }, + { url = "https://files.pythonhosted.org/packages/03/64/bb5463d4a6a97888d52caa6256d242acab1f7eabcc59343f7874a89a30dc/livekit_blingfire-1.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d4d5642e36fc0a9f89a5154affbd12305ae008c34c7b32f00fe00127ab18d6bd", size = 148792, upload-time = "2025-12-16T00:48:12.324Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9f/ec51ebce455e17b6f304044e2bda57b15b1b45fd20b2feefa6e242fa33c6/livekit_blingfire-1.1.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:502d7a41fed246ec9cc432646d523c488a05fb2e572187a754735532ba5d69b7", size = 167606, upload-time = "2025-12-16T00:48:13.611Z" }, + { url = "https://files.pythonhosted.org/packages/d1/19/a4b56e54af456f2667287497f7678ff69a82ad21a687fc540213b4f25982/livekit_blingfire-1.1.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cdec36ea4d8b0dcda2791358ac9965e832539ecf13e651011197bab9960ea156", size = 174972, upload-time = "2025-12-16T00:48:14.811Z" }, + { url = "https://files.pythonhosted.org/packages/32/29/032cbf2c88ca40bee25b8a1b5346b5cb66487e689c4f42dd19f7e745090d/livekit_blingfire-1.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:28d8c822616ca2ce53125040dfe09d06a6cc3e63c9055d39ca767a5c8f67ef84", size = 131026, upload-time = "2025-12-16T00:48:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/81/50/46e410b935154a6bcf2d9494ee8e298b1a9c91ae33beaa78346703cf7681/livekit_blingfire-1.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f5f6a40e498940f5b2e53d9753f5f7fb7f909e12a93a158844c9e3e99a5486b8", size = 154623, upload-time = "2025-12-16T00:48:17.641Z" }, + { url = "https://files.pythonhosted.org/packages/de/b4/f51c25bf104e51703dc66558ff9831a9769a9effa397956268902784a3d0/livekit_blingfire-1.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:945a672a224c9a686925e9af94c2660bacdbe190ccf693d6f17cea9359426c15", size = 148846, upload-time = "2025-12-16T00:48:18.591Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d2/ad95d195ed6dccb6527ed3c1e753f211c3e9509050af5cddf007608bb104/livekit_blingfire-1.1.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f3aac3207cdd88c62323e0b07c33a69aac79c544122a2ddfbecc6c721ca760c", size = 167886, upload-time = "2025-12-16T00:48:19.858Z" }, + { url = "https://files.pythonhosted.org/packages/c5/67/fc4af1bbbed319d8edc319051bce720b51fa544f5d2ebb3201240779f135/livekit_blingfire-1.1.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:839feefa2910f99d794d3f3d696f95193ee8188cc6688a8d712bade2cede7951", size = 175858, upload-time = "2025-12-16T00:48:21.144Z" }, + { url = "https://files.pythonhosted.org/packages/76/6c/9e14763826476925767b511531318a83f95f3bf9e4dbc7dc611400af6e9e/livekit_blingfire-1.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:1409d4c297260b60a37bfe6ba21e4fb59dd53cd929632c0a78a28d41fe424302", size = 131048, upload-time = "2025-12-16T00:48:22.17Z" }, + { url = "https://files.pythonhosted.org/packages/d7/9c/81fc3b7835fbee79ebf9a28cb4c673fa5fce30e5d8659fadaeed4ecb0f53/livekit_blingfire-1.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:81a5942894944a5773dfa2ce800d016c5f5d8868cd01db1d4b099aa951df41aa", size = 154889, upload-time = "2025-12-16T00:48:23.181Z" }, + { url = "https://files.pythonhosted.org/packages/e8/83/976000dbd2781f5018cff52bc470cd48c7344ce5bd33f8417cbed5adaf8f/livekit_blingfire-1.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ed861a19759987314ae71f2315d9bef11a3d6cc11e9effd5b9a3f0c567a3ba8d", size = 149170, upload-time = "2025-12-16T00:48:24.419Z" }, + { url = "https://files.pythonhosted.org/packages/23/5f/f3b3b83758638aa90803946659dd6236253de3b529a9fb6148a0ad8dcab1/livekit_blingfire-1.1.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4cbcd68b2dea451be70e26cefa7cffb7a02aeacdbfa0efaa33cce7474e15983", size = 168075, upload-time = "2025-12-16T00:48:26.377Z" }, + { url = "https://files.pythonhosted.org/packages/ba/82/44e068acf6f9cf2abe0bc019c7073330cb8211e196e2767cacbdf3e4bf57/livekit_blingfire-1.1.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:db593c044a3aff38af0b4d4f3d739aad4b24c740c80255bffaca07af2f9e6721", size = 175825, upload-time = "2025-12-16T00:48:27.377Z" }, + { url = "https://files.pythonhosted.org/packages/ad/2b/be8b3096727391726a7b382c5b98042ae6d29af1eee7c8467a93f823bcca/livekit_blingfire-1.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:bb23eb24d6a27df7205a562ce8c4d0a495d9d2a23aa3b5dec142d07401aeb342", size = 135843, upload-time = "2025-12-16T00:48:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/2f/9e/a9bf3a927c5c9544acef40a51f67b40aaba23bfcae63ab1f80418e25d9ce/livekit_blingfire-1.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a6c4d3ee6ef7c0597dc737837997082d7a1eb69aed6efb12688dd2bef0d5b282", size = 157380, upload-time = "2025-12-16T00:48:29.268Z" }, + { url = "https://files.pythonhosted.org/packages/fa/61/8c2f68c4bab4202746c4f13670d8e7cf40dcbc0a32f292492e0c483f3811/livekit_blingfire-1.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5f4076098363dc5b57d8c5a6781a48539ebb35d82c1fe9587c047167ccf844d", size = 153248, upload-time = "2025-12-16T00:48:30.241Z" }, + { url = "https://files.pythonhosted.org/packages/72/08/93ed14e757f3bb3d22c40e11900ea2815883b7beb331fe758c8d40ea1dd0/livekit_blingfire-1.1.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20b95b2c15c4a1af4e68c1aa7d885bf295f89ee6eb5c1a1fdfa315a51795b30d", size = 170081, upload-time = "2025-12-16T00:48:31.268Z" }, + { url = "https://files.pythonhosted.org/packages/0f/6d/b2a23cafabf55561c463490b3a87e323640259ae340e6db26bb71e0fa26d/livekit_blingfire-1.1.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c13ef26e5234674ac353b7cfaadeb23468e951eb07461b6b6c77f79cd5ff763", size = 176755, upload-time = "2025-12-16T00:48:32.294Z" }, + { url = "https://files.pythonhosted.org/packages/60/93/c00c175d2187160bdb2dac6b338203d51396307dfce23f03defb3b5e5572/livekit_blingfire-1.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91b2315e0497383384304d33554d70b8a63dec5ad96cd43437c67f4172077cf", size = 141072, upload-time = "2025-12-16T00:48:33.423Z" }, +] + +[[package]] +name = "livekit-plugins-openai" +version = "1.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "livekit-agents", extra = ["codecs", "images"] }, + { name = "openai", extra = ["realtime"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f2/90/11573bd130ce6bb173c3ae24a2dc23b3f040504ddb99ea4d47548d7a4e0a/livekit_plugins_openai-1.5.6.tar.gz", hash = "sha256:e6c8fa6560f5adcbb47b61d674749805b9e7df64b3dd44421ddc2529b506f12c", size = 43026, upload-time = "2026-04-22T20:23:01.512Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/0a/0f55f595ea6075a80234df26cdadf3d863de051cd2211d8fc3e4139c9622/livekit_plugins_openai-1.5.6-py3-none-any.whl", hash = "sha256:f7e8c14cbafbe837b271ff5c0e6fff7292ef536d50c00f48da3b23823e1aaea9", size = 49797, upload-time = "2026-04-22T20:23:00.253Z" }, +] + +[[package]] +name = "livekit-plugins-xai" +version = "1.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "livekit-agents", extra = ["openai"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e3/a1/eaad8e48fc8318565de679e6c5294fc83917917a2edc2673c045aa77cd69/livekit_plugins_xai-1.5.6.tar.gz", hash = "sha256:caf7561c6cde0bcf77145454f64378174bcbaba20f5d226ba3afb869de2636dd", size = 12279, upload-time = "2026-04-22T20:23:48.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/57/2331e7d174154c4a47c8cf3df290262a7054e41a138854f210ad1abeefba/livekit_plugins_xai-1.5.6-py3-none-any.whl", hash = "sha256:e52c534ff279690762cebd39eaf4269b88322a56ef7b0f8082286d2204523f9c", size = 16227, upload-time = "2026-04-22T20:23:46.771Z" }, +] + +[[package]] +name = "livekit-protocol" +source = { editable = "../../livekit-protocol" } +dependencies = [ + { name = "protobuf" }, + { name = "types-protobuf" }, +] + +[package.metadata] +requires-dist = [ + { name = "protobuf", specifier = ">=4" }, + { name = "types-protobuf", specifier = ">=4" }, +] + +[[package]] +name = "livekit-wakeword" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "onnxruntime" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/19/143fb2b8cfcd8cb15eedaff87eeb73c27a81cc5c4f6c1721b18384e6f00b/livekit_wakeword-0.2.0.tar.gz", hash = "sha256:65fccf346a9d8d70d33449b89b62458863178e724bdabb2315f2333875e9f570", size = 1890077, upload-time = "2026-04-17T12:16:29.134Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/79/d95ed6a5e9099babf3329a28164be8eb313722d699a4d07d599da00652f4/livekit_wakeword-0.2.0-py3-none-any.whl", hash = "sha256:6bfa3a5e0fa6d5053ed8fb49e845a672fd44fb6b8427b33de29ea36361849207", size = 1910694, upload-time = "2026-04-17T12:16:26.526Z" }, +] + +[[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" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" }, + { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" }, + { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" }, + { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" }, + { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" }, + { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" }, + { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" }, + { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" }, + { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" }, + { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" }, + { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" }, + { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" }, + { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" }, + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" }, + { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" }, + { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" }, + { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" }, + { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" }, + { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" }, + { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" }, + { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" }, + { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" }, + { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" }, + { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" }, + { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" }, + { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" }, + { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" }, + { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" }, + { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" }, + { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" }, + { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" }, + { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" }, + { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" }, + { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" }, + { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" }, + { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" }, + { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" }, + { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" }, + { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" }, + { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" }, + { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" }, + { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" }, + { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", hash = "sha256:2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0", size = 20731587, upload-time = "2026-03-29T13:22:01.298Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/c6/4218570d8c8ecc9704b5157a3348e486e84ef4be0ed3e38218ab473c83d2/numpy-2.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f983334aea213c99992053ede6168500e5f086ce74fbc4acc3f2b00f5762e9db", size = 16976799, upload-time = "2026-03-29T13:18:15.438Z" }, + { url = "https://files.pythonhosted.org/packages/dd/92/b4d922c4a5f5dab9ed44e6153908a5c665b71acf183a83b93b690996e39b/numpy-2.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:72944b19f2324114e9dc86a159787333b77874143efcf89a5167ef83cfee8af0", size = 14971552, upload-time = "2026-03-29T13:18:18.606Z" }, + { url = "https://files.pythonhosted.org/packages/8a/dc/df98c095978fa6ee7b9a9387d1d58cbb3d232d0e69ad169a4ce784bde4fd/numpy-2.4.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:86b6f55f5a352b48d7fbfd2dbc3d5b780b2d79f4d3c121f33eb6efb22e9a2015", size = 5476566, upload-time = "2026-03-29T13:18:21.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/34/b3fdcec6e725409223dd27356bdf5a3c2cc2282e428218ecc9cb7acc9763/numpy-2.4.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:ba1f4fc670ed79f876f70082eff4f9583c15fb9a4b89d6188412de4d18ae2f40", size = 6806482, upload-time = "2026-03-29T13:18:23.634Z" }, + { url = "https://files.pythonhosted.org/packages/68/62/63417c13aa35d57bee1337c67446761dc25ea6543130cf868eace6e8157b/numpy-2.4.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a87ec22c87be071b6bdbd27920b129b94f2fc964358ce38f3822635a3e2e03d", size = 15973376, upload-time = "2026-03-29T13:18:26.677Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c5/9fcb7e0e69cef59cf10c746b84f7d58b08bc66a6b7d459783c5a4f6101a6/numpy-2.4.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df3775294accfdd75f32c74ae39fcba920c9a378a2fc18a12b6820aa8c1fb502", size = 16925137, upload-time = "2026-03-29T13:18:30.14Z" }, + { url = "https://files.pythonhosted.org/packages/7e/43/80020edacb3f84b9efdd1591120a4296462c23fd8db0dde1666f6ef66f13/numpy-2.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d4e437e295f18ec29bc79daf55e8a47a9113df44d66f702f02a293d93a2d6dd", size = 17329414, upload-time = "2026-03-29T13:18:33.733Z" }, + { url = "https://files.pythonhosted.org/packages/fd/06/af0658593b18a5f73532d377188b964f239eb0894e664a6c12f484472f97/numpy-2.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6aa3236c78803afbcb255045fbef97a9e25a1f6c9888357d205ddc42f4d6eba5", size = 18658397, upload-time = "2026-03-29T13:18:37.511Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ce/13a09ed65f5d0ce5c7dd0669250374c6e379910f97af2c08c57b0608eee4/numpy-2.4.4-cp311-cp311-win32.whl", hash = "sha256:30caa73029a225b2d40d9fae193e008e24b2026b7ee1a867b7ee8d96ca1a448e", size = 6239499, upload-time = "2026-03-29T13:18:40.372Z" }, + { url = "https://files.pythonhosted.org/packages/bd/63/05d193dbb4b5eec1eca73822d80da98b511f8328ad4ae3ca4caf0f4db91d/numpy-2.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:6bbe4eb67390b0a0265a2c25458f6b90a409d5d069f1041e6aff1e27e3d9a79e", size = 12614257, upload-time = "2026-03-29T13:18:42.95Z" }, + { url = "https://files.pythonhosted.org/packages/87/c5/8168052f080c26fa984c413305012be54741c9d0d74abd7fbeeccae3889f/numpy-2.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:fcfe2045fd2e8f3cb0ce9d4ba6dba6333b8fa05bb8a4939c908cd43322d14c7e", size = 10486775, upload-time = "2026-03-29T13:18:45.835Z" }, + { url = "https://files.pythonhosted.org/packages/28/05/32396bec30fb2263770ee910142f49c1476d08e8ad41abf8403806b520ce/numpy-2.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15716cfef24d3a9762e3acdf87e27f58dc823d1348f765bbea6bef8c639bfa1b", size = 16689272, upload-time = "2026-03-29T13:18:49.223Z" }, + { url = "https://files.pythonhosted.org/packages/c5/f3/a983d28637bfcd763a9c7aafdb6d5c0ebf3d487d1e1459ffdb57e2f01117/numpy-2.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23cbfd4c17357c81021f21540da84ee282b9c8fba38a03b7b9d09ba6b951421e", size = 14699573, upload-time = "2026-03-29T13:18:52.629Z" }, + { url = "https://files.pythonhosted.org/packages/9b/fd/e5ecca1e78c05106d98028114f5c00d3eddb41207686b2b7de3e477b0e22/numpy-2.4.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8b3b60bb7cba2c8c81837661c488637eee696f59a877788a396d33150c35d842", size = 5204782, upload-time = "2026-03-29T13:18:55.579Z" }, + { url = "https://files.pythonhosted.org/packages/de/2f/702a4594413c1a8632092beae8aba00f1d67947389369b3777aed783fdca/numpy-2.4.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e4a010c27ff6f210ff4c6ef34394cd61470d01014439b192ec22552ee867f2a8", size = 6552038, upload-time = "2026-03-29T13:18:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121", size = 15670666, upload-time = "2026-03-29T13:19:00.341Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e", size = 16645480, upload-time = "2026-03-29T13:19:03.63Z" }, + { url = "https://files.pythonhosted.org/packages/34/49/f2312c154b82a286758ee2f1743336d50651f8b5195db18cdb63675ff649/numpy-2.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:62d6b0f03b694173f9fcb1fb317f7222fd0b0b103e784c6549f5e53a27718c44", size = 17020036, upload-time = "2026-03-29T13:19:07.428Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e9/736d17bd77f1b0ec4f9901aaec129c00d59f5d84d5e79bba540ef12c2330/numpy-2.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fbc356aae7adf9e6336d336b9c8111d390a05df88f1805573ebb0807bd06fd1d", size = 18368643, upload-time = "2026-03-29T13:19:10.775Z" }, + { url = "https://files.pythonhosted.org/packages/63/f6/d417977c5f519b17c8a5c3bc9e8304b0908b0e21136fe43bf628a1343914/numpy-2.4.4-cp312-cp312-win32.whl", hash = "sha256:0d35aea54ad1d420c812bfa0385c71cd7cc5bcf7c65fed95fc2cd02fe8c79827", size = 5961117, upload-time = "2026-03-29T13:19:13.464Z" }, + { url = "https://files.pythonhosted.org/packages/2d/5b/e1deebf88ff431b01b7406ca3583ab2bbb90972bbe1c568732e49c844f7e/numpy-2.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:b5f0362dc928a6ecd9db58868fca5e48485205e3855957bdedea308f8672ea4a", size = 12320584, upload-time = "2026-03-29T13:19:16.155Z" }, + { url = "https://files.pythonhosted.org/packages/58/89/e4e856ac82a68c3ed64486a544977d0e7bdd18b8da75b78a577ca31c4395/numpy-2.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:846300f379b5b12cc769334464656bc882e0735d27d9726568bc932fdc49d5ec", size = 10221450, upload-time = "2026-03-29T13:19:18.994Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d0a583ce4fefcc3308806a749a536c201ed6b5ad6e1322e227ee4848979d/numpy-2.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:08f2e31ed5e6f04b118e49821397f12767934cfdd12a1ce86a058f91e004ee50", size = 16684933, upload-time = "2026-03-29T13:19:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2b7a48fbb745d344742c0277f01286dead15f3f68e4f359fbfcf7b48f70f/numpy-2.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e823b8b6edc81e747526f70f71a9c0a07ac4e7ad13020aa736bb7c9d67196115", size = 14694532, upload-time = "2026-03-29T13:19:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/e5/87/499737bfba066b4a3bebff24a8f1c5b2dee410b209bc6668c9be692580f0/numpy-2.4.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:4a19d9dba1a76618dd86b164d608566f393f8ec6ac7c44f0cc879011c45e65af", size = 5199661, upload-time = "2026-03-29T13:19:28.31Z" }, + { url = "https://files.pythonhosted.org/packages/cd/da/464d551604320d1491bc345efed99b4b7034143a85787aab78d5691d5a0e/numpy-2.4.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d2a8490669bfe99a233298348acc2d824d496dee0e66e31b66a6022c2ad74a5c", size = 6547539, upload-time = "2026-03-29T13:19:30.97Z" }, + { url = "https://files.pythonhosted.org/packages/7d/90/8d23e3b0dafd024bf31bdec225b3bb5c2dbfa6912f8a53b8659f21216cbf/numpy-2.4.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45dbed2ab436a9e826e302fcdcbe9133f9b0006e5af7168afb8963a6520da103", size = 15668806, upload-time = "2026-03-29T13:19:33.887Z" }, + { url = "https://files.pythonhosted.org/packages/d1/73/a9d864e42a01896bb5974475438f16086be9ba1f0d19d0bb7a07427c4a8b/numpy-2.4.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c901b15172510173f5cb310eae652908340f8dede90fff9e3bf6c0d8dfd92f83", size = 16632682, upload-time = "2026-03-29T13:19:37.336Z" }, + { url = "https://files.pythonhosted.org/packages/34/fb/14570d65c3bde4e202a031210475ae9cde9b7686a2e7dc97ee67d2833b35/numpy-2.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:99d838547ace2c4aace6c4f76e879ddfe02bb58a80c1549928477862b7a6d6ed", size = 17019810, upload-time = "2026-03-29T13:19:40.963Z" }, + { url = "https://files.pythonhosted.org/packages/8a/77/2ba9d87081fd41f6d640c83f26fb7351e536b7ce6dd9061b6af5904e8e46/numpy-2.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0aec54fd785890ecca25a6003fd9a5aed47ad607bbac5cd64f836ad8666f4959", size = 18357394, upload-time = "2026-03-29T13:19:44.859Z" }, + { url = "https://files.pythonhosted.org/packages/a2/23/52666c9a41708b0853fa3b1a12c90da38c507a3074883823126d4e9d5b30/numpy-2.4.4-cp313-cp313-win32.whl", hash = "sha256:07077278157d02f65c43b1b26a3886bce886f95d20aabd11f87932750dfb14ed", size = 5959556, upload-time = "2026-03-29T13:19:47.661Z" }, + { url = "https://files.pythonhosted.org/packages/57/fb/48649b4971cde70d817cf97a2a2fdc0b4d8308569f1dd2f2611959d2e0cf/numpy-2.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:5c70f1cc1c4efbe316a572e2d8b9b9cc44e89b95f79ca3331553fbb63716e2bf", size = 12317311, upload-time = "2026-03-29T13:19:50.67Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d8/11490cddd564eb4de97b4579ef6bfe6a736cc07e94c1598590ae25415e01/numpy-2.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:ef4059d6e5152fa1a39f888e344c73fdc926e1b2dd58c771d67b0acfbf2aa67d", size = 10222060, upload-time = "2026-03-29T13:19:54.229Z" }, + { url = "https://files.pythonhosted.org/packages/99/5d/dab4339177a905aad3e2221c915b35202f1ec30d750dd2e5e9d9a72b804b/numpy-2.4.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4bbc7f303d125971f60ec0aaad5e12c62d0d2c925f0ab1273debd0e4ba37aba5", size = 14822302, upload-time = "2026-03-29T13:19:57.585Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e4/0564a65e7d3d97562ed6f9b0fd0fb0a6f559ee444092f105938b50043876/numpy-2.4.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:4d6d57903571f86180eb98f8f0c839fa9ebbfb031356d87f1361be91e433f5b7", size = 5327407, upload-time = "2026-03-29T13:20:00.601Z" }, + { url = "https://files.pythonhosted.org/packages/29/8d/35a3a6ce5ad371afa58b4700f1c820f8f279948cca32524e0a695b0ded83/numpy-2.4.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:4636de7fd195197b7535f231b5de9e4b36d2c440b6e566d2e4e4746e6af0ca93", size = 6647631, upload-time = "2026-03-29T13:20:02.855Z" }, + { url = "https://files.pythonhosted.org/packages/f4/da/477731acbd5a58a946c736edfdabb2ac5b34c3d08d1ba1a7b437fa0884df/numpy-2.4.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ad2e2ef14e0b04e544ea2fa0a36463f847f113d314aa02e5b402fdf910ef309e", size = 15727691, upload-time = "2026-03-29T13:20:06.004Z" }, + { url = "https://files.pythonhosted.org/packages/e6/db/338535d9b152beabeb511579598418ba0212ce77cf9718edd70262cc4370/numpy-2.4.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a285b3b96f951841799528cd1f4f01cd70e7e0204b4abebac9463eecfcf2a40", size = 16681241, upload-time = "2026-03-29T13:20:09.417Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a9/ad248e8f58beb7a0219b413c9c7d8151c5d285f7f946c3e26695bdbbe2df/numpy-2.4.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f8474c4241bc18b750be2abea9d7a9ec84f46ef861dbacf86a4f6e043401f79e", size = 17085767, upload-time = "2026-03-29T13:20:13.126Z" }, + { url = "https://files.pythonhosted.org/packages/b5/1a/3b88ccd3694681356f70da841630e4725a7264d6a885c8d442a697e1146b/numpy-2.4.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4e874c976154687c1f71715b034739b45c7711bec81db01914770373d125e392", size = 18403169, upload-time = "2026-03-29T13:20:17.096Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c9/fcfd5d0639222c6eac7f304829b04892ef51c96a75d479214d77e3ce6e33/numpy-2.4.4-cp313-cp313t-win32.whl", hash = "sha256:9c585a1790d5436a5374bac930dad6ed244c046ed91b2b2a3634eb2971d21008", size = 6083477, upload-time = "2026-03-29T13:20:20.195Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e3/3938a61d1c538aaec8ed6fd6323f57b0c2d2d2219512434c5c878db76553/numpy-2.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:93e15038125dc1e5345d9b5b68aa7f996ec33b98118d18c6ca0d0b7d6198b7e8", size = 12457487, upload-time = "2026-03-29T13:20:22.946Z" }, + { url = "https://files.pythonhosted.org/packages/97/6a/7e345032cc60501721ef94e0e30b60f6b0bd601f9174ebd36389a2b86d40/numpy-2.4.4-cp313-cp313t-win_arm64.whl", hash = "sha256:0dfd3f9d3adbe2920b68b5cd3d51444e13a10792ec7154cd0a2f6e74d4ab3233", size = 10292002, upload-time = "2026-03-29T13:20:25.909Z" }, + { url = "https://files.pythonhosted.org/packages/6e/06/c54062f85f673dd5c04cbe2f14c3acb8c8b95e3384869bb8cc9bff8cb9df/numpy-2.4.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f169b9a863d34f5d11b8698ead99febeaa17a13ca044961aa8e2662a6c7766a0", size = 16684353, upload-time = "2026-03-29T13:20:29.504Z" }, + { url = "https://files.pythonhosted.org/packages/4c/39/8a320264a84404c74cc7e79715de85d6130fa07a0898f67fb5cd5bd79908/numpy-2.4.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2483e4584a1cb3092da4470b38866634bafb223cbcd551ee047633fd2584599a", size = 14704914, upload-time = "2026-03-29T13:20:33.547Z" }, + { url = "https://files.pythonhosted.org/packages/91/fb/287076b2614e1d1044235f50f03748f31fa287e3dbe6abeb35cdfa351eca/numpy-2.4.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:2d19e6e2095506d1736b7d80595e0f252d76b89f5e715c35e06e937679ea7d7a", size = 5210005, upload-time = "2026-03-29T13:20:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/63/eb/fcc338595309910de6ecabfcef2419a9ce24399680bfb149421fa2df1280/numpy-2.4.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:6a246d5914aa1c820c9443ddcee9c02bec3e203b0c080349533fae17727dfd1b", size = 6544974, upload-time = "2026-03-29T13:20:39.014Z" }, + { url = "https://files.pythonhosted.org/packages/44/5d/e7e9044032a716cdfaa3fba27a8e874bf1c5f1912a1ddd4ed071bf8a14a6/numpy-2.4.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:989824e9faf85f96ec9c7761cd8d29c531ad857bfa1daa930cba85baaecf1a9a", size = 15684591, upload-time = "2026-03-29T13:20:42.146Z" }, + { url = "https://files.pythonhosted.org/packages/98/7c/21252050676612625449b4807d6b695b9ce8a7c9e1c197ee6216c8a65c7c/numpy-2.4.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27a8d92cd10f1382a67d7cf4db7ce18341b66438bdd9f691d7b0e48d104c2a9d", size = 16637700, upload-time = "2026-03-29T13:20:46.204Z" }, + { url = "https://files.pythonhosted.org/packages/b1/29/56d2bbef9465db24ef25393383d761a1af4f446a1df9b8cded4fe3a5a5d7/numpy-2.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e44319a2953c738205bf3354537979eaa3998ed673395b964c1176083dd46252", size = 17035781, upload-time = "2026-03-29T13:20:50.242Z" }, + { url = "https://files.pythonhosted.org/packages/e3/2b/a35a6d7589d21f44cea7d0a98de5ddcbb3d421b2622a5c96b1edf18707c3/numpy-2.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e892aff75639bbef0d2a2cfd55535510df26ff92f63c92cd84ef8d4ba5a5557f", size = 18362959, upload-time = "2026-03-29T13:20:54.019Z" }, + { url = "https://files.pythonhosted.org/packages/64/c9/d52ec581f2390e0f5f85cbfd80fb83d965fc15e9f0e1aec2195faa142cde/numpy-2.4.4-cp314-cp314-win32.whl", hash = "sha256:1378871da56ca8943c2ba674530924bb8ca40cd228358a3b5f302ad60cf875fc", size = 6008768, upload-time = "2026-03-29T13:20:56.912Z" }, + { url = "https://files.pythonhosted.org/packages/fa/22/4cc31a62a6c7b74a8730e31a4274c5dc80e005751e277a2ce38e675e4923/numpy-2.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:715d1c092715954784bc79e1174fc2a90093dc4dc84ea15eb14dad8abdcdeb74", size = 12449181, upload-time = "2026-03-29T13:20:59.548Z" }, + { url = "https://files.pythonhosted.org/packages/70/2e/14cda6f4d8e396c612d1bf97f22958e92148801d7e4f110cabebdc0eef4b/numpy-2.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:2c194dd721e54ecad9ad387c1d35e63dce5c4450c6dc7dd5611283dda239aabb", size = 10496035, upload-time = "2026-03-29T13:21:02.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e8/8fed8c8d848d7ecea092dc3469643f9d10bc3a134a815a3b033da1d2039b/numpy-2.4.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2aa0613a5177c264ff5921051a5719d20095ea586ca88cc802c5c218d1c67d3e", size = 14824958, upload-time = "2026-03-29T13:21:05.671Z" }, + { url = "https://files.pythonhosted.org/packages/05/1a/d8007a5138c179c2bf33ef44503e83d70434d2642877ee8fbb230e7c0548/numpy-2.4.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:42c16925aa5a02362f986765f9ebabf20de75cdefdca827d14315c568dcab113", size = 5330020, upload-time = "2026-03-29T13:21:08.635Z" }, + { url = "https://files.pythonhosted.org/packages/99/64/ffb99ac6ae93faf117bcbd5c7ba48a7f45364a33e8e458545d3633615dda/numpy-2.4.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:874f200b2a981c647340f841730fc3a2b54c9d940566a3c4149099591e2c4c3d", size = 6650758, upload-time = "2026-03-29T13:21:10.949Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6e/795cc078b78a384052e73b2f6281ff7a700e9bf53bcce2ee579d4f6dd879/numpy-2.4.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9b39d38a9bd2ae1becd7eac1303d031c5c110ad31f2b319c6e7d98b135c934d", size = 15729948, upload-time = "2026-03-29T13:21:14.047Z" }, + { url = "https://files.pythonhosted.org/packages/5f/86/2acbda8cc2af5f3d7bfc791192863b9e3e19674da7b5e533fded124d1299/numpy-2.4.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b268594bccac7d7cf5844c7732e3f20c50921d94e36d7ec9b79e9857694b1b2f", size = 16679325, upload-time = "2026-03-29T13:21:17.561Z" }, + { url = "https://files.pythonhosted.org/packages/bc/59/cafd83018f4aa55e0ac6fa92aa066c0a1877b77a615ceff1711c260ffae8/numpy-2.4.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ac6b31e35612a26483e20750126d30d0941f949426974cace8e6b5c58a3657b0", size = 17084883, upload-time = "2026-03-29T13:21:21.106Z" }, + { url = "https://files.pythonhosted.org/packages/f0/85/a42548db84e65ece46ab2caea3d3f78b416a47af387fcbb47ec28e660dc2/numpy-2.4.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8e3ed142f2728df44263aaf5fb1f5b0b99f4070c553a0d7f033be65338329150", size = 18403474, upload-time = "2026-03-29T13:21:24.828Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ad/483d9e262f4b831000062e5d8a45e342166ec8aaa1195264982bca267e62/numpy-2.4.4-cp314-cp314t-win32.whl", hash = "sha256:dddbbd259598d7240b18c9d87c56a9d2fb3b02fe266f49a7c101532e78c1d871", size = 6155500, upload-time = "2026-03-29T13:21:28.205Z" }, + { url = "https://files.pythonhosted.org/packages/c7/03/2fc4e14c7bd4ff2964b74ba90ecb8552540b6315f201df70f137faa5c589/numpy-2.4.4-cp314-cp314t-win_amd64.whl", hash = "sha256:a7164afb23be6e37ad90b2f10426149fd75aee07ca55653d2aa41e66c4ef697e", size = 12637755, upload-time = "2026-03-29T13:21:31.107Z" }, + { url = "https://files.pythonhosted.org/packages/58/78/548fb8e07b1a341746bfbecb32f2c268470f45fa028aacdbd10d9bc73aab/numpy-2.4.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ba203255017337d39f89bdd58417f03c4426f12beed0440cfd933cb15f8669c7", size = 10566643, upload-time = "2026-03-29T13:21:34.339Z" }, + { url = "https://files.pythonhosted.org/packages/6b/33/8fae8f964a4f63ed528264ddf25d2b683d0b663e3cba26961eb838a7c1bd/numpy-2.4.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:58c8b5929fcb8287cbd6f0a3fae19c6e03a5c48402ae792962ac465224a629a4", size = 16854491, upload-time = "2026-03-29T13:21:38.03Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d0/1aabee441380b981cf8cdda3ae7a46aa827d1b5a8cce84d14598bc94d6d9/numpy-2.4.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:eea7ac5d2dce4189771cedb559c738a71512768210dc4e4753b107a2048b3d0e", size = 14895830, upload-time = "2026-03-29T13:21:41.509Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b8/aafb0d1065416894fccf4df6b49ef22b8db045187949545bced89c034b8e/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:51fc224f7ca4d92656d5a5eb315f12eb5fe2c97a66249aa7b5f562528a3be38c", size = 5400927, upload-time = "2026-03-29T13:21:44.747Z" }, + { url = "https://files.pythonhosted.org/packages/d6/77/063baa20b08b431038c7f9ff5435540c7b7265c78cf56012a483019ca72d/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:28a650663f7314afc3e6ec620f44f333c386aad9f6fc472030865dc0ebb26ee3", size = 6715557, upload-time = "2026-03-29T13:21:47.406Z" }, + { url = "https://files.pythonhosted.org/packages/c7/a8/379542d45a14f149444c5c4c4e7714707239ce9cc1de8c2803958889da14/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:19710a9ca9992d7174e9c52f643d4272dcd1558c5f7af7f6f8190f633bd651a7", size = 15804253, upload-time = "2026-03-29T13:21:50.753Z" }, + { url = "https://files.pythonhosted.org/packages/a2/c8/f0a45426d6d21e7ea3310a15cf90c43a14d9232c31a837702dba437f3373/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b2aec6af35c113b05695ebb5749a787acd63cafc83086a05771d1e1cd1e555f", size = 16753552, upload-time = "2026-03-29T13:21:54.344Z" }, + { url = "https://files.pythonhosted.org/packages/04/74/f4c001f4714c3ad9ce037e18cf2b9c64871a84951eaa0baf683a9ca9301c/numpy-2.4.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f2cf083b324a467e1ab358c105f6cad5ea950f50524668a80c486ff1db24e119", size = 12509075, upload-time = "2026-03-29T13:21:57.644Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "flatbuffers" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/00/dccf702195572df51a40784fc939304595a0ae3577537d3b5be79273151a/onnxruntime-1.25.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:5cf58ec7601120bb4370f0b868f794d3e3626db7b1b1dba366c27874b224e9de", size = 17762805, upload-time = "2026-04-27T22:00:45.336Z" }, + { url = "https://files.pythonhosted.org/packages/64/2a/54a784e321093459ed18b8430ebb043af9049838a8b2c485fa7d41dca181/onnxruntime-1.25.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fa7d4daa78a18b8f3b410e31e82dab8580363c85cac644179a853f2748618e89", size = 15866935, upload-time = "2026-04-27T21:59:33.842Z" }, + { url = "https://files.pythonhosted.org/packages/b4/18/e3966c6035789a0b5b494ca0a9a5f331d57b5c15ae7795b9fffae2e277c5/onnxruntime-1.25.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:79162f873cdfa38cfc8d53d59a8dc7a71a14074df3d565b2f8ce24289545ddc0", size = 18007288, upload-time = "2026-04-27T22:00:02.34Z" }, + { url = "https://files.pythonhosted.org/packages/19/c1/a08f7ce3959af4ea7017210233a129c4c3260d08f728fdf6c0d4b743ce2d/onnxruntime-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:451b9494056f7f96b1be76a32745ccc4582bd61b2a0e1bc52de3708446151d5d", size = 12899002, upload-time = "2026-04-27T22:00:33.956Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f4/95de11cdc1b50686454c041273c9f84e67c4d1bc3ee40e36fa3dafe74c0a/onnxruntime-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:7e608f8950076da02c0aeceec2dd790d201eeb31dd73acb04ec989b2bf6199dc", size = 12625773, upload-time = "2026-04-27T22:00:22.483Z" }, + { url = "https://files.pythonhosted.org/packages/c0/52/8b2a10e8dedf5d486332bc2b3bca0b1ed8049c0b9e4a5cced95413aadfdd/onnxruntime-1.25.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:66e52f7a30d1f780a34aa84d68a0a04d382d9f5b141884ecbf45b7566b9fbde9", size = 17770987, upload-time = "2026-04-27T22:00:47.985Z" }, + { url = "https://files.pythonhosted.org/packages/3f/87/a424d2867477c42ef8c60172709281120797f7b0f1fd33cc36b24329c825/onnxruntime-1.25.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5f41779f044d1ff75593df5c10a4d311bc82563687796d5218e2685b8f9da25", size = 15871829, upload-time = "2026-04-27T21:59:39.088Z" }, + { url = "https://files.pythonhosted.org/packages/d4/55/7819e64c515f17c86005447ede8122b974ca851255a94125e2119376f0f8/onnxruntime-1.25.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:905409e9eb2ef87f8226e073f56e71faf731c3e480ebd34952cf953730e4a4ff", size = 18024586, upload-time = "2026-04-27T22:00:05.359Z" }, + { url = "https://files.pythonhosted.org/packages/89/36/b4f3eb5e95c66389aafd490950b5255e87c9333742cf90516eb50898e1dc/onnxruntime-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:d4097b75b77486bb45835a8ed25b9a67976040ec6c258aeabae6aadfbdd1201c", size = 12905112, upload-time = "2026-04-27T22:00:36.478Z" }, + { url = "https://files.pythonhosted.org/packages/38/fa/e5c43397632a399f542663ed3e3e37763ee203ba845b10b266cd2ede8925/onnxruntime-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:b6c7aa5cae606d5c90a392679fac074b60f80025a2e83e1e90fdf882bd2a97f0", size = 12634433, upload-time = "2026-04-27T22:00:25.918Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ee/db3ac55ef770347a926ac0f1317df0ab42c8bc604350833b30c7356bf936/onnxruntime-1.25.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e9d9b3b1694196bc3c5bc66f760a237a5e27d7688aaa2e2c9c0f66abd0486699", size = 17770761, upload-time = "2026-04-27T21:59:54.853Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9a/33225481a94a59906fce44e27ab12fc3bddd2aaecdc6160bd73341ca1aba/onnxruntime-1.25.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:311d29b943e46a55ca72ca1ea48d7815c993122bfc359f68215fddeb9583fff4", size = 15871542, upload-time = "2026-04-27T21:59:41.881Z" }, + { url = "https://files.pythonhosted.org/packages/8b/09/f20aac60f6fcf840543be54d4e9252cfeb7e8c2bb6d22477aaeb180e763e/onnxruntime-1.25.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98016a038b31160db23208706139fa3b99cd60bc1c5ffdade77aafd6a37a92ad", size = 18036960, upload-time = "2026-04-27T22:00:10.739Z" }, + { url = "https://files.pythonhosted.org/packages/50/83/47964ac7e2f7e2f9e83c69ec466642c6835466252cc2ef0561eafeb56b66/onnxruntime-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:08717d6eee2820807ba60b1b17032af207bd7aaca5b6c4abaee71f83feae877b", size = 12904886, upload-time = "2026-04-27T22:00:39.878Z" }, + { url = "https://files.pythonhosted.org/packages/d4/6c/a6c5aea47dc95fca7728f8a5af67c184ec9e7d4e7882125c7062e4bba8dd/onnxruntime-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:84f8963d70e00167bae273ab7e80e9795bfc5eb94f6b23236a99c5c11af00844", size = 12634117, upload-time = "2026-04-27T22:00:29.15Z" }, + { url = "https://files.pythonhosted.org/packages/a8/8a/3b65e7911eec86c125e3d6f43d690a6f68671500543c0390ecd6eb59b771/onnxruntime-1.25.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03e800b3a4b48d9f3a2d23aacc4fa95486a3b406b14e51d1a9b8b6981d9adf9c", size = 15882935, upload-time = "2026-04-27T21:59:44.912Z" }, + { url = "https://files.pythonhosted.org/packages/3c/bb/410a760694f8ae7bbfc5fa81ccbeb7da241e6d520ee02a333a439cf462a2/onnxruntime-1.25.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd83ef5c10cfc051a1cb465db692d57b996a1bc75a2a97b161398e29cdbc47ff", size = 18021727, upload-time = "2026-04-27T22:00:13.846Z" }, + { url = "https://files.pythonhosted.org/packages/fb/aa/04530bd38e31e26970fa1212346d76cf81705dc16a8ee5e6f4fb24634c11/onnxruntime-1.25.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:395eb662c437fa2407f44266e4778b75bff261b17c2a6fef042421f9069f871d", size = 17773721, upload-time = "2026-04-27T21:59:59.24Z" }, + { url = "https://files.pythonhosted.org/packages/ef/7f/ec79ab5cece6a688c944a7fa214a8511d548b9d5142a15d1a3d730b705f1/onnxruntime-1.25.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ae85395f41b291ae3e61780ec5092640181d369ef6c268aa8141c478b509e69", size = 15875954, upload-time = "2026-04-27T21:59:49.394Z" }, + { url = "https://files.pythonhosted.org/packages/67/fe/20428215d822099ea2c1e3cf35c295cf1a58f467bf18b6c607597a39c18a/onnxruntime-1.25.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:828e1b12710fbedb6dfab5e7bae6f11563617cddf3c2e7e8d84c64de566a4a3a", size = 18038703, upload-time = "2026-04-27T22:00:16.199Z" }, + { url = "https://files.pythonhosted.org/packages/5a/b1/b15db965e6a68bc47ca7eb584de4e6b3d2d2f484d46cc57f715b596f6528/onnxruntime-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:2affc9d2fd9ab013b9c9637464e649a0cca870d57ae18bfef74180eee65c3369", size = 13218513, upload-time = "2026-04-27T22:00:42.506Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f9/25cd2d1b29cdc8140eee4afbb6fb930b69125526632b1d579bc747975306/onnxruntime-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:3387d75d1a815b4b2495b4e47a05ef1b3bcb64a817ddc68587e0bfcb9702bcf6", size = 12969835, upload-time = "2026-04-27T22:00:31.504Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0e/6c507d1e65b2421fb44e241cbba577c7276792279485024fb1752b43f5c5/onnxruntime-1.25.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:06280b06604660595037f783c6d24bc70cbe5c6093975f194cd1482e77d450de", size = 15883298, upload-time = "2026-04-27T21:59:51.991Z" }, + { url = "https://files.pythonhosted.org/packages/df/4e/1c9df57496409dc86b320bd38f29ad7a34b7115e4f35b8fca44a827568a7/onnxruntime-1.25.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e79fd5ce7db10ebcc24e020e2ed0159476e69e2326b9b7828e5aadcf6184212", size = 18021249, upload-time = "2026-04-27T22:00:18.954Z" }, +] + +[[package]] +name = "openai" +version = "2.33.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f0/ee/d056c82f63c05f06baac0cffb4a90952d8274f90c49dfe244f20497b9bbd/openai-2.33.0.tar.gz", hash = "sha256:f850c435e2a4685bba3295bd54912dd26315d9c1b7733068186134d6e0599f9a", size = 693254, upload-time = "2026-04-28T14:04:42.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/32/37734d769bc8b42e4938785313cc05aade6cb0fa72479d3220a0d61a4e78/openai-2.33.0-py3-none-any.whl", hash = "sha256:03ac37d70e8c9e3a8124214e3afa785e2cbc12e627fbd98177a086ef2fd87ad5", size = 1162695, upload-time = "2026-04-28T14:04:40.482Z" }, +] + +[package.optional-dependencies] +realtime = [ + { name = "websockets" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.39.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/97/b9/3161be15bb8e3ad01be8be5a968a9237c3027c5be504362ff800fca3e442/opentelemetry_api-1.39.1.tar.gz", hash = "sha256:fbde8c80e1b937a2c61f20347e91c0c18a1940cecf012d62e65a7caf08967c9c", size = 65767, upload-time = "2025-12-11T13:32:39.182Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/df/d3f1ddf4bb4cb50ed9b1139cc7b1c54c34a1e7ce8fd1b9a37c0d1551a6bd/opentelemetry_api-1.39.1-py3-none-any.whl", hash = "sha256:2edd8463432a7f8443edce90972169b195e7d6a05500cd29e6d13898187c9950", size = 66356, upload-time = "2025-12-11T13:32:17.304Z" }, +] + +[[package]] +name = "opentelemetry-exporter-otlp" +version = "1.39.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-exporter-otlp-proto-grpc" }, + { name = "opentelemetry-exporter-otlp-proto-http" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/30/9c/3ab1db90f32da200dba332658f2bbe602369e3d19f6aba394031a42635be/opentelemetry_exporter_otlp-1.39.1.tar.gz", hash = "sha256:7cf7470e9fd0060c8a38a23e4f695ac686c06a48ad97f8d4867bc9b420180b9c", size = 6147, upload-time = "2025-12-11T13:32:40.309Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/6c/bdc82a066e6fb1dcf9e8cc8d4e026358fe0f8690700cc6369a6bf9bd17a7/opentelemetry_exporter_otlp-1.39.1-py3-none-any.whl", hash = "sha256:68ae69775291f04f000eb4b698ff16ff685fdebe5cb52871bc4e87938a7b00fe", size = 7019, upload-time = "2025-12-11T13:32:19.387Z" }, +] + +[[package]] +name = "opentelemetry-exporter-otlp-proto-common" +version = "1.39.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-proto" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/9d/22d241b66f7bbde88a3bfa6847a351d2c46b84de23e71222c6aae25c7050/opentelemetry_exporter_otlp_proto_common-1.39.1.tar.gz", hash = "sha256:763370d4737a59741c89a67b50f9e39271639ee4afc999dadfe768541c027464", size = 20409, upload-time = "2025-12-11T13:32:40.885Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/02/ffc3e143d89a27ac21fd557365b98bd0653b98de8a101151d5805b5d4c33/opentelemetry_exporter_otlp_proto_common-1.39.1-py3-none-any.whl", hash = "sha256:08f8a5862d64cc3435105686d0216c1365dc5701f86844a8cd56597d0c764fde", size = 18366, upload-time = "2025-12-11T13:32:20.2Z" }, +] + +[[package]] +name = "opentelemetry-exporter-otlp-proto-grpc" +version = "1.39.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "googleapis-common-protos" }, + { name = "grpcio" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp-proto-common" }, + { name = "opentelemetry-proto" }, + { name = "opentelemetry-sdk" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/53/48/b329fed2c610c2c32c9366d9dc597202c9d1e58e631c137ba15248d8850f/opentelemetry_exporter_otlp_proto_grpc-1.39.1.tar.gz", hash = "sha256:772eb1c9287485d625e4dbe9c879898e5253fea111d9181140f51291b5fec3ad", size = 24650, upload-time = "2025-12-11T13:32:41.429Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/a3/cc9b66575bd6597b98b886a2067eea2693408d2d5f39dad9ab7fc264f5f3/opentelemetry_exporter_otlp_proto_grpc-1.39.1-py3-none-any.whl", hash = "sha256:fa1c136a05c7e9b4c09f739469cbdb927ea20b34088ab1d959a849b5cc589c18", size = 19766, upload-time = "2025-12-11T13:32:21.027Z" }, +] + +[[package]] +name = "opentelemetry-exporter-otlp-proto-http" +version = "1.39.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "googleapis-common-protos" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp-proto-common" }, + { name = "opentelemetry-proto" }, + { name = "opentelemetry-sdk" }, + { name = "requests" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/04/2a08fa9c0214ae38880df01e8bfae12b067ec0793446578575e5080d6545/opentelemetry_exporter_otlp_proto_http-1.39.1.tar.gz", hash = "sha256:31bdab9745c709ce90a49a0624c2bd445d31a28ba34275951a6a362d16a0b9cb", size = 17288, upload-time = "2025-12-11T13:32:42.029Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/f1/b27d3e2e003cd9a3592c43d099d2ed8d0a947c15281bf8463a256db0b46c/opentelemetry_exporter_otlp_proto_http-1.39.1-py3-none-any.whl", hash = "sha256:d9f5207183dd752a412c4cd564ca8875ececba13be6e9c6c370ffb752fd59985", size = 19641, upload-time = "2025-12-11T13:32:22.248Z" }, +] + +[[package]] +name = "opentelemetry-proto" +version = "1.39.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/1d/f25d76d8260c156c40c97c9ed4511ec0f9ce353f8108ca6e7561f82a06b2/opentelemetry_proto-1.39.1.tar.gz", hash = "sha256:6c8e05144fc0d3ed4d22c2289c6b126e03bcd0e6a7da0f16cedd2e1c2772e2c8", size = 46152, upload-time = "2025-12-11T13:32:48.681Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/95/b40c96a7b5203005a0b03d8ce8cd212ff23f1793d5ba289c87a097571b18/opentelemetry_proto-1.39.1-py3-none-any.whl", hash = "sha256:22cdc78efd3b3765d09e68bfbd010d4fc254c9818afd0b6b423387d9dee46007", size = 72535, upload-time = "2025-12-11T13:32:33.866Z" }, +] + +[[package]] +name = "opentelemetry-sdk" +version = "1.39.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "opentelemetry-semantic-conventions" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/fb/c76080c9ba07e1e8235d24cdcc4d125ef7aa3edf23eb4e497c2e50889adc/opentelemetry_sdk-1.39.1.tar.gz", hash = "sha256:cf4d4563caf7bff906c9f7967e2be22d0d6b349b908be0d90fb21c8e9c995cc6", size = 171460, upload-time = "2025-12-11T13:32:49.369Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/98/e91cf858f203d86f4eccdf763dcf01cf03f1dae80c3750f7e635bfa206b6/opentelemetry_sdk-1.39.1-py3-none-any.whl", hash = "sha256:4d5482c478513ecb0a5d938dcc61394e647066e0cc2676bee9f3af3f3f45f01c", size = 132565, upload-time = "2025-12-11T13:32:35.069Z" }, +] + +[[package]] +name = "opentelemetry-semantic-conventions" +version = "0.60b1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/df/553f93ed38bf22f4b999d9be9c185adb558982214f33eae539d3b5cd0858/opentelemetry_semantic_conventions-0.60b1.tar.gz", hash = "sha256:87c228b5a0669b748c76d76df6c364c369c28f1c465e50f661e39737e84bc953", size = 137935, upload-time = "2025-12-11T13:32:50.487Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/5e/5958555e09635d09b75de3c4f8b9cae7335ca545d77392ffe7331534c402/opentelemetry_semantic_conventions-0.60b1-py3-none-any.whl", hash = "sha256:9fa8c8b0c110da289809292b0591220d3a7b53c1526a23021e977d68597893fb", size = 219982, upload-time = "2025-12-11T13:32:36.955Z" }, +] + +[[package]] +name = "packaging" +version = "26.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + +[[package]] +name = "prometheus-client" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/fb/d9aa83ffe43ce1f19e557c0971d04b90561b0cfd50762aafb01968285553/prometheus_client-0.25.0.tar.gz", hash = "sha256:5e373b75c31afb3c86f1a52fa1ad470c9aace18082d39ec0d2f918d11cc9ba28", size = 86035, upload-time = "2026-04-09T19:53:42.359Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/9b/d4b1e644385499c8346fa9b622a3f030dce14cd6ef8a1871c221a17a67e7/prometheus_client-0.25.0-py3-none-any.whl", hash = "sha256:d5aec89e349a6ec230805d0df882f3807f74fd6c1a2fa86864e3c2279059fed1", size = 64154, upload-time = "2026-04-09T19:53:41.324Z" }, +] + +[[package]] +name = "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/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 = "protobuf" +version = "6.33.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" }, + { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" }, + { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" }, + { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" }, + { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" }, + { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" }, + { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pydantic" +version = "2.13.3" +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/d9/e4/40d09941a2cebcb20609b86a559817d5b9291c49dd6f8c87e5feffbe703a/pydantic-2.13.3.tar.gz", hash = "sha256:af09e9d1d09f4e7fe37145c1f577e1d61ceb9a41924bf0094a36506285d0a84d", size = 844068, upload-time = "2026-04-20T14:46:43.632Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/0a/fd7d723f8f8153418fb40cf9c940e82004fce7e987026b08a68a36dd3fe7/pydantic-2.13.3-py3-none-any.whl", hash = "sha256:6db14ac8dfc9a1e57f87ea2c0de670c251240f43cb0c30a5130e9720dc612927", size = 471981, upload-time = "2026-04-20T14:46:41.402Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.46.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/ef/f7abb56c49382a246fd2ce9c799691e3c3e7175ec74b14d99e798bcddb1a/pydantic_core-2.46.3.tar.gz", hash = "sha256:41c178f65b8c29807239d47e6050262eb6bf84eb695e41101e62e38df4a5bc2c", size = 471412, upload-time = "2026-04-20T14:40:56.672Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a2/1ba90a83e85a3f94c796b184f3efde9c72f2830dcda493eea8d59ba78e6d/pydantic_core-2.46.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:ab124d49d0459b2373ecf54118a45c28a1e6d4192a533fbc915e70f556feb8e5", size = 2106740, upload-time = "2026-04-20T14:41:20.932Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f6/99ae893c89a0b9d3daec9f95487aa676709aa83f67643b3f0abaf4ab628a/pydantic_core-2.46.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cca67d52a5c7a16aed2b3999e719c4bcf644074eac304a5d3d62dd70ae7d4b2c", size = 1948293, upload-time = "2026-04-20T14:43:42.115Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b8/2e8e636dc9e3f16c2e16bf0849e24be82c5ee82c603c65fc0326666328fc/pydantic_core-2.46.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c024e08c0ba23e6fd68c771a521e9d6a792f2ebb0fa734296b36394dc30390e", size = 1973222, upload-time = "2026-04-20T14:41:57.841Z" }, + { url = "https://files.pythonhosted.org/packages/34/36/0e730beec4d83c5306f417afbd82ff237d9a21e83c5edf675f31ed84c1fe/pydantic_core-2.46.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6645ce7eec4928e29a1e3b3d5c946621d105d3e79f0c9cddf07c2a9770949287", size = 2053852, upload-time = "2026-04-20T14:40:43.077Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f0/3071131f47e39136a17814576e0fada9168569f7f8c0e6ac4d1ede6a4958/pydantic_core-2.46.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a712c7118e6c5ea96562f7b488435172abb94a3c53c22c9efc1412264a45cbbe", size = 2221134, upload-time = "2026-04-20T14:43:03.349Z" }, + { url = "https://files.pythonhosted.org/packages/2f/a9/a2dc023eec5aa4b02a467874bad32e2446957d2adcab14e107eab502e978/pydantic_core-2.46.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:69a868ef3ff206343579021c40faf3b1edc64b1cc508ff243a28b0a514ccb050", size = 2279785, upload-time = "2026-04-20T14:41:19.285Z" }, + { url = "https://files.pythonhosted.org/packages/0a/44/93f489d16fb63fbd41c670441536541f6e8cfa1e5a69f40bc9c5d30d8c90/pydantic_core-2.46.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc7e8c32db809aa0f6ea1d6869ebc8518a65d5150fdfad8bcae6a49ae32a22e2", size = 2089404, upload-time = "2026-04-20T14:43:10.108Z" }, + { url = "https://files.pythonhosted.org/packages/2a/78/8692e3aa72b2d004f7a5d937f1dfdc8552ba26caf0bec75f342c40f00dec/pydantic_core-2.46.3-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:3481bd1341dc85779ee506bc8e1196a277ace359d89d28588a9468c3ecbe63fa", size = 2114898, upload-time = "2026-04-20T14:44:51.475Z" }, + { url = "https://files.pythonhosted.org/packages/6a/62/e83133f2e7832532060175cebf1f13748f4c7e7e7165cdd1f611f174494b/pydantic_core-2.46.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8690eba565c6d68ffd3a8655525cbdd5246510b44a637ee2c6c03a7ebfe64d3c", size = 2157856, upload-time = "2026-04-20T14:43:46.64Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ec/6a500e3ad7718ee50583fae79c8651f5d37e3abce1fa9ae177ae65842c53/pydantic_core-2.46.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4de88889d7e88d50d40ee5b39d5dac0bcaef9ba91f7e536ac064e6b2834ecccf", size = 2180168, upload-time = "2026-04-20T14:42:00.302Z" }, + { url = "https://files.pythonhosted.org/packages/d8/53/8267811054b1aa7fc1dc7ded93812372ef79a839f5e23558136a6afbfde1/pydantic_core-2.46.3-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:e480080975c1ef7f780b8f99ed72337e7cc5efea2e518a20a692e8e7b278eb8b", size = 2322885, upload-time = "2026-04-20T14:41:05.253Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c1/1c0acdb3aa0856ddc4ecc55214578f896f2de16f400cf51627eb3c26c1c4/pydantic_core-2.46.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:de3a5c376f8cd94da9a1b8fd3dd1c16c7a7b216ed31dc8ce9fd7a22bf13b836e", size = 2360328, upload-time = "2026-04-20T14:41:43.991Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d0/ef39cd0f4a926814f360e71c1adeab48ad214d9727e4deb48eedfb5bce1a/pydantic_core-2.46.3-cp311-cp311-win32.whl", hash = "sha256:fc331a5314ffddd5385b9ee9d0d2fee0b13c27e0e02dad71b1ae5d6561f51eeb", size = 1979464, upload-time = "2026-04-20T14:43:12.215Z" }, + { url = "https://files.pythonhosted.org/packages/18/9c/f41951b0d858e343f1cf09398b2a7b3014013799744f2c4a8ad6a3eec4f2/pydantic_core-2.46.3-cp311-cp311-win_amd64.whl", hash = "sha256:b5b9c6cf08a8a5e502698f5e153056d12c34b8fb30317e0c5fd06f45162a6346", size = 2070837, upload-time = "2026-04-20T14:41:47.707Z" }, + { url = "https://files.pythonhosted.org/packages/9f/1e/264a17cd582f6ed50950d4d03dd5fefd84e570e238afe1cb3e25cf238769/pydantic_core-2.46.3-cp311-cp311-win_arm64.whl", hash = "sha256:5dfd51cf457482f04ec49491811a2b8fd5b843b64b11eecd2d7a1ee596ea78a6", size = 2053647, upload-time = "2026-04-20T14:42:27.535Z" }, + { url = "https://files.pythonhosted.org/packages/4b/cb/5b47425556ecc1f3fe18ed2a0083188aa46e1dd812b06e406475b3a5d536/pydantic_core-2.46.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b11b59b3eee90a80a36701ddb4576d9ae31f93f05cb9e277ceaa09e6bf074a67", size = 2101946, upload-time = "2026-04-20T14:40:52.581Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4f/2fb62c2267cae99b815bbf4a7b9283812c88ca3153ef29f7707200f1d4e5/pydantic_core-2.46.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:af8653713055ea18a3abc1537fe2ebc42f5b0bbb768d1eb79fd74eb47c0ac089", size = 1951612, upload-time = "2026-04-20T14:42:42.996Z" }, + { url = "https://files.pythonhosted.org/packages/50/6e/b7348fd30d6556d132cddd5bd79f37f96f2601fe0608afac4f5fb01ec0b3/pydantic_core-2.46.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:75a519dab6d63c514f3a81053e5266c549679e4aa88f6ec57f2b7b854aceb1b0", size = 1977027, upload-time = "2026-04-20T14:42:02.001Z" }, + { url = "https://files.pythonhosted.org/packages/82/11/31d60ee2b45540d3fb0b29302a393dbc01cd771c473f5b5147bcd353e593/pydantic_core-2.46.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6cd87cb1575b1ad05ba98894c5b5c96411ef678fa2f6ed2576607095b8d9789", size = 2063008, upload-time = "2026-04-20T14:44:17.952Z" }, + { url = "https://files.pythonhosted.org/packages/8a/db/3a9d1957181b59258f44a2300ab0f0be9d1e12d662a4f57bb31250455c52/pydantic_core-2.46.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f80a55484b8d843c8ada81ebf70a682f3f00a3d40e378c06cf17ecb44d280d7d", size = 2233082, upload-time = "2026-04-20T14:40:57.934Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e1/3277c38792aeb5cfb18c2f0c5785a221d9ff4e149abbe1184d53d5f72273/pydantic_core-2.46.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3861f1731b90c50a3266316b9044f5c9b405eecb8e299b0a7120596334e4fe9c", size = 2304615, upload-time = "2026-04-20T14:42:12.584Z" }, + { url = "https://files.pythonhosted.org/packages/5e/d5/e3d9717c9eba10855325650afd2a9cba8e607321697f18953af9d562da2f/pydantic_core-2.46.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb528e295ed31570ac3dcc9bfdd6e0150bc11ce6168ac87a8082055cf1a67395", size = 2094380, upload-time = "2026-04-20T14:43:05.522Z" }, + { url = "https://files.pythonhosted.org/packages/a1/20/abac35dedcbfd66c6f0b03e4e3564511771d6c9b7ede10a362d03e110d9b/pydantic_core-2.46.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:367508faa4973b992b271ba1494acaab36eb7e8739d1e47be5035fb1ea225396", size = 2135429, upload-time = "2026-04-20T14:41:55.549Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a5/41bfd1df69afad71b5cf0535055bccc73022715ad362edbc124bc1e021d7/pydantic_core-2.46.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5ad3c826fe523e4becf4fe39baa44286cff85ef137c729a2c5e269afbfd0905d", size = 2174582, upload-time = "2026-04-20T14:41:45.96Z" }, + { url = "https://files.pythonhosted.org/packages/79/65/38d86ea056b29b2b10734eb23329b7a7672ca604df4f2b6e9c02d4ee22fe/pydantic_core-2.46.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ec638c5d194ef8af27db69f16c954a09797c0dc25015ad6123eb2c73a4d271ca", size = 2187533, upload-time = "2026-04-20T14:40:55.367Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/a1129141678a2026badc539ad1dee0a71d06f54c2f06a4bd68c030ac781b/pydantic_core-2.46.3-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:28ed528c45446062ee66edb1d33df5d88828ae167de76e773a3c7f64bd14e976", size = 2332985, upload-time = "2026-04-20T14:44:13.05Z" }, + { url = "https://files.pythonhosted.org/packages/d7/60/cb26f4077719f709e54819f4e8e1d43f4091f94e285eb6bd21e1190a7b7c/pydantic_core-2.46.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aed19d0c783886d5bd86d80ae5030006b45e28464218747dcf83dabfdd092c7b", size = 2373670, upload-time = "2026-04-20T14:41:53.421Z" }, + { url = "https://files.pythonhosted.org/packages/6b/7e/c3f21882bdf1d8d086876f81b5e296206c69c6082551d776895de7801fa0/pydantic_core-2.46.3-cp312-cp312-win32.whl", hash = "sha256:06d5d8820cbbdb4147578c1fe7ffcd5b83f34508cb9f9ab76e807be7db6ff0a4", size = 1966722, upload-time = "2026-04-20T14:44:30.588Z" }, + { url = "https://files.pythonhosted.org/packages/57/be/6b5e757b859013ebfbd7adba02f23b428f37c86dcbf78b5bb0b4ffd36e99/pydantic_core-2.46.3-cp312-cp312-win_amd64.whl", hash = "sha256:c3212fda0ee959c1dd04c60b601ec31097aaa893573a3a1abd0a47bcac2968c1", size = 2072970, upload-time = "2026-04-20T14:42:54.248Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f8/a989b21cc75e9a32d24192ef700eea606521221a89faa40c919ce884f2b1/pydantic_core-2.46.3-cp312-cp312-win_arm64.whl", hash = "sha256:f1f8338dd7a7f31761f1f1a3c47503a9a3b34eea3c8b01fa6ee96408affb5e72", size = 2035963, upload-time = "2026-04-20T14:44:20.4Z" }, + { url = "https://files.pythonhosted.org/packages/9b/3c/9b5e8eb9821936d065439c3b0fb1490ffa64163bfe7e1595985a47896073/pydantic_core-2.46.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:12bc98de041458b80c86c56b24df1d23832f3e166cbaff011f25d187f5c62c37", size = 2102109, upload-time = "2026-04-20T14:41:24.219Z" }, + { url = "https://files.pythonhosted.org/packages/91/97/1c41d1f5a19f241d8069f1e249853bcce378cdb76eec8ab636d7bc426280/pydantic_core-2.46.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:85348b8f89d2c3508b65b16c3c33a4da22b8215138d8b996912bb1532868885f", size = 1951820, upload-time = "2026-04-20T14:42:14.236Z" }, + { url = "https://files.pythonhosted.org/packages/30/b4/d03a7ae14571bc2b6b3c7b122441154720619afe9a336fa3a95434df5e2f/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1105677a6df914b1fb71a81b96c8cce7726857e1717d86001f29be06a25ee6f8", size = 1977785, upload-time = "2026-04-20T14:42:31.648Z" }, + { url = "https://files.pythonhosted.org/packages/ae/0c/4086f808834b59e3c8f1aa26df8f4b6d998cdcf354a143d18ef41529d1fe/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:87082cd65669a33adeba5470769e9704c7cf026cc30afb9cc77fd865578ebaad", size = 2062761, upload-time = "2026-04-20T14:40:37.093Z" }, + { url = "https://files.pythonhosted.org/packages/fa/71/a649be5a5064c2df0db06e0a512c2281134ed2fcc981f52a657936a7527c/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:60e5f66e12c4f5212d08522963380eaaeac5ebd795826cfd19b2dfb0c7a52b9c", size = 2232989, upload-time = "2026-04-20T14:42:59.254Z" }, + { url = "https://files.pythonhosted.org/packages/a2/84/7756e75763e810b3a710f4724441d1ecc5883b94aacb07ca71c5fb5cfb69/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b6cdf19bf84128d5e7c37e8a73a0c5c10d51103a650ac585d42dd6ae233f2b7f", size = 2303975, upload-time = "2026-04-20T14:41:32.287Z" }, + { url = "https://files.pythonhosted.org/packages/6c/35/68a762e0c1e31f35fa0dac733cbd9f5b118042853698de9509c8e5bf128b/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:031bb17f4885a43773c8c763089499f242aee2ea85cf17154168775dccdecf35", size = 2095325, upload-time = "2026-04-20T14:42:47.685Z" }, + { url = "https://files.pythonhosted.org/packages/77/bf/1bf8c9a8e91836c926eae5e3e51dce009bf495a60ca56060689d3df3f340/pydantic_core-2.46.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:bcf2a8b2982a6673693eae7348ef3d8cf3979c1d63b54fca7c397a635cc68687", size = 2133368, upload-time = "2026-04-20T14:41:22.766Z" }, + { url = "https://files.pythonhosted.org/packages/e5/50/87d818d6bab915984995157ceb2380f5aac4e563dddbed6b56f0ed057aba/pydantic_core-2.46.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28e8cf2f52d72ced402a137145923a762cbb5081e48b34312f7a0c8f55928ec3", size = 2173908, upload-time = "2026-04-20T14:42:52.044Z" }, + { url = "https://files.pythonhosted.org/packages/91/88/a311fb306d0bd6185db41fa14ae888fb81d0baf648a761ae760d30819d33/pydantic_core-2.46.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:17eaface65d9fc5abb940003020309c1bf7a211f5f608d7870297c367e6f9022", size = 2186422, upload-time = "2026-04-20T14:43:29.55Z" }, + { url = "https://files.pythonhosted.org/packages/8f/79/28fd0d81508525ab2054fef7c77a638c8b5b0afcbbaeee493cf7c3fef7e1/pydantic_core-2.46.3-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:93fd339f23408a07e98950a89644f92c54d8729719a40b30c0a30bb9ebc55d23", size = 2332709, upload-time = "2026-04-20T14:42:16.134Z" }, + { url = "https://files.pythonhosted.org/packages/b3/21/795bf5fe5c0f379308b8ef19c50dedab2e7711dbc8d0c2acf08f1c7daa05/pydantic_core-2.46.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:23cbdb3aaa74dfe0837975dbf69b469753bbde8eacace524519ffdb6b6e89eb7", size = 2372428, upload-time = "2026-04-20T14:41:10.974Z" }, + { url = "https://files.pythonhosted.org/packages/45/b3/ed14c659cbe7605e3ef063077680a64680aec81eb1a04763a05190d49b7f/pydantic_core-2.46.3-cp313-cp313-win32.whl", hash = "sha256:610eda2e3838f401105e6326ca304f5da1e15393ae25dacae5c5c63f2c275b13", size = 1965601, upload-time = "2026-04-20T14:41:42.128Z" }, + { url = "https://files.pythonhosted.org/packages/ef/bb/adb70d9a762ddd002d723fbf1bd492244d37da41e3af7b74ad212609027e/pydantic_core-2.46.3-cp313-cp313-win_amd64.whl", hash = "sha256:68cc7866ed863db34351294187f9b729964c371ba33e31c26f478471c52e1ed0", size = 2071517, upload-time = "2026-04-20T14:43:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/52/eb/66faefabebfe68bd7788339c9c9127231e680b11906368c67ce112fdb47f/pydantic_core-2.46.3-cp313-cp313-win_arm64.whl", hash = "sha256:f64b5537ac62b231572879cd08ec05600308636a5d63bcbdb15063a466977bec", size = 2035802, upload-time = "2026-04-20T14:43:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/7f/db/a7bcb4940183fda36022cd18ba8dd12f2dff40740ec7b58ce7457befa416/pydantic_core-2.46.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:afa3aa644f74e290cdede48a7b0bee37d1c35e71b05105f6b340d484af536d9b", size = 2097614, upload-time = "2026-04-20T14:44:38.374Z" }, + { url = "https://files.pythonhosted.org/packages/24/35/e4066358a22e3e99519db370494c7528f5a2aa1367370e80e27e20283543/pydantic_core-2.46.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ced3310e51aa425f7f77da8bbbb5212616655bedbe82c70944320bc1dbe5e018", size = 1951896, upload-time = "2026-04-20T14:40:53.996Z" }, + { url = "https://files.pythonhosted.org/packages/87/92/37cf4049d1636996e4b888c05a501f40a43ff218983a551d57f9d5e14f0d/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e29908922ce9da1a30b4da490bd1d3d82c01dcfdf864d2a74aacee674d0bfa34", size = 1979314, upload-time = "2026-04-20T14:41:49.446Z" }, + { url = "https://files.pythonhosted.org/packages/d8/36/9ff4d676dfbdfb2d591cf43f3d90ded01e15b1404fd101180ed2d62a2fd3/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0c9ff69140423eea8ed2d5477df3ba037f671f5e897d206d921bc9fdc39613e7", size = 2056133, upload-time = "2026-04-20T14:42:23.574Z" }, + { url = "https://files.pythonhosted.org/packages/bc/f0/405b442a4d7ba855b06eec8b2bf9c617d43b8432d099dfdc7bf999293495/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b675ab0a0d5b1c8fdb81195dc5bcefea3f3c240871cdd7ff9a2de8aa50772eb2", size = 2228726, upload-time = "2026-04-20T14:44:22.816Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f8/65cd92dd5a0bd89ba277a98ecbfaf6fc36bbd3300973c7a4b826d6ab1391/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0087084960f209a9a4af50ecd1fb063d9ad3658c07bb81a7a53f452dacbfb2ba", size = 2301214, upload-time = "2026-04-20T14:44:48.792Z" }, + { url = "https://files.pythonhosted.org/packages/fd/86/ef96a4c6e79e7a2d0410826a68fbc0eccc0fd44aa733be199d5fcac3bb87/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed42e6cc8e1b0e2b9b96e2276bad70ae625d10d6d524aed0c93de974ae029f9f", size = 2099927, upload-time = "2026-04-20T14:41:40.196Z" }, + { url = "https://files.pythonhosted.org/packages/6d/53/269caf30e0096e0a8a8f929d1982a27b3879872cca2d917d17c2f9fdf4fe/pydantic_core-2.46.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:f1771ce258afb3e4201e67d154edbbae712a76a6081079fe247c2f53c6322c22", size = 2128789, upload-time = "2026-04-20T14:41:15.868Z" }, + { url = "https://files.pythonhosted.org/packages/00/b0/1a6d9b6a587e118482910c244a1c5acf4d192604174132efd12bf0ac486f/pydantic_core-2.46.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a7610b6a5242a6c736d8ad47fd5fff87fcfe8f833b281b1c409c3d6835d9227f", size = 2173815, upload-time = "2026-04-20T14:44:25.152Z" }, + { url = "https://files.pythonhosted.org/packages/87/56/e7e00d4041a7e62b5a40815590114db3b535bf3ca0bf4dca9f16cef25246/pydantic_core-2.46.3-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:ff5e7783bcc5476e1db448bf268f11cb257b1c276d3e89f00b5727be86dd0127", size = 2181608, upload-time = "2026-04-20T14:41:28.933Z" }, + { url = "https://files.pythonhosted.org/packages/e8/22/4bd23c3d41f7c185d60808a1de83c76cf5aeabf792f6c636a55c3b1ec7f9/pydantic_core-2.46.3-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:9d2e32edcc143bc01e95300671915d9ca052d4f745aa0a49c48d4803f8a85f2c", size = 2326968, upload-time = "2026-04-20T14:42:03.962Z" }, + { url = "https://files.pythonhosted.org/packages/24/ac/66cd45129e3915e5ade3b292cb3bc7fd537f58f8f8dbdaba6170f7cabb74/pydantic_core-2.46.3-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6e42d83d1c6b87fa56b521479cff237e626a292f3b31b6345c15a99121b454c1", size = 2369842, upload-time = "2026-04-20T14:41:35.52Z" }, + { url = "https://files.pythonhosted.org/packages/a2/51/dd4248abb84113615473aa20d5545b7c4cd73c8644003b5259686f93996c/pydantic_core-2.46.3-cp314-cp314-win32.whl", hash = "sha256:07bc6d2a28c3adb4f7c6ae46aa4f2d2929af127f587ed44057af50bf1ce0f505", size = 1959661, upload-time = "2026-04-20T14:41:00.042Z" }, + { url = "https://files.pythonhosted.org/packages/20/eb/59980e5f1ae54a3b86372bd9f0fa373ea2d402e8cdcd3459334430f91e91/pydantic_core-2.46.3-cp314-cp314-win_amd64.whl", hash = "sha256:8940562319bc621da30714617e6a7eaa6b98c84e8c685bcdc02d7ed5e7c7c44e", size = 2071686, upload-time = "2026-04-20T14:43:16.471Z" }, + { url = "https://files.pythonhosted.org/packages/8c/db/1cf77e5247047dfee34bc01fa9bca134854f528c8eb053e144298893d370/pydantic_core-2.46.3-cp314-cp314-win_arm64.whl", hash = "sha256:5dcbbcf4d22210ced8f837c96db941bdb078f419543472aca5d9a0bb7cddc7df", size = 2026907, upload-time = "2026-04-20T14:43:31.732Z" }, + { url = "https://files.pythonhosted.org/packages/57/c0/b3df9f6a543276eadba0a48487b082ca1f201745329d97dbfa287034a230/pydantic_core-2.46.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d0fe3dce1e836e418f912c1ad91c73357d03e556a4d286f441bf34fed2dbeecf", size = 2095047, upload-time = "2026-04-20T14:42:37.982Z" }, + { url = "https://files.pythonhosted.org/packages/66/57/886a938073b97556c168fd99e1a7305bb363cd30a6d2c76086bf0587b32a/pydantic_core-2.46.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9ce92e58abc722dac1bf835a6798a60b294e48eb0e625ec9fd994b932ac5feee", size = 1934329, upload-time = "2026-04-20T14:43:49.655Z" }, + { url = "https://files.pythonhosted.org/packages/0b/7c/b42eaa5c34b13b07ecb51da21761297a9b8eb43044c864a035999998f328/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a03e6467f0f5ab796a486146d1b887b2dc5e5f9b3288898c1b1c3ad974e53e4a", size = 1974847, upload-time = "2026-04-20T14:42:10.737Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9b/92b42db6543e7de4f99ae977101a2967b63122d4b6cf7773812da2d7d5b5/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2798b6ba041b9d70acfb9071a2ea13c8456dd1e6a5555798e41ba7b0790e329c", size = 2041742, upload-time = "2026-04-20T14:40:44.262Z" }, + { url = "https://files.pythonhosted.org/packages/0f/19/46fbe1efabb5aa2834b43b9454e70f9a83ad9c338c1291e48bdc4fecf167/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9be3e221bdc6d69abf294dcf7aff6af19c31a5cdcc8f0aa3b14be29df4bd03b1", size = 2236235, upload-time = "2026-04-20T14:41:27.307Z" }, + { url = "https://files.pythonhosted.org/packages/77/da/b3f95bc009ad60ec53120f5d16c6faa8cabdbe8a20d83849a1f2b8728148/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f13936129ce841f2a5ddf6f126fea3c43cd128807b5a59588c37cf10178c2e64", size = 2282633, upload-time = "2026-04-20T14:44:33.271Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6e/401336117722e28f32fb8220df676769d28ebdf08f2f4469646d404c43a3/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28b5f2ef03416facccb1c6ef744c69793175fd27e44ef15669201601cf423acb", size = 2109679, upload-time = "2026-04-20T14:44:41.065Z" }, + { url = "https://files.pythonhosted.org/packages/fc/53/b289f9bc8756a32fe718c46f55afaeaf8d489ee18d1a1e7be1db73f42cc4/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:830d1247d77ad23852314f069e9d7ddafeec5f684baf9d7e7065ed46a049c4e6", size = 2108342, upload-time = "2026-04-20T14:42:50.144Z" }, + { url = "https://files.pythonhosted.org/packages/10/5b/8292fc7c1f9111f1b2b7c1b0dcf1179edcd014fc3ea4517499f50b829d71/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0793c90c1a3c74966e7975eaef3ed30ebdff3260a0f815a62a22adc17e4c01c", size = 2157208, upload-time = "2026-04-20T14:42:08.133Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9e/f80044e9ec07580f057a89fc131f78dda7a58751ddf52bbe05eaf31db50f/pydantic_core-2.46.3-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:d2d0aead851b66f5245ec0c4fb2612ef457f8bbafefdf65a2bf9d6bac6140f47", size = 2167237, upload-time = "2026-04-20T14:42:25.412Z" }, + { url = "https://files.pythonhosted.org/packages/f8/84/6781a1b037f3b96be9227edbd1101f6d3946746056231bf4ac48cdff1a8d/pydantic_core-2.46.3-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:2f40e4246676beb31c5ce77c38a55ca4e465c6b38d11ea1bd935420568e0b1ab", size = 2312540, upload-time = "2026-04-20T14:40:40.313Z" }, + { url = "https://files.pythonhosted.org/packages/3e/db/19c0839feeb728e7df03255581f198dfdf1c2aeb1e174a8420b63c5252e5/pydantic_core-2.46.3-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:cf489cf8986c543939aeee17a09c04d6ffb43bfef8ca16fcbcc5cfdcbed24dba", size = 2369556, upload-time = "2026-04-20T14:41:09.427Z" }, + { url = "https://files.pythonhosted.org/packages/e0/15/3228774cb7cd45f5f721ddf1b2242747f4eb834d0c491f0c02d606f09fed/pydantic_core-2.46.3-cp314-cp314t-win32.whl", hash = "sha256:ffe0883b56cfc05798bf994164d2b2ff03efe2d22022a2bb080f3b626176dd56", size = 1949756, upload-time = "2026-04-20T14:41:25.717Z" }, + { url = "https://files.pythonhosted.org/packages/b8/2a/c79cf53fd91e5a87e30d481809f52f9a60dd221e39de66455cf04deaad37/pydantic_core-2.46.3-cp314-cp314t-win_amd64.whl", hash = "sha256:706d9d0ce9cf4593d07270d8e9f53b161f90c57d315aeec4fb4fd7a8b10240d8", size = 2051305, upload-time = "2026-04-20T14:43:18.627Z" }, + { url = "https://files.pythonhosted.org/packages/0b/db/d8182a7f1d9343a032265aae186eb063fe26ca4c40f256b21e8da4498e89/pydantic_core-2.46.3-cp314-cp314t-win_arm64.whl", hash = "sha256:77706aeb41df6a76568434701e0917da10692da28cb69d5fb6919ce5fdb07374", size = 2026310, upload-time = "2026-04-20T14:41:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/66/7f/03dbad45cd3aa9083fbc93c210ae8b005af67e4136a14186950a747c6874/pydantic_core-2.46.3-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:9715525891ed524a0a1eb6d053c74d4d4ad5017677fb00af0b7c2644a31bae46", size = 2105683, upload-time = "2026-04-20T14:42:19.779Z" }, + { url = "https://files.pythonhosted.org/packages/26/22/4dc186ac8ea6b257e9855031f51b62a9637beac4d68ac06bee02f046f836/pydantic_core-2.46.3-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:9d2f400712a99a013aff420ef1eb9be077f8189a36c1e3ef87660b4e1088a874", size = 1940052, upload-time = "2026-04-20T14:43:59.274Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ca/d376391a5aff1f2e8188960d7873543608130a870961c2b6b5236627c116/pydantic_core-2.46.3-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd2aab0e2e9dc2daf36bd2686c982535d5e7b1d930a1344a7bb6e82baab42a76", size = 1988172, upload-time = "2026-04-20T14:41:17.469Z" }, + { url = "https://files.pythonhosted.org/packages/0e/6b/523b9f85c23788755d6ab949329de692a2e3a584bc6beb67fef5e035aa9d/pydantic_core-2.46.3-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e9d76736da5f362fabfeea6a69b13b7f2be405c6d6966f06b2f6bfff7e64531", size = 2128596, upload-time = "2026-04-20T14:40:41.707Z" }, + { url = "https://files.pythonhosted.org/packages/34/42/f426db557e8ab2791bc7562052299944a118655496fbff99914e564c0a94/pydantic_core-2.46.3-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:b12dd51f1187c2eb489af8e20f880362db98e954b54ab792fa5d92e8bcc6b803", size = 2091877, upload-time = "2026-04-20T14:43:27.091Z" }, + { url = "https://files.pythonhosted.org/packages/5c/4f/86a832a9d14df58e663bfdf4627dc00d3317c2bd583c4fb23390b0f04b8e/pydantic_core-2.46.3-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f00a0961b125f1a47af7bcc17f00782e12f4cd056f83416006b30111d941dfa3", size = 1932428, upload-time = "2026-04-20T14:40:45.781Z" }, + { url = "https://files.pythonhosted.org/packages/11/1a/fe857968954d93fb78e0d4b6df5c988c74c4aaa67181c60be7cfe327c0ca/pydantic_core-2.46.3-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57697d7c056aca4bbb680200f96563e841a6386ac1129370a0102592f4dddff5", size = 1997550, upload-time = "2026-04-20T14:44:02.425Z" }, + { url = "https://files.pythonhosted.org/packages/17/eb/9d89ad2d9b0ba8cd65393d434471621b98912abb10fbe1df08e480ba57b5/pydantic_core-2.46.3-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd35aa21299def8db7ef4fe5c4ff862941a9a158ca7b63d61e66fe67d30416b4", size = 2137657, upload-time = "2026-04-20T14:42:45.149Z" }, + { url = "https://files.pythonhosted.org/packages/1f/da/99d40830684f81dec901cac521b5b91c095394cc1084b9433393cde1c2df/pydantic_core-2.46.3-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:13afdd885f3d71280cf286b13b310ee0f7ccfefd1dbbb661514a474b726e2f25", size = 2107973, upload-time = "2026-04-20T14:42:06.175Z" }, + { url = "https://files.pythonhosted.org/packages/99/a5/87024121818d75bbb2a98ddbaf638e40e7a18b5e0f5492c9ca4b1b316107/pydantic_core-2.46.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f91c0aff3e3ee0928edd1232c57f643a7a003e6edf1860bc3afcdc749cb513f3", size = 1947191, upload-time = "2026-04-20T14:43:14.319Z" }, + { url = "https://files.pythonhosted.org/packages/60/62/0c1acfe10945b83a6a59d19fbaa92f48825381509e5701b855c08f13db76/pydantic_core-2.46.3-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6529d1d128321a58d30afcc97b49e98836542f68dd41b33c2e972bb9e5290536", size = 2123791, upload-time = "2026-04-20T14:43:22.766Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/3b2393b4c8f44285561dc30b00cf307a56a2eff7c483a824db3b8221ca51/pydantic_core-2.46.3-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:975c267cff4f7e7272eacbe50f6cc03ca9a3da4c4fbd66fffd89c94c1e311aa1", size = 2153197, upload-time = "2026-04-20T14:44:27.932Z" }, + { url = "https://files.pythonhosted.org/packages/ba/75/5af02fb35505051eee727c061f2881c555ab4f8ddb2d42da715a42c9731b/pydantic_core-2.46.3-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:2b8e4f2bbdf71415c544b4b1138b8060db7b6611bc927e8064c769f64bed651c", size = 2181073, upload-time = "2026-04-20T14:43:20.729Z" }, + { url = "https://files.pythonhosted.org/packages/10/92/7e0e1bd9ca3c68305db037560ca2876f89b2647deb2f8b6319005de37505/pydantic_core-2.46.3-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:e61ea8e9fff9606d09178f577ff8ccdd7206ff73d6552bcec18e1033c4254b85", size = 2315886, upload-time = "2026-04-20T14:44:04.826Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d8/101655f27eaf3e44558ead736b2795d12500598beed4683f279396fa186e/pydantic_core-2.46.3-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b504bda01bafc69b6d3c7a0c7f039dcf60f47fab70e06fe23f57b5c75bdc82b8", size = 2360528, upload-time = "2026-04-20T14:40:47.431Z" }, + { url = "https://files.pythonhosted.org/packages/07/0f/1c34a74c8d07136f0d729ffe5e1fdab04fbdaa7684f61a92f92511a84a15/pydantic_core-2.46.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b00b76f7142fc60c762ce579bd29c8fa44aaa56592dd3c54fab3928d0d4ca6ff", size = 2184144, upload-time = "2026-04-20T14:42:57Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pyjwt" +version = "2.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" }, +] + +[[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 = "requests" +version = "2.33.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[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 = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "sounddevice" +version = "0.5.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/f9/2592608737553638fca98e21e54bfec40bf577bb98a61b2770c912aab25e/sounddevice-0.5.5.tar.gz", hash = "sha256:22487b65198cb5bf2208755105b524f78ad173e5ab6b445bdab1c989f6698df3", size = 143191, upload-time = "2026-01-23T18:36:43.529Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/0a/478e441fd049002cf308520c0d62dd8333e7c6cc8d997f0dda07b9fbcc46/sounddevice-0.5.5-py3-none-any.whl", hash = "sha256:30ff99f6c107f49d25ad16a45cacd8d91c25a1bcdd3e81a206b921a3a6405b1f", size = 32807, upload-time = "2026-01-23T18:36:35.649Z" }, + { url = "https://files.pythonhosted.org/packages/56/f9/c037c35f6d0b6bc3bc7bfb314f1d6f1f9a341328ef47cd63fc4f850a7b27/sounddevice-0.5.5-py3-none-macosx_10_6_x86_64.macosx_10_6_universal2.whl", hash = "sha256:05eb9fd6c54c38d67741441c19164c0dae8ce80453af2d8c4ad2e7823d15b722", size = 108557, upload-time = "2026-01-23T18:36:37.41Z" }, + { url = "https://files.pythonhosted.org/packages/88/a1/d19dd9889cd4bce2e233c4fac007cd8daaf5b9fe6e6a5d432cf17be0b807/sounddevice-0.5.5-py3-none-win32.whl", hash = "sha256:1234cc9b4c9df97b6cbe748146ae0ec64dd7d6e44739e8e42eaa5b595313a103", size = 317765, upload-time = "2026-01-23T18:36:39.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/0e/002ed7c4c1c2ab69031f78989d3b789fee3a7fba9e586eb2b81688bf4961/sounddevice-0.5.5-py3-none-win_amd64.whl", hash = "sha256:cfc6b2c49fb7f555591c78cb8ecf48d6a637fd5b6e1db5fec6ed9365d64b3519", size = 365324, upload-time = "2026-01-23T18:36:40.496Z" }, + { url = "https://files.pythonhosted.org/packages/4e/39/a61d4b83a7746b70d23d9173be688c0c6bfc7173772344b7442c2c155497/sounddevice-0.5.5-py3-none-win_arm64.whl", hash = "sha256:3861901ddd8230d2e0e8ae62ac320cdd4c688d81df89da036dcb812f757bb3e6", size = 317115, upload-time = "2026-01-23T18:36:42.235Z" }, +] + +[[package]] +name = "tqdm" +version = "4.67.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" }, +] + +[[package]] +name = "typer" +version = "0.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/51/9aed62104cea109b820bbd6c14245af756112017d309da813ef107d42e7e/typer-0.25.1.tar.gz", hash = "sha256:9616eb8853a09ffeabab1698952f33c6f29ffdbceb4eaeecf571880e8d7664cc", size = 122276, upload-time = "2026-04-30T19:32:16.964Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/f9/2b3ff4e56e5fa7debfaf9eb135d0da96f3e9a1d5b27222223c7296336e5f/typer-0.25.1-py3-none-any.whl", hash = "sha256:75caa44ed46a03fb2dab8808753ffacdbfea88495e74c85a28c5eefcf5f39c89", size = 58409, upload-time = "2026-04-30T19:32:18.271Z" }, +] + +[[package]] +name = "types-protobuf" +version = "7.34.1.20260408" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/b1/4521e68c2cc17703d80eb42796751345376dd4c706f84007ef5e7c707774/types_protobuf-7.34.1.20260408.tar.gz", hash = "sha256:e2c0a0430e08c75b52671a6f0035abfdcc791aad12af16274282de1b721758ab", size = 68835, upload-time = "2026-04-08T04:26:43.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/b5/0bc9874d89c58fb0ce851e150055ce732d254dbb10b06becbc7635d0d635/types_protobuf-7.34.1.20260408-py3-none-any.whl", hash = "sha256:ebbcd4e27b145aef6a59bc0cb6c013b3528151c1ba5e7f7337aeee355d276a5e", size = 86012, upload-time = "2026-04-08T04:26:42.566Z" }, +] + +[[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 = "wakeword-agent-dispatch-example" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "livekit" }, + { name = "livekit-agents", extra = ["xai"] }, + { name = "livekit-api" }, + { name = "livekit-protocol" }, + { name = "livekit-wakeword" }, + { name = "python-dotenv" }, + { name = "sounddevice" }, +] + +[package.metadata] +requires-dist = [ + { name = "livekit", editable = "../../livekit-rtc" }, + { name = "livekit-agents", extras = ["xai"], specifier = ">=1.5.0" }, + { name = "livekit-api", editable = "../../livekit-api" }, + { name = "livekit-protocol", editable = "../../livekit-protocol" }, + { name = "livekit-wakeword", specifier = ">=0.1.1" }, + { name = "python-dotenv", specifier = ">=1.0.0" }, + { name = "sounddevice", specifier = ">=0.4.6" }, +] + +[[package]] +name = "watchfiles" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/f8/2c5f479fb531ce2f0564eda479faecf253d886b1ab3630a39b7bf7362d46/watchfiles-1.1.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f57b396167a2565a4e8b5e56a5a1c537571733992b226f4f1197d79e94cf0ae5", size = 406529, upload-time = "2025-10-14T15:04:32.899Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cd/f515660b1f32f65df671ddf6f85bfaca621aee177712874dc30a97397977/watchfiles-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:421e29339983e1bebc281fab40d812742268ad057db4aee8c4d2bce0af43b741", size = 394384, upload-time = "2025-10-14T15:04:33.761Z" }, + { url = "https://files.pythonhosted.org/packages/7b/c3/28b7dc99733eab43fca2d10f55c86e03bd6ab11ca31b802abac26b23d161/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e43d39a741e972bab5d8100b5cdacf69db64e34eb19b6e9af162bccf63c5cc6", size = 448789, upload-time = "2025-10-14T15:04:34.679Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" }, + { url = "https://files.pythonhosted.org/packages/f4/c3/3c9a55f255aa57b91579ae9e98c88704955fa9dac3e5614fb378291155df/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2cd9e04277e756a2e2d2543d65d1e2166d6fd4c9b183f8808634fda23f17b14", size = 488722, upload-time = "2025-10-14T15:04:37.091Z" }, + { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" }, + { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" }, + { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" }, + { url = "https://files.pythonhosted.org/packages/b0/c3/d5932fd62bde1a30c36e10c409dc5d54506726f08cb3e1d8d0ba5e2bc8db/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fac835b4ab3c6487b5dbad78c4b3724e26bcc468e886f8ba8cc4306f68f6701", size = 629432, upload-time = "2025-10-14T15:04:41.789Z" }, + { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" }, + { url = "https://files.pythonhosted.org/packages/46/ef/f2ecb9a0f342b4bfad13a2787155c6ee7ce792140eac63a34676a2feeef2/watchfiles-1.1.1-cp311-cp311-win32.whl", hash = "sha256:de6da501c883f58ad50db3a32ad397b09ad29865b5f26f64c24d3e3281685849", size = 271473, upload-time = "2025-10-14T15:04:43.624Z" }, + { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" }, + { url = "https://files.pythonhosted.org/packages/57/c9/a30f897351f95bbbfb6abcadafbaca711ce1162f4db95fc908c98a9165f3/watchfiles-1.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:57ca5281a8b5e27593cb7d82c2ac927ad88a96ed406aa446f6344e4328208e9e", size = 277210, upload-time = "2025-10-14T15:04:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" }, + { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" }, + { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" }, + { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" }, + { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" }, + { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" }, + { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" }, + { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" }, + { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" }, + { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" }, + { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" }, + { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" }, + { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" }, + { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" }, + { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" }, + { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" }, + { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" }, + { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" }, + { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" }, + { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" }, + { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" }, + { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" }, + { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" }, + { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" }, + { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" }, + { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" }, + { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" }, + { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" }, + { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" }, + { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" }, + { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" }, + { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" }, + { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" }, + { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" }, + { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" }, + { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" }, + { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" }, + { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" }, + { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" }, + { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" }, + { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" }, + { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8e/e500f8b0b77be4ff753ac94dc06b33d8f0d839377fee1b78e8c8d8f031bf/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:db476ab59b6765134de1d4fe96a1a9c96ddf091683599be0f26147ea1b2e4b88", size = 408250, upload-time = "2025-10-14T15:06:10.264Z" }, + { url = "https://files.pythonhosted.org/packages/bd/95/615e72cd27b85b61eec764a5ca51bd94d40b5adea5ff47567d9ebc4d275a/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89eef07eee5e9d1fda06e38822ad167a044153457e6fd997f8a858ab7564a336", size = 396117, upload-time = "2025-10-14T15:06:11.28Z" }, + { url = "https://files.pythonhosted.org/packages/c9/81/e7fe958ce8a7fb5c73cc9fb07f5aeaf755e6aa72498c57d760af760c91f8/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce19e06cbda693e9e7686358af9cd6f5d61312ab8b00488bc36f5aabbaf77e24", size = 450493, upload-time = "2025-10-14T15:06:12.321Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" }, +] + +[[package]] +name = "websockets" +version = "15.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" }, + { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" }, + { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" }, + { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" }, + { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" }, + { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" }, + { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" }, + { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" }, + { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" }, + { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" }, + { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" }, + { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" }, + { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" }, + { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" }, + { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" }, + { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" }, + { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" }, + { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" }, + { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" }, + { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" }, + { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" }, + { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" }, + { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" }, + { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" }, +] + +[[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/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" }, +] + +[[package]] +name = "zipp" +version = "3.23.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/21/093488dfc7cc8964ded15ab726fad40f25fd3d788fd741cc1c5a17d78ee8/zipp-3.23.1.tar.gz", hash = "sha256:32120e378d32cd9714ad503c1d024619063ec28aad2248dc6672ad13edfa5110", size = 25965, upload-time = "2026-04-13T23:21:46.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/8a/0861bec20485572fbddf3dfba2910e38fe249796cb73ecdeb74e07eeb8d3/zipp-3.23.1-py3-none-any.whl", hash = "sha256:0b3596c50a5c700c9cb40ba8d86d9f2cc4807e9bedb06bcdf7fac85633e444dc", size = 10378, upload-time = "2026-04-13T23:21:45.386Z" }, +] diff --git a/livekit-rtc/livekit/rtc/media_devices.py b/livekit-rtc/livekit/rtc/media_devices.py index 4958a9de..07cc5e75 100644 --- a/livekit-rtc/livekit/rtc/media_devices.py +++ b/livekit-rtc/livekit/rtc/media_devices.py @@ -493,6 +493,21 @@ def open_input( # Queue from callback to async task q: asyncio.Queue[AudioFrame] = asyncio.Queue(maxsize=queue_capacity) + def _enqueue_frame(frame: AudioFrame) -> None: + try: + q.put_nowait(frame) + except asyncio.QueueFull: + # Capture must never surface QueueFull on the event loop thread. + # Drop the oldest frame so the published mic stays close to realtime. + try: + q.get_nowait() + except asyncio.QueueEmpty: + return + try: + q.put_nowait(frame) + except asyncio.QueueFull: + pass + def _input_callback( indata: np.ndarray, frame_count: int, time_info: Any, status: Any ) -> None: @@ -532,9 +547,7 @@ def _input_callback( # Continue even if APM processing fails pass try: - # Non-blocking: drop if full - if not q.full(): - loop.call_soon_threadsafe(q.put_nowait, frame) + loop.call_soon_threadsafe(_enqueue_frame, frame) except Exception: pass diff --git a/livekit-rtc/livekit/rtc/participant.py b/livekit-rtc/livekit/rtc/participant.py index 54d7163c..d6a80a33 100644 --- a/livekit-rtc/livekit/rtc/participant.py +++ b/livekit-rtc/livekit/rtc/participant.py @@ -800,18 +800,37 @@ def _setup_preconnect_auto_send( if room is None: return - async def _on_participant_active(participant: RemoteParticipant) -> None: + def _send_buffer(participant: RemoteParticipant) -> None: + if not track.has_preconnect_buffer: + return + + task = asyncio.create_task( + track.send_preconnect_buffer(destination_identity=participant.identity) + ) + + def _on_done(task: asyncio.Task[None]) -> None: + try: + task.result() + except Exception: + logger.exception("failed to auto-send preconnect buffer") + + task.add_done_callback(_on_done) + + def _on_participant_active(participant: RemoteParticipant) -> None: if participant.identity != target_identity: return if not track.has_preconnect_buffer: return room.off("participant_active", _on_participant_active) - try: - await track.send_preconnect_buffer( - destination_identity=participant.identity - ) - except Exception: - logger.exception("failed to auto-send preconnect buffer") + _send_buffer(participant) + + participant = room.remote_participants.get(target_identity) + if ( + participant is not None + and participant.state == proto_participant.PARTICIPANT_STATE_ACTIVE + ): + _send_buffer(participant) + return room.on("participant_active", _on_participant_active) From f91e0f301df9383f944d3d3391ceea58ce8fb04b Mon Sep 17 00:00:00 2001 From: David Chen Date: Fri, 1 May 2026 13:16:12 -0700 Subject: [PATCH 3/7] uv lock --- examples/wakeword_agent_dispatch/uv.lock | 177 +---------------------- 1 file changed, 2 insertions(+), 175 deletions(-) diff --git a/examples/wakeword_agent_dispatch/uv.lock b/examples/wakeword_agent_dispatch/uv.lock index 12a51cb6..25abc068 100644 --- a/examples/wakeword_agent_dispatch/uv.lock +++ b/examples/wakeword_agent_dispatch/uv.lock @@ -800,20 +800,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/08/22/e0a5fc0f3f4145c46fbf5a373c2c199571685b57ac275fdcbb42444862ab/livekit_agents-1.5.6-py3-none-any.whl", hash = "sha256:8c4cf05e20a5b2c7127d3d2ad8f8fa0e6f3aa753cfa00b4099b8a59471bd428c", size = 2585534, upload-time = "2026-04-22T20:21:29.412Z" }, ] -[package.optional-dependencies] -codecs = [ - { name = "numpy" }, -] -images = [ - { name = "pillow" }, -] -openai = [ - { name = "livekit-plugins-openai" }, -] -xai = [ - { name = "livekit-plugins-xai" }, -] - [[package]] name = "livekit-api" source = { editable = "../../livekit-api" } @@ -866,31 +852,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/60/93/c00c175d2187160bdb2dac6b338203d51396307dfce23f03defb3b5e5572/livekit_blingfire-1.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91b2315e0497383384304d33554d70b8a63dec5ad96cd43437c67f4172077cf", size = 141072, upload-time = "2025-12-16T00:48:33.423Z" }, ] -[[package]] -name = "livekit-plugins-openai" -version = "1.5.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "livekit-agents", extra = ["codecs", "images"] }, - { name = "openai", extra = ["realtime"] }, -] -sdist = { url = "https://files.pythonhosted.org/packages/f2/90/11573bd130ce6bb173c3ae24a2dc23b3f040504ddb99ea4d47548d7a4e0a/livekit_plugins_openai-1.5.6.tar.gz", hash = "sha256:e6c8fa6560f5adcbb47b61d674749805b9e7df64b3dd44421ddc2529b506f12c", size = 43026, upload-time = "2026-04-22T20:23:01.512Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cf/0a/0f55f595ea6075a80234df26cdadf3d863de051cd2211d8fc3e4139c9622/livekit_plugins_openai-1.5.6-py3-none-any.whl", hash = "sha256:f7e8c14cbafbe837b271ff5c0e6fff7292ef536d50c00f48da3b23823e1aaea9", size = 49797, upload-time = "2026-04-22T20:23:00.253Z" }, -] - -[[package]] -name = "livekit-plugins-xai" -version = "1.5.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "livekit-agents", extra = ["openai"] }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e3/a1/eaad8e48fc8318565de679e6c5294fc83917917a2edc2673c045aa77cd69/livekit_plugins_xai-1.5.6.tar.gz", hash = "sha256:caf7561c6cde0bcf77145454f64378174bcbaba20f5d226ba3afb869de2636dd", size = 12279, upload-time = "2026-04-22T20:23:48.031Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4a/57/2331e7d174154c4a47c8cf3df290262a7054e41a138854f210ad1abeefba/livekit_plugins_xai-1.5.6-py3-none-any.whl", hash = "sha256:e52c534ff279690762cebd39eaf4269b88322a56ef7b0f8082286d2204523f9c", size = 16227, upload-time = "2026-04-22T20:23:46.771Z" }, -] - [[package]] name = "livekit-protocol" source = { editable = "../../livekit-protocol" } @@ -1200,11 +1161,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7d/32/37734d769bc8b42e4938785313cc05aade6cb0fa72479d3220a0d61a4e78/openai-2.33.0-py3-none-any.whl", hash = "sha256:03ac37d70e8c9e3a8124214e3afa785e2cbc12e627fbd98177a086ef2fd87ad5", size = 1162695, upload-time = "2026-04-28T14:04:40.482Z" }, ] -[package.optional-dependencies] -realtime = [ - { name = "websockets" }, -] - [[package]] name = "opentelemetry-api" version = "1.39.1" @@ -1327,93 +1283,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, ] -[[package]] -name = "pillow" -version = "12.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, - { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, - { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, - { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, - { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, - { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, - { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, - { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, - { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, - { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, - { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, - { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, - { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, - { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, - { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, - { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, - { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, - { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, - { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, - { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, - { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, - { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, - { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, - { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, - { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, - { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, - { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, - { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, - { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, - { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, - { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, - { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, - { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, - { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, - { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, - { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, - { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, - { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, - { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, - { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, - { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, - { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, - { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, - { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, - { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, - { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, - { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, - { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, - { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, - { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, - { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, - { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, - { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, - { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, - { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, - { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, - { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, - { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, - { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, - { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, - { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, - { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, - { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, - { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, - { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, - { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, - { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, - { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, - { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, - { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, - { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, - { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, - { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, - { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, - { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, - { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, - { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, - { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, - { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, -] - [[package]] name = "prometheus-client" version = "0.25.0" @@ -1852,7 +1721,7 @@ version = "0.1.0" source = { virtual = "." } dependencies = [ { name = "livekit" }, - { name = "livekit-agents", extra = ["xai"] }, + { name = "livekit-agents" }, { name = "livekit-api" }, { name = "livekit-protocol" }, { name = "livekit-wakeword" }, @@ -1863,7 +1732,7 @@ dependencies = [ [package.metadata] requires-dist = [ { name = "livekit", editable = "../../livekit-rtc" }, - { name = "livekit-agents", extras = ["xai"], specifier = ">=1.5.0" }, + { name = "livekit-agents", specifier = ">=1.3.0" }, { name = "livekit-api", editable = "../../livekit-api" }, { name = "livekit-protocol", editable = "../../livekit-protocol" }, { name = "livekit-wakeword", specifier = ">=0.1.1" }, @@ -1958,48 +1827,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" }, ] -[[package]] -name = "websockets" -version = "15.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" }, - { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" }, - { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" }, - { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" }, - { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" }, - { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" }, - { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" }, - { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" }, - { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" }, - { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" }, - { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" }, - { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" }, - { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" }, - { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" }, - { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" }, - { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" }, - { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" }, - { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" }, - { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" }, - { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" }, - { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" }, - { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" }, - { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" }, - { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" }, - { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" }, - { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" }, - { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" }, - { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" }, - { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" }, - { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" }, - { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" }, - { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" }, - { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" }, - { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" }, -] - [[package]] name = "yarl" version = "1.23.0" From 8a7352374d5789da879bfa6b45678805d1dcc416 Mon Sep 17 00:00:00 2001 From: David Chen Date: Fri, 1 May 2026 13:42:17 -0700 Subject: [PATCH 4/7] cleanup audio devices upon shutdown --- examples/wakeword_agent_dispatch/client.py | 62 ++++++++++++++++++++-- 1 file changed, 59 insertions(+), 3 deletions(-) diff --git a/examples/wakeword_agent_dispatch/client.py b/examples/wakeword_agent_dispatch/client.py index a6a0b3ff..40ae2422 100644 --- a/examples/wakeword_agent_dispatch/client.py +++ b/examples/wakeword_agent_dispatch/client.py @@ -4,6 +4,7 @@ import contextlib import logging import os +import signal from collections import deque from dataclasses import dataclass from enum import Enum @@ -246,6 +247,28 @@ def _drain_audio_queue(audio_queue: asyncio.Queue[MicChunk]) -> int: return drained +async def _wait_mic_chunk_or_shutdown( + audio_queue: asyncio.Queue[MicChunk], + shutdown: asyncio.Event, +) -> MicChunk | None: + """Return the next mic chunk, or None when shutdown was requested.""" + if shutdown.is_set(): + return None + get_chunk = asyncio.create_task(audio_queue.get()) + wait_shutdown = asyncio.create_task(shutdown.wait()) + done, pending = await asyncio.wait( + {get_chunk, wait_shutdown}, + return_when=asyncio.FIRST_COMPLETED, + ) + for task in pending: + task.cancel() + with contextlib.suppress(asyncio.CancelledError): + await task + if wait_shutdown in done: + return None + return get_chunk.result() + + def _reset_wakeword_model(model: Any) -> None: reset = getattr(model, "reset", None) if callable(reset): @@ -284,6 +307,7 @@ async def _run_audio_loop( room: rtc.Room, lkapi: api.LiveKitAPI, config: Config, + shutdown: asyncio.Event, ) -> None: preroll = PrerollBuffer(config.wakeword_preroll_seconds) wakeword_window = WakeWordAudioWindow(WAKEWORD_WINDOW_SAMPLES) @@ -370,7 +394,10 @@ def _on_dispatch_done(task: asyncio.Task[str]) -> None: try: while True: - chunk = await audio_queue.get() + chunk = await _wait_mic_chunk_or_shutdown(audio_queue, shutdown) + if chunk is None: + logger.info("audio loop stopping (shutdown requested)") + break if state.mode == ClientMode.IDLE: preroll.append(chunk) @@ -429,6 +456,8 @@ async def main() -> None: from livekit.wakeword import WakeWordModel + shutdown_event = asyncio.Event() + model = WakeWordModel(models=[str(config.wakeword_model)]) room = rtc.Room() lkapi = api.LiveKitAPI(config.url, config.api_key, config.api_secret) @@ -533,10 +562,26 @@ def _on_track_unsubscribed( .to_jwt() ) + loop = asyncio.get_running_loop() + signal_handlers_registered = False + + def _request_shutdown() -> None: + if not shutdown_event.is_set(): + logger.info("shutdown requested; stopping wake word client…") + shutdown_event.set() + try: await room.connect(config.url, token) logger.info("connected to room %s", room.name) + try: + for sig in (signal.SIGINT, signal.SIGTERM): + loop.add_signal_handler(sig, _request_shutdown) + signal_handlers_registered = True + except (NotImplementedError, RuntimeError): + # Some platforms (e.g. Windows) may not support signal handlers on the event loop. + pass + track = rtc.LocalAudioTrack.create_audio_track("wakeword-mic", mic.source) options = rtc.TrackPublishOptions() @@ -556,15 +601,26 @@ def _on_track_unsubscribed( room, lkapi, config, + shutdown_event, ) finally: + if signal_handlers_registered: + for sig in (signal.SIGINT, signal.SIGTERM): + with contextlib.suppress(Exception): + loop.remove_signal_handler(sig) + for task in list(background_tasks): task.cancel() for task in list(background_tasks): with contextlib.suppress(asyncio.CancelledError): await task - await mic.aclose() - await player.aclose() + + # Close playback before capture so PortAudio + AEC reverse path tear down cleanly. + with contextlib.suppress(Exception): + await player.aclose() + with contextlib.suppress(Exception): + await mic.aclose() + room.unregister_text_stream_handler("lk.transcription") await lkapi.aclose() await room.disconnect() From 1ded16252bffe7d4edd9d4390095d76ca642b480 Mon Sep 17 00:00:00 2001 From: David Chen Date: Fri, 1 May 2026 13:44:16 -0700 Subject: [PATCH 5/7] clean up & remove join delay --- examples/wakeword_agent_dispatch/.env.example | 11 ----------- examples/wakeword_agent_dispatch/agent.py | 11 +++-------- 2 files changed, 3 insertions(+), 19 deletions(-) diff --git a/examples/wakeword_agent_dispatch/.env.example b/examples/wakeword_agent_dispatch/.env.example index 59327b43..73e2a0d9 100644 --- a/examples/wakeword_agent_dispatch/.env.example +++ b/examples/wakeword_agent_dispatch/.env.example @@ -15,14 +15,3 @@ LIVEKIT_WAKEWORD_THRESHOLD=0.5 LIVEKIT_WAKEWORD_PREROLL_SECONDS=2.0 LIVEKIT_PRECONNECT_BUFFER_SECONDS=10.0 LIVEKIT_AGENT_WAIT_TIMEOUT=30.0 -LIVEKIT_AGENT_JOIN_DELAY_SECONDS=2.0 - -# Voice pipeline model settings for agent.py -LIVEKIT_AGENT_STT_MODEL=deepgram/nova-3 -LIVEKIT_AGENT_LLM_MODEL=openai/gpt-4o-mini -LIVEKIT_AGENT_TTS_MODEL=cartesia/sonic-2 - -# Provider API keys used by the default voice pipeline models -DEEPGRAM_API_KEY= -OPENAI_API_KEY= -CARTESIA_API_KEY= diff --git a/examples/wakeword_agent_dispatch/agent.py b/examples/wakeword_agent_dispatch/agent.py index 0383f5e0..4c786bd1 100644 --- a/examples/wakeword_agent_dispatch/agent.py +++ b/examples/wakeword_agent_dispatch/agent.py @@ -28,9 +28,9 @@ def __init__(self) -> None: "'bye livekit' or otherwise clearly asks to end the conversation, call " "the end_session tool immediately." ), - stt=os.getenv("LIVEKIT_AGENT_STT_MODEL", "deepgram/nova-3"), - llm=os.getenv("LIVEKIT_AGENT_LLM_MODEL", "openai/gpt-4o-mini"), - tts=os.getenv("LIVEKIT_AGENT_TTS_MODEL", "cartesia/sonic-2"), + stt="deepgram/nova-3", + llm="openai/gpt-4o-mini", + tts="cartesia/sonic-2", ) @function_tool(name="end_session") @@ -49,7 +49,6 @@ async def end_session(self, ctx: RunContext) -> None: async def entrypoint(ctx: JobContext) -> None: session = AgentSession() closed = asyncio.get_running_loop().create_future() - join_delay = float(os.getenv("LIVEKIT_AGENT_JOIN_DELAY_SECONDS", "2.0")) pre_connect_audio_timeout = float( os.getenv("LIVEKIT_AGENT_PRECONNECT_AUDIO_TIMEOUT_SECONDS", "10.0") ) @@ -71,10 +70,6 @@ def _on_user_input_transcribed(ev) -> None: def _on_conversation_item_added(ev) -> None: logger.info("conversation item added: %s", ev.item) - if join_delay > 0: - logger.info("delaying agent room join by %.1f seconds", join_delay) - await asyncio.sleep(join_delay) - await session.start( agent=BasicAssistant(), room=ctx.room, From a26fcba02d8e1180868ac980551e27603a9aa329 Mon Sep 17 00:00:00 2001 From: David Chen Date: Fri, 1 May 2026 14:42:35 -0700 Subject: [PATCH 6/7] fix buffer gap --- examples/wakeword_agent_dispatch/.env.example | 10 + examples/wakeword_agent_dispatch/agent.py | 14 +- examples/wakeword_agent_dispatch/client.py | 198 ++++++++++++++---- .../wakeword_agent_dispatch/pyproject.toml | 2 +- examples/wakeword_agent_dispatch/uv.lock | 177 +++++++++++++++- 5 files changed, 353 insertions(+), 48 deletions(-) diff --git a/examples/wakeword_agent_dispatch/.env.example b/examples/wakeword_agent_dispatch/.env.example index 73e2a0d9..b2c2be9d 100644 --- a/examples/wakeword_agent_dispatch/.env.example +++ b/examples/wakeword_agent_dispatch/.env.example @@ -1,3 +1,10 @@ +# xAI Grok Voice Agent API (see https://docs.livekit.io/agents/models/realtime/plugins/xai/) +XAI_API_KEY= + +# Optional: voice (Ara, Eve, Leo, Rex, Sal) and model override +# LIVEKIT_AGENT_XAI_VOICE=Ara +# LIVEKIT_AGENT_XAI_MODEL=grok-voice-fast-1.0 + # LiveKit connection settings LIVEKIT_URL=wss://your-project.livekit.cloud LIVEKIT_API_KEY= @@ -15,3 +22,6 @@ LIVEKIT_WAKEWORD_THRESHOLD=0.5 LIVEKIT_WAKEWORD_PREROLL_SECONDS=2.0 LIVEKIT_PRECONNECT_BUFFER_SECONDS=10.0 LIVEKIT_AGENT_WAIT_TIMEOUT=30.0 + +# Debug directory to write preconnect buffer WAV files +LIVEKIT_PRECONNECT_DEBUG_WAV=./debug \ No newline at end of file diff --git a/examples/wakeword_agent_dispatch/agent.py b/examples/wakeword_agent_dispatch/agent.py index 4c786bd1..21a256c4 100644 --- a/examples/wakeword_agent_dispatch/agent.py +++ b/examples/wakeword_agent_dispatch/agent.py @@ -15,10 +15,20 @@ function_tool, room_io, ) +from livekit.plugins import xai logger = logging.getLogger("wakeword-agent") +def _xai_realtime_model() -> xai.realtime.RealtimeModel: + """Grok Voice Agent API (OpenAI Realtime–compatible) end-to-end voice model.""" + voice = os.getenv("LIVEKIT_AGENT_XAI_VOICE", "Ara") + model = os.getenv("LIVEKIT_AGENT_XAI_MODEL", "").strip() + if model: + return xai.realtime.RealtimeModel(model=model, voice=voice) + return xai.realtime.RealtimeModel(voice=voice) + + class BasicAssistant(Agent): def __init__(self) -> None: super().__init__( @@ -28,9 +38,7 @@ def __init__(self) -> None: "'bye livekit' or otherwise clearly asks to end the conversation, call " "the end_session tool immediately." ), - stt="deepgram/nova-3", - llm="openai/gpt-4o-mini", - tts="cartesia/sonic-2", + llm=_xai_realtime_model(), ) @function_tool(name="end_session") diff --git a/examples/wakeword_agent_dispatch/client.py b/examples/wakeword_agent_dispatch/client.py index 40ae2422..f9893040 100644 --- a/examples/wakeword_agent_dispatch/client.py +++ b/examples/wakeword_agent_dispatch/client.py @@ -2,14 +2,16 @@ import asyncio import contextlib +import datetime import logging import os import signal +import wave from collections import deque from dataclasses import dataclass from enum import Enum from pathlib import Path -from typing import Any, Deque, Iterable, Optional +from typing import Any, Deque, Optional import numpy as np from dotenv import find_dotenv, load_dotenv @@ -21,6 +23,7 @@ WAKEWORD_WINDOW_SAMPLES = 2 * WAKEWORD_SAMPLE_RATE OUTPUT_SAMPLE_RATE = 48_000 OUTPUT_FRAME_SAMPLES = 480 # 10 ms at 48 kHz +PRE_CONNECT_AUDIO_BUFFER_TOPIC = "lk.agent.pre-connect-audio-buffer" logger = logging.getLogger("wakeword-agent-dispatch") @@ -37,6 +40,7 @@ class Config: wakeword_threshold: float wakeword_preroll_seconds: float preconnect_buffer_seconds: float + preconnect_debug_wav: Path | None agent_metadata: str agent_wait_timeout: float @@ -67,6 +71,11 @@ def from_env() -> "Config": preconnect_buffer_seconds=float( os.getenv("LIVEKIT_PRECONNECT_BUFFER_SECONDS", "10.0") ), + preconnect_debug_wav=( + Path(debug_wav).expanduser() + if (debug_wav := os.getenv("LIVEKIT_PRECONNECT_DEBUG_WAV")) + else None + ), agent_metadata=os.getenv("LIVEKIT_AGENT_METADATA", ""), agent_wait_timeout=float(os.getenv("LIVEKIT_AGENT_WAIT_TIMEOUT", "30.0")), ) @@ -78,22 +87,34 @@ class MicChunk: samples_per_channel: int -class PrerollBuffer: +class PreconnectAudioBuffer: def __init__(self, max_duration: float) -> None: - self._max_samples = max(1, int(max_duration * SAMPLE_RATE)) + self._max_samples = self._duration_to_samples(max_duration) self._chunks: Deque[MicChunk] = deque() self._samples = 0 + @staticmethod + def _duration_to_samples(duration: float) -> int: + return max(1, int(duration * SAMPLE_RATE)) + + def set_max_duration(self, max_duration: float) -> None: + self._max_samples = self._duration_to_samples(max_duration) + self._trim() + def append(self, chunk: MicChunk) -> None: self._chunks.append(chunk) self._samples += chunk.samples_per_channel + self._trim() + def _trim(self) -> None: while self._samples > self._max_samples and len(self._chunks) > 1: dropped = self._chunks.popleft() self._samples -= dropped.samples_per_channel - def snapshot(self) -> list[MicChunk]: - return list(self._chunks) + def capture(self) -> bytes: + data = b"".join(chunk.data for chunk in self._chunks) + self.clear() + return data def clear(self) -> None: self._chunks.clear() @@ -200,41 +221,117 @@ def _on_participant_active(participant: rtc.RemoteParticipant) -> None: room.off("participant_active", _on_participant_active) -def _push_preroll_to_preconnect_buffer( +def _preconnect_debug_wav_path(path: Path) -> Path: + if path.suffix.lower() == ".wav": + return path + + timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S-%f") + return path / f"preconnect-buffer-{timestamp}.wav" + + +def _write_preconnect_debug_wav( + path: Path, + pcm_data: bytes, + *, + sample_rate: int, + num_channels: int, +) -> Path: + output_path = _preconnect_debug_wav_path(path) + output_path.parent.mkdir(parents=True, exist_ok=True) + + with wave.open(str(output_path), "wb") as wav_file: + wav_file.setnchannels(num_channels) + wav_file.setsampwidth(2) + wav_file.setframerate(sample_rate) + wav_file.writeframes(pcm_data) + + return output_path + + +async def _send_preconnect_buffer( track: rtc.LocalAudioTrack, - chunks: Iterable[MicChunk], + audio_queue: asyncio.Queue[MicChunk], + preconnect_buffer: PreconnectAudioBuffer, + *, + destination_identity: str, + debug_wav: Path | None, ) -> None: - preconnect_buffer = getattr(track, "_preconnect_buffer", None) - if preconnect_buffer is None: - raise RuntimeError("pre-connect buffer was not started") + participant = getattr(track, "_participant", None) + if participant is None: + raise RuntimeError("track is not published") + + source = getattr(track, "_source", None) + if source is None: + raise RuntimeError("track has no audio source") + + async with track._send_lock: + drained = _drain_audio_queue_to_buffer(audio_queue, preconnect_buffer) + if drained: + logger.info("included %d queued audio chunks in pre-connect buffer", drained) + + data = preconnect_buffer.capture() + if not data: + return - for chunk in chunks: - preconnect_buffer.push(_chunk_to_audio_frame(chunk)) + if debug_wav is not None: + output_path = _write_preconnect_debug_wav( + debug_wav, + data, + sample_rate=source.sample_rate, + num_channels=source.num_channels, + ) + duration = len(data) / (source.sample_rate * source.num_channels * 2) + logger.info( + "wrote pre-connect buffer debug WAV %s (%.2fs, %d bytes)", + output_path, + duration, + len(data), + ) + + writer = await participant.stream_bytes( + "preconnect-buffer", + topic=PRE_CONNECT_AUDIO_BUFFER_TOPIC, + mime_type="application/octet-stream", + destination_identities=[destination_identity], + attributes={ + "trackId": track._publication_sid or track.sid, + "sampleRate": str(source.sample_rate), + "channels": str(source.num_channels), + }, + ) + + await writer.write(data) + await writer.aclose() async def _dispatch_agent_and_send_buffer( lkapi: api.LiveKitAPI, room: rtc.Room, track: rtc.LocalAudioTrack, + audio_queue: asyncio.Queue[MicChunk], + preconnect_buffer: PreconnectAudioBuffer, config: Config, ) -> str: - try: - dispatch = await lkapi.agent_dispatch.create_dispatch( - api.CreateAgentDispatchRequest( - agent_name=config.agent_name, - room=config.room_name, - metadata=config.agent_metadata, - ) + dispatch = await lkapi.agent_dispatch.create_dispatch( + api.CreateAgentDispatchRequest( + agent_name=config.agent_name, + room=config.room_name, + metadata=config.agent_metadata, ) - logger.info("created dispatch %s for agent %s", dispatch.id, config.agent_name) - - agent = await _wait_for_active_agent(room, timeout=config.agent_wait_timeout) - logger.info("agent participant %s is active; sending buffered audio", agent.identity) - await track.send_preconnect_buffer(destination_identity=agent.identity) - logger.info("sent pre-connect buffer to %s", agent.identity) - return agent.identity - finally: - track.stop_preconnect_buffer() + ) + logger.info("created dispatch %s for agent %s", dispatch.id, config.agent_name) + + agent = await _wait_for_active_agent(room, timeout=config.agent_wait_timeout) + logger.info("agent participant %s is active; sending buffered audio", agent.identity) + await _send_preconnect_buffer( + track, + audio_queue, + preconnect_buffer, + destination_identity=agent.identity, + debug_wav=config.preconnect_debug_wav, + ) + logger.info("sent pre-connect buffer to %s", agent.identity) + return agent.identity def _drain_audio_queue(audio_queue: asyncio.Queue[MicChunk]) -> int: @@ -247,6 +344,20 @@ def _drain_audio_queue(audio_queue: asyncio.Queue[MicChunk]) -> int: return drained +def _drain_audio_queue_to_buffer( + audio_queue: asyncio.Queue[MicChunk], + preconnect_buffer: PreconnectAudioBuffer, +) -> int: + drained = 0 + while True: + try: + chunk = audio_queue.get_nowait() + except asyncio.QueueEmpty: + return drained + preconnect_buffer.append(chunk) + drained += 1 + + async def _wait_mic_chunk_or_shutdown( audio_queue: asyncio.Queue[MicChunk], shutdown: asyncio.Event, @@ -309,7 +420,7 @@ async def _run_audio_loop( config: Config, shutdown: asyncio.Event, ) -> None: - preroll = PrerollBuffer(config.wakeword_preroll_seconds) + preconnect_buffer = PreconnectAudioBuffer(config.wakeword_preroll_seconds) wakeword_window = WakeWordAudioWindow(WAKEWORD_WINDOW_SAMPLES) wakeword_resampler = rtc.AudioResampler(SAMPLE_RATE, WAKEWORD_SAMPLE_RATE) state = ClientState() @@ -323,9 +434,9 @@ def _reset_to_idle(reason: str, *, cancel_dispatch: bool = True) -> None: state.dispatch_task = None state.agent_identity = None state.mode = ClientMode.IDLE - track.stop_preconnect_buffer() source.clear_queue() - preroll.clear() + preconnect_buffer.set_max_duration(config.wakeword_preroll_seconds) + preconnect_buffer.clear() wakeword_window.clear() wakeword_resampler = rtc.AudioResampler(SAMPLE_RATE, WAKEWORD_SAMPLE_RATE) drained = _drain_audio_queue(audio_queue) @@ -399,9 +510,10 @@ def _on_dispatch_done(task: asyncio.Task[str]) -> None: logger.info("audio loop stopping (shutdown requested)") break - if state.mode == ClientMode.IDLE: - preroll.append(chunk) + if state.mode in (ClientMode.IDLE, ClientMode.DISPATCHING): + preconnect_buffer.append(chunk) + if state.mode == ClientMode.IDLE: for wakeword_frame in wakeword_resampler.push(_chunk_to_audio_frame(chunk)): samples = np.frombuffer(wakeword_frame.data, dtype=np.int16) wakeword_window.append(samples) @@ -423,17 +535,19 @@ def _on_dispatch_done(task: asyncio.Task[str]) -> None: confidence, ) - track.start_preconnect_buffer( - max_duration=config.preconnect_buffer_seconds - ) - - # The SDK buffer only captures after it starts. Because this loop - # observes the already-published mic track, include the full preroll. - preroll_chunks = preroll.snapshot() - _push_preroll_to_preconnect_buffer(track, preroll_chunks) + # Keep one ordered buffer from the monitor stream so the wakeword + # preroll and dispatch audio do not cross timing domains. + preconnect_buffer.set_max_duration(config.preconnect_buffer_seconds) state.dispatch_task = asyncio.create_task( - _dispatch_agent_and_send_buffer(lkapi, room, track, config) + _dispatch_agent_and_send_buffer( + lkapi, + room, + track, + audio_queue, + preconnect_buffer, + config, + ) ) state.dispatch_task.add_done_callback(_on_dispatch_done) finally: diff --git a/examples/wakeword_agent_dispatch/pyproject.toml b/examples/wakeword_agent_dispatch/pyproject.toml index 7df4b743..3e7c9923 100644 --- a/examples/wakeword_agent_dispatch/pyproject.toml +++ b/examples/wakeword_agent_dispatch/pyproject.toml @@ -5,7 +5,7 @@ description = "Wake word-triggered LiveKit agent dispatch with pre-connect audio requires-python = ">=3.11" dependencies = [ "livekit", - "livekit-agents>=1.3.0", + "livekit-agents[xai]>=1.3.0", "livekit-api", "livekit-protocol", "livekit-wakeword>=0.1.1", diff --git a/examples/wakeword_agent_dispatch/uv.lock b/examples/wakeword_agent_dispatch/uv.lock index 25abc068..7b462eee 100644 --- a/examples/wakeword_agent_dispatch/uv.lock +++ b/examples/wakeword_agent_dispatch/uv.lock @@ -800,6 +800,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/08/22/e0a5fc0f3f4145c46fbf5a373c2c199571685b57ac275fdcbb42444862ab/livekit_agents-1.5.6-py3-none-any.whl", hash = "sha256:8c4cf05e20a5b2c7127d3d2ad8f8fa0e6f3aa753cfa00b4099b8a59471bd428c", size = 2585534, upload-time = "2026-04-22T20:21:29.412Z" }, ] +[package.optional-dependencies] +codecs = [ + { name = "numpy" }, +] +images = [ + { name = "pillow" }, +] +openai = [ + { name = "livekit-plugins-openai" }, +] +xai = [ + { name = "livekit-plugins-xai" }, +] + [[package]] name = "livekit-api" source = { editable = "../../livekit-api" } @@ -852,6 +866,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/60/93/c00c175d2187160bdb2dac6b338203d51396307dfce23f03defb3b5e5572/livekit_blingfire-1.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91b2315e0497383384304d33554d70b8a63dec5ad96cd43437c67f4172077cf", size = 141072, upload-time = "2025-12-16T00:48:33.423Z" }, ] +[[package]] +name = "livekit-plugins-openai" +version = "1.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "livekit-agents", extra = ["codecs", "images"] }, + { name = "openai", extra = ["realtime"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f2/90/11573bd130ce6bb173c3ae24a2dc23b3f040504ddb99ea4d47548d7a4e0a/livekit_plugins_openai-1.5.6.tar.gz", hash = "sha256:e6c8fa6560f5adcbb47b61d674749805b9e7df64b3dd44421ddc2529b506f12c", size = 43026, upload-time = "2026-04-22T20:23:01.512Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/0a/0f55f595ea6075a80234df26cdadf3d863de051cd2211d8fc3e4139c9622/livekit_plugins_openai-1.5.6-py3-none-any.whl", hash = "sha256:f7e8c14cbafbe837b271ff5c0e6fff7292ef536d50c00f48da3b23823e1aaea9", size = 49797, upload-time = "2026-04-22T20:23:00.253Z" }, +] + +[[package]] +name = "livekit-plugins-xai" +version = "1.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "livekit-agents", extra = ["openai"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e3/a1/eaad8e48fc8318565de679e6c5294fc83917917a2edc2673c045aa77cd69/livekit_plugins_xai-1.5.6.tar.gz", hash = "sha256:caf7561c6cde0bcf77145454f64378174bcbaba20f5d226ba3afb869de2636dd", size = 12279, upload-time = "2026-04-22T20:23:48.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/57/2331e7d174154c4a47c8cf3df290262a7054e41a138854f210ad1abeefba/livekit_plugins_xai-1.5.6-py3-none-any.whl", hash = "sha256:e52c534ff279690762cebd39eaf4269b88322a56ef7b0f8082286d2204523f9c", size = 16227, upload-time = "2026-04-22T20:23:46.771Z" }, +] + [[package]] name = "livekit-protocol" source = { editable = "../../livekit-protocol" } @@ -1161,6 +1200,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7d/32/37734d769bc8b42e4938785313cc05aade6cb0fa72479d3220a0d61a4e78/openai-2.33.0-py3-none-any.whl", hash = "sha256:03ac37d70e8c9e3a8124214e3afa785e2cbc12e627fbd98177a086ef2fd87ad5", size = 1162695, upload-time = "2026-04-28T14:04:40.482Z" }, ] +[package.optional-dependencies] +realtime = [ + { name = "websockets" }, +] + [[package]] name = "opentelemetry-api" version = "1.39.1" @@ -1283,6 +1327,93 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, ] +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + [[package]] name = "prometheus-client" version = "0.25.0" @@ -1721,7 +1852,7 @@ version = "0.1.0" source = { virtual = "." } dependencies = [ { name = "livekit" }, - { name = "livekit-agents" }, + { name = "livekit-agents", extra = ["xai"] }, { name = "livekit-api" }, { name = "livekit-protocol" }, { name = "livekit-wakeword" }, @@ -1732,7 +1863,7 @@ dependencies = [ [package.metadata] requires-dist = [ { name = "livekit", editable = "../../livekit-rtc" }, - { name = "livekit-agents", specifier = ">=1.3.0" }, + { name = "livekit-agents", extras = ["xai"], specifier = ">=1.3.0" }, { name = "livekit-api", editable = "../../livekit-api" }, { name = "livekit-protocol", editable = "../../livekit-protocol" }, { name = "livekit-wakeword", specifier = ">=0.1.1" }, @@ -1827,6 +1958,48 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" }, ] +[[package]] +name = "websockets" +version = "15.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" }, + { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" }, + { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" }, + { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" }, + { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" }, + { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" }, + { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" }, + { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" }, + { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" }, + { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" }, + { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" }, + { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" }, + { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" }, + { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" }, + { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" }, + { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" }, + { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" }, + { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" }, + { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" }, + { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" }, + { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" }, + { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" }, + { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" }, + { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" }, +] + [[package]] name = "yarl" version = "1.23.0" From ca1b56b59a8975994cee8ab9dac527d48332042c Mon Sep 17 00:00:00 2001 From: David Chen Date: Fri, 1 May 2026 18:06:23 -0700 Subject: [PATCH 7/7] add config for audio devices --- examples/wakeword_agent_dispatch/.env.example | 4 ++ examples/wakeword_agent_dispatch/client.py | 54 +++++++++++++++++-- 2 files changed, 54 insertions(+), 4 deletions(-) diff --git a/examples/wakeword_agent_dispatch/.env.example b/examples/wakeword_agent_dispatch/.env.example index b2c2be9d..06e40132 100644 --- a/examples/wakeword_agent_dispatch/.env.example +++ b/examples/wakeword_agent_dispatch/.env.example @@ -15,6 +15,10 @@ LIVEKIT_ROOM=wakeword-preconnect LIVEKIT_AGENT_NAME=test-agent LIVEKIT_AGENT_METADATA= +# Optional PortAudio device indices. Leave blank to use system defaults. +LIVEKIT_AUDIO_INPUT_DEVICE= +LIVEKIT_AUDIO_OUTPUT_DEVICE= + # Wake word model settings LIVEKIT_WAKEWORD_MODEL=./models/hey_livekit.onnx LIVEKIT_WAKEWORD_NAME=hey_livekit diff --git a/examples/wakeword_agent_dispatch/client.py b/examples/wakeword_agent_dispatch/client.py index f9893040..e7898cd2 100644 --- a/examples/wakeword_agent_dispatch/client.py +++ b/examples/wakeword_agent_dispatch/client.py @@ -43,6 +43,8 @@ class Config: preconnect_debug_wav: Path | None agent_metadata: str agent_wait_timeout: float + audio_input_device: int | None + audio_output_device: int | None @staticmethod def from_env() -> "Config": @@ -78,8 +80,44 @@ def from_env() -> "Config": ), agent_metadata=os.getenv("LIVEKIT_AGENT_METADATA", ""), agent_wait_timeout=float(os.getenv("LIVEKIT_AGENT_WAIT_TIMEOUT", "30.0")), + audio_input_device=Config._optional_int_from_env( + "LIVEKIT_AUDIO_INPUT_DEVICE" + ), + audio_output_device=Config._optional_int_from_env( + "LIVEKIT_AUDIO_OUTPUT_DEVICE" + ), ) + @staticmethod + def _optional_int_from_env(name: str) -> int | None: + raw = os.getenv(name) + if raw is None or not raw.strip(): + return None + + try: + return int(raw) + except ValueError: + raise RuntimeError(f"{name} must be an integer device index") from None + + +def _describe_audio_device(device_index: int | None, kind: str) -> str: + import sounddevice as sd # type: ignore[import-not-found, import-untyped] + + selected_index = device_index + if selected_index is None: + default_device = sd.default.device + if isinstance(default_device, (list, tuple)): + selected_index = default_device[0 if kind == "input" else 1] + + if selected_index is None: + return "system default" + + try: + device = sd.query_devices(selected_index) + return f"{selected_index} ({device['name']})" + except Exception: + return str(selected_index) + @dataclass(frozen=True) class MicChunk: @@ -573,8 +611,6 @@ async def main() -> None: shutdown_event = asyncio.Event() model = WakeWordModel(models=[str(config.wakeword_model)]) - room = rtc.Room() - lkapi = api.LiveKitAPI(config.url, config.api_key, config.api_secret) audio_queue: asyncio.Queue[MicChunk] = asyncio.Queue(maxsize=100) devices = rtc.MediaDevices( input_sample_rate=SAMPLE_RATE, @@ -582,8 +618,18 @@ async def main() -> None: num_channels=NUM_CHANNELS, blocksize=OUTPUT_FRAME_SAMPLES, ) - mic = devices.open_input(enable_aec=True) - player = devices.open_output() + logger.info( + "using audio devices input=%s output=%s", + _describe_audio_device(config.audio_input_device, "input"), + _describe_audio_device(config.audio_output_device, "output"), + ) + mic = devices.open_input( + enable_aec=True, + input_device=config.audio_input_device, + ) + player = devices.open_output(output_device=config.audio_output_device) + room = rtc.Room() + lkapi = api.LiveKitAPI(config.url, config.api_key, config.api_secret) background_tasks: set[asyncio.Task[None]] = set() def _create_background_task(coro) -> None:

tCsr`aso9g+s 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 FTk#XFhdC zv$Jk&_4E=Pi1Fix?vY?xIDsE3r^8-lAD%z;G=DG}&m-JSP+ZVPx-&+@;W1G>({nJp zUi(Iq4V+QM-A*=U%|Q$peq4~ht{`q|a6o0#O<-jD4Hh3Vpn_GKa6)AQOs$OJmXR5_ zG~zt<2t3N?`o!aJzYOtH!8H7K@)e!BVaBr|lVUQGi8guRkXBRHYu?KXpDskX(oAeT zm_>zQ)4=bpopjqhM{euRLq+0qF*AG=Yh2D2*8G@`NjA@gX~x#9UbBl9EczuJ^6kX) zmLH=B@#9Eml{`?@h?dNhlv#rt68z!N01>?Ek~yyNJxrJ4-J_H|q~APwc(y})1~kN3%N>pwAc$Tqr|P$W{!B$#F~n}#P2<&xzRG1fQ{ z|8tI^Iq!DT#+n9diT@?8EG(j>-?N}|&^SEVF^zt#l)>3Rg8t8paD3A^+-Powx>c1R zN&MmcYhBDXnhBQ<-vdntEj(pBgwwhV=l4G?xLcpz@aLyHK924#ie?0#ChBv;mL{_O zCxZ+4ks>#n!tJJBX!*^QFRV4^iA&x>YlHzltX+gX_10sd*&=LOwi@2{s3N0?Zmbk+ zBU!t3`C9itSbT6cZk8Gj{*&@0;|gu@xkn=;O{&DRdol#4E4lRPKadowfTiPqfLr8O zVbbZ}l>4ogCi|sORZ%=|Y#3Xf5kHmZ_T9=|%0tC9`D^gi0aZL;R4Y1ka}$=uR?8k& znz8A?&h%4Xa(E2)mj%wTq=NAm;MnQT{LMr1YqZ<)$VsJuC0;oq_INILru<> z&7=IWSI9WzJ}b|VG8?64aCt%xDNiE6%j11z+GX*MK`(qTHCCJD>ovuFwY^#4D|1bi zJih5Xnyvn=XTyz2mj+&OLqluiynuPTY9{bkJ){|k29wn0;dq z_w`Z2F&bSU>$@fony$>PG2Jl?|a^W z+dF;mlV*WZ`SarM$T2+XW29sL-NS72)Pa&c!ugZjE4H~X0f%PP(~ejxDa#kg2J(-% z)9rECe();PC$&I`$5tWiRXyJCQ7dKk&e8QnMr?gT5jHPVgh>Oegy$n}g2$13@vyBW zG#%cHJH8V4n@*A9ur1VKHkl7u?Zm^w6+m+>(P&0|o1X`#e=h?w{r%A5*Fjf` zRoLaJGO0HXgnRwvSy5{``uA5u9~EV`U%XOCE-!)6BgcUR@d!s76j)#Bxo~dQN#Vbf zi>00HVX`~+Q~1{^ W)B>rAnt#j~MoWH4 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